# [ doc = r" Value read from the register" ] pub struct R { bits : u32 } # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 } impl super :: SHORTS { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & self , f : F ) where for < 'w > F : FnOnce ( & R , & 'w mut W ) -> & 'w mut W { let bits = self . register . get ( ) ; let r = R { bits : bits } ; let mut w = W { bits : bits } ; f ( & r , & mut w ) ; self . register . set ( w . bits ) ; } # [ doc = r" Reads the contents of the register" ] # [ inline ] pub fn read ( & self ) -> R { R { bits : self . register . get ( ) } } # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let mut w = W :: reset_value ( ) ; f ( & mut w ) ; 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 `ENDRX_STARTRX`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ENDRX_STARTRXR { # [ doc = "Disable shortcut" ] DISABLED , # [ doc = "Enable shortcut" ] ENABLED , } impl ENDRX_STARTRXR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { ENDRX_STARTRXR :: DISABLED => false , ENDRX_STARTRXR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> ENDRX_STARTRXR { match value { false => ENDRX_STARTRXR :: DISABLED , true => ENDRX_STARTRXR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == ENDRX_STARTRXR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == ENDRX_STARTRXR :: ENABLED } } # [ doc = "Possible values of the field `ENDRX_STOPRX`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ENDRX_STOPRXR { # [ doc = "Disable shortcut" ] DISABLED , # [ doc = "Enable shortcut" ] ENABLED , } impl ENDRX_STOPRXR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { ENDRX_STOPRXR :: DISABLED => false , ENDRX_STOPRXR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> ENDRX_STOPRXR { match value { false => ENDRX_STOPRXR :: DISABLED , true => ENDRX_STOPRXR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == ENDRX_STOPRXR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == ENDRX_STOPRXR :: ENABLED } } # [ doc = "Values that can be written to the field `ENDRX_STARTRX`" ] pub enum ENDRX_STARTRXW { # [ doc = "Disable shortcut" ] DISABLED , # [ doc = "Enable shortcut" ] ENABLED , } impl ENDRX_STARTRXW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { ENDRX_STARTRXW :: DISABLED => false , ENDRX_STARTRXW :: ENABLED => true , } } } # [ doc = r" Proxy" ] pub struct _ENDRX_STARTRXW < 'a > { w : & 'a mut W } impl < 'a > _ENDRX_STARTRXW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ENDRX_STARTRXW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Disable shortcut" ] # [ inline ] pub fn disabled ( self ) -> & 'a mut W { self . variant ( ENDRX_STARTRXW :: DISABLED ) } # [ doc = "Enable shortcut" ] # [ inline ] pub fn enabled ( self ) -> & 'a mut W { self . variant ( ENDRX_STARTRXW :: ENABLED ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub fn bit ( self , value : bool ) -> & 'a mut W { const MASK : 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 `ENDRX_STOPRX`" ] pub enum ENDRX_STOPRXW { # [ doc = "Disable shortcut" ] DISABLED , # [ doc = "Enable shortcut" ] ENABLED , } impl ENDRX_STOPRXW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { ENDRX_STOPRXW :: DISABLED => false , ENDRX_STOPRXW :: ENABLED => true , } } } # [ doc = r" Proxy" ] pub struct _ENDRX_STOPRXW < 'a > { w : & 'a mut W } impl < 'a > _ENDRX_STOPRXW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ENDRX_STOPRXW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Disable shortcut" ] # [ inline ] pub fn disabled ( self ) -> & 'a mut W { self . variant ( ENDRX_STOPRXW :: DISABLED ) } # [ doc = "Enable shortcut" ] # [ inline ] pub fn enabled ( self ) -> & 'a mut W { self . variant ( ENDRX_STOPRXW :: ENABLED ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub fn bit ( self , value : bool ) -> & 'a mut W { const 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 5 - Shortcut between ENDRX event and STARTRX task" ] # [ inline ] pub fn endrx_startrx ( & self ) -> ENDRX_STARTRXR { ENDRX_STARTRXR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 6 - Shortcut between ENDRX event and STOPRX task" ] # [ inline ] pub fn endrx_stoprx ( & self ) -> ENDRX_STOPRXR { ENDRX_STOPRXR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( 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 5 - Shortcut between ENDRX event and STARTRX task" ] # [ inline ] pub fn endrx_startrx ( & mut self ) -> _ENDRX_STARTRXW { _ENDRX_STARTRXW { w : self } } # [ doc = "Bit 6 - Shortcut between ENDRX event and STOPRX task" ] # [ inline ] pub fn endrx_stoprx ( & mut self ) -> _ENDRX_STOPRXW { _ENDRX_STOPRXW { w : self } } }