2017-09-23 18:09:53 +00:00
#[ doc = r " Value read from the register " ]
pub struct R {
bits : u32 ,
}
#[ doc = r " Value to write to the register " ]
pub struct W {
bits : u32 ,
}
impl super ::CTRL1 {
#[ doc = r " Modifies the contents of the register " ]
#[ inline ]
pub fn modify < F > ( & self , f : F )
where
for < ' w > F : FnOnce ( & R , & ' w mut W ) -> & ' w mut W ,
{
let bits = self . register . get ( ) ;
let r = R { bits : bits } ;
let mut w = W { bits : bits } ;
f ( & r , & mut w ) ;
self . register . set ( w . bits ) ;
}
#[ doc = r " Reads the contents of the register " ]
#[ inline ]
pub fn read ( & self ) -> R {
2017-09-23 18:31:10 +00:00
R {
bits : self . register . get ( ) ,
}
2017-09-23 18:09:53 +00:00
}
#[ doc = r " Writes to the register " ]
#[ inline ]
pub fn write < F > ( & self , f : F )
where
F : FnOnce ( & mut W ) -> & mut W ,
{
let mut w = W ::reset_value ( ) ;
f ( & mut w ) ;
self . register . set ( w . bits ) ;
}
#[ doc = r " Writes the reset value to the register " ]
#[ inline ]
pub fn reset ( & self ) {
self . write ( | w | w )
}
}
#[ doc = r " Value of the field " ]
pub struct PROPSEGR {
bits : u8 ,
}
impl PROPSEGR {
#[ doc = r " Value of the field as raw bits " ]
#[ inline ]
pub fn bits ( & self ) -> u8 {
self . bits
}
}
#[ doc = " Possible values of the field `LOM` " ]
#[ derive(Clone, Copy, Debug, PartialEq) ]
pub enum LOMR {
2018-02-06 14:15:10 +00:00
#[ doc = " Listen-Only mode is deactivated. " ]
_0 ,
#[ doc = " FlexCAN module operates in Listen-Only mode. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl LOMR {
#[ doc = r " Returns `true` if the bit is clear (0) " ]
#[ inline ]
pub fn bit_is_clear ( & self ) -> bool {
! self . bit ( )
}
#[ doc = r " 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 {
LOMR ::_0 = > false ,
LOMR ::_1 = > true ,
}
}
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _from ( value : bool ) -> LOMR {
match value {
false = > LOMR ::_0 ,
true = > LOMR ::_1 ,
}
}
#[ doc = " Checks if the value of the field is `_0` " ]
#[ inline ]
pub fn is_0 ( & self ) -> bool {
* self = = LOMR ::_0
}
#[ doc = " Checks if the value of the field is `_1` " ]
#[ inline ]
pub fn is_1 ( & self ) -> bool {
* self = = LOMR ::_1
}
}
#[ doc = " Possible values of the field `LBUF` " ]
#[ derive(Clone, Copy, Debug, PartialEq) ]
pub enum LBUFR {
2018-02-06 14:15:10 +00:00
#[ doc = " Buffer with highest priority is transmitted first. " ]
_0 ,
#[ doc = " Lowest number buffer is transmitted first. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl LBUFR {
#[ doc = r " Returns `true` if the bit is clear (0) " ]
#[ inline ]
pub fn bit_is_clear ( & self ) -> bool {
! self . bit ( )
}
#[ doc = r " 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 {
LBUFR ::_0 = > false ,
LBUFR ::_1 = > true ,
}
}
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _from ( value : bool ) -> LBUFR {
match value {
false = > LBUFR ::_0 ,
true = > LBUFR ::_1 ,
}
}
#[ doc = " Checks if the value of the field is `_0` " ]
#[ inline ]
pub fn is_0 ( & self ) -> bool {
* self = = LBUFR ::_0
}
#[ doc = " Checks if the value of the field is `_1` " ]
#[ inline ]
pub fn is_1 ( & self ) -> bool {
* self = = LBUFR ::_1
}
}
#[ doc = " Possible values of the field `TSYN` " ]
#[ derive(Clone, Copy, Debug, PartialEq) ]
pub enum TSYNR {
2018-02-06 14:15:10 +00:00
#[ doc = " Timer Sync feature disabled " ]
_0 ,
#[ doc = " Timer Sync feature enabled " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl TSYNR {
#[ doc = r " Returns `true` if the bit is clear (0) " ]
#[ inline ]
pub fn bit_is_clear ( & self ) -> bool {
! self . bit ( )
}
#[ doc = r " 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 {
TSYNR ::_0 = > false ,
TSYNR ::_1 = > true ,
}
}
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _from ( value : bool ) -> TSYNR {
match value {
false = > TSYNR ::_0 ,
true = > TSYNR ::_1 ,
}
}
#[ doc = " Checks if the value of the field is `_0` " ]
#[ inline ]
pub fn is_0 ( & self ) -> bool {
* self = = TSYNR ::_0
}
#[ doc = " Checks if the value of the field is `_1` " ]
#[ inline ]
pub fn is_1 ( & self ) -> bool {
* self = = TSYNR ::_1
}
}
#[ doc = " Possible values of the field `BOFFREC` " ]
#[ derive(Clone, Copy, Debug, PartialEq) ]
pub enum BOFFRECR {
2018-02-06 14:15:10 +00:00
#[ doc = " Automatic recovering from Bus Off state enabled. " ]
_0 ,
#[ doc = " Automatic recovering from Bus Off state disabled. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl BOFFRECR {
#[ doc = r " Returns `true` if the bit is clear (0) " ]
#[ inline ]
pub fn bit_is_clear ( & self ) -> bool {
! self . bit ( )
}
#[ doc = r " 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 {
BOFFRECR ::_0 = > false ,
BOFFRECR ::_1 = > true ,
}
}
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _from ( value : bool ) -> BOFFRECR {
match value {
false = > BOFFRECR ::_0 ,
true = > BOFFRECR ::_1 ,
}
}
#[ doc = " Checks if the value of the field is `_0` " ]
#[ inline ]
pub fn is_0 ( & self ) -> bool {
* self = = BOFFRECR ::_0
}
#[ doc = " Checks if the value of the field is `_1` " ]
#[ inline ]
pub fn is_1 ( & self ) -> bool {
* self = = BOFFRECR ::_1
}
}
#[ doc = " Possible values of the field `SMP` " ]
#[ derive(Clone, Copy, Debug, PartialEq) ]
pub enum SMPR {
2018-02-06 14:15:10 +00:00
#[ doc = " Just one sample is used to determine the bit value. " ]
_0 ,
2017-09-23 18:09:53 +00:00
#[ doc = " Three samples are used to determine the value of the received bit: the regular one (sample point) and 2 preceding samples; a majority rule is used. " ]
_1 ,
}
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 ::_0 = > false ,
SMPR ::_1 = > true ,
}
}
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _from ( value : bool ) -> SMPR {
match value {
false = > SMPR ::_0 ,
true = > SMPR ::_1 ,
}
}
#[ doc = " Checks if the value of the field is `_0` " ]
#[ inline ]
pub fn is_0 ( & self ) -> bool {
* self = = SMPR ::_0
}
#[ doc = " Checks if the value of the field is `_1` " ]
#[ inline ]
pub fn is_1 ( & self ) -> bool {
* self = = SMPR ::_1
}
}
#[ doc = " Possible values of the field `RWRNMSK` " ]
#[ derive(Clone, Copy, Debug, PartialEq) ]
pub enum RWRNMSKR {
2018-02-06 14:15:10 +00:00
#[ doc = " Rx Warning Interrupt disabled. " ]
_0 ,
#[ doc = " Rx Warning Interrupt enabled. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl RWRNMSKR {
#[ doc = r " Returns `true` if the bit is clear (0) " ]
#[ inline ]
pub fn bit_is_clear ( & self ) -> bool {
! self . bit ( )
}
#[ doc = r " 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 {
RWRNMSKR ::_0 = > false ,
RWRNMSKR ::_1 = > true ,
}
}
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _from ( value : bool ) -> RWRNMSKR {
match value {
false = > RWRNMSKR ::_0 ,
true = > RWRNMSKR ::_1 ,
}
}
#[ doc = " Checks if the value of the field is `_0` " ]
#[ inline ]
pub fn is_0 ( & self ) -> bool {
* self = = RWRNMSKR ::_0
}
#[ doc = " Checks if the value of the field is `_1` " ]
#[ inline ]
pub fn is_1 ( & self ) -> bool {
* self = = RWRNMSKR ::_1
}
}
#[ doc = " Possible values of the field `TWRNMSK` " ]
#[ derive(Clone, Copy, Debug, PartialEq) ]
pub enum TWRNMSKR {
2018-02-06 14:15:10 +00:00
#[ doc = " Tx Warning Interrupt disabled. " ]
_0 ,
#[ doc = " Tx Warning Interrupt enabled. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl TWRNMSKR {
#[ doc = r " Returns `true` if the bit is clear (0) " ]
#[ inline ]
pub fn bit_is_clear ( & self ) -> bool {
! self . bit ( )
}
#[ doc = r " 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 {
TWRNMSKR ::_0 = > false ,
TWRNMSKR ::_1 = > true ,
}
}
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _from ( value : bool ) -> TWRNMSKR {
match value {
false = > TWRNMSKR ::_0 ,
true = > TWRNMSKR ::_1 ,
}
}
#[ doc = " Checks if the value of the field is `_0` " ]
#[ inline ]
pub fn is_0 ( & self ) -> bool {
* self = = TWRNMSKR ::_0
}
#[ doc = " Checks if the value of the field is `_1` " ]
#[ inline ]
pub fn is_1 ( & self ) -> bool {
* self = = TWRNMSKR ::_1
}
}
#[ doc = " Possible values of the field `LPB` " ]
#[ derive(Clone, Copy, Debug, PartialEq) ]
pub enum LPBR {
2018-02-06 14:15:10 +00:00
#[ doc = " Loop Back disabled. " ]
_0 ,
#[ doc = " Loop Back enabled. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl LPBR {
#[ doc = r " Returns `true` if the bit is clear (0) " ]
#[ inline ]
pub fn bit_is_clear ( & self ) -> bool {
! self . bit ( )
}
#[ doc = r " 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 {
LPBR ::_0 = > false ,
LPBR ::_1 = > true ,
}
}
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _from ( value : bool ) -> LPBR {
match value {
false = > LPBR ::_0 ,
true = > LPBR ::_1 ,
}
}
#[ doc = " Checks if the value of the field is `_0` " ]
#[ inline ]
pub fn is_0 ( & self ) -> bool {
* self = = LPBR ::_0
}
#[ doc = " Checks if the value of the field is `_1` " ]
#[ inline ]
pub fn is_1 ( & self ) -> bool {
* self = = LPBR ::_1
}
}
#[ doc = " Possible values of the field `CLKSRC` " ]
#[ derive(Clone, Copy, Debug, PartialEq) ]
pub enum CLKSRCR {
#[ doc = " The CAN engine clock source is the oscillator clock. Under this condition, the oscillator clock frequency must be lower than the bus clock. " ]
_0 ,
2018-02-06 14:15:10 +00:00
#[ doc = " The CAN engine clock source is the peripheral clock. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl CLKSRCR {
#[ doc = r " Returns `true` if the bit is clear (0) " ]
#[ inline ]
pub fn bit_is_clear ( & self ) -> bool {
! self . bit ( )
}
#[ doc = r " 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 {
CLKSRCR ::_0 = > false ,
CLKSRCR ::_1 = > true ,
}
}
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _from ( value : bool ) -> CLKSRCR {
match value {
false = > CLKSRCR ::_0 ,
true = > CLKSRCR ::_1 ,
}
}
#[ doc = " Checks if the value of the field is `_0` " ]
#[ inline ]
pub fn is_0 ( & self ) -> bool {
* self = = CLKSRCR ::_0
}
#[ doc = " Checks if the value of the field is `_1` " ]
#[ inline ]
pub fn is_1 ( & self ) -> bool {
* self = = CLKSRCR ::_1
}
}
#[ doc = " Possible values of the field `ERRMSK` " ]
#[ derive(Clone, Copy, Debug, PartialEq) ]
pub enum ERRMSKR {
2018-02-06 14:15:10 +00:00
#[ doc = " Error interrupt disabled. " ]
_0 ,
#[ doc = " Error interrupt enabled. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl ERRMSKR {
#[ doc = r " Returns `true` if the bit is clear (0) " ]
#[ inline ]
pub fn bit_is_clear ( & self ) -> bool {
! self . bit ( )
}
#[ doc = r " 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 {
ERRMSKR ::_0 = > false ,
ERRMSKR ::_1 = > true ,
}
}
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _from ( value : bool ) -> ERRMSKR {
match value {
false = > ERRMSKR ::_0 ,
true = > ERRMSKR ::_1 ,
}
}
#[ doc = " Checks if the value of the field is `_0` " ]
#[ inline ]
pub fn is_0 ( & self ) -> bool {
* self = = ERRMSKR ::_0
}
#[ doc = " Checks if the value of the field is `_1` " ]
#[ inline ]
pub fn is_1 ( & self ) -> bool {
* self = = ERRMSKR ::_1
}
}
#[ doc = " Possible values of the field `BOFFMSK` " ]
#[ derive(Clone, Copy, Debug, PartialEq) ]
pub enum BOFFMSKR {
2018-02-06 14:15:10 +00:00
#[ doc = " Bus Off interrupt disabled. " ]
_0 ,
#[ doc = " Bus Off interrupt enabled. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl BOFFMSKR {
#[ doc = r " Returns `true` if the bit is clear (0) " ]
#[ inline ]
pub fn bit_is_clear ( & self ) -> bool {
! self . bit ( )
}
#[ doc = r " 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 {
BOFFMSKR ::_0 = > false ,
BOFFMSKR ::_1 = > true ,
}
}
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _from ( value : bool ) -> BOFFMSKR {
match value {
false = > BOFFMSKR ::_0 ,
true = > BOFFMSKR ::_1 ,
}
}
#[ doc = " Checks if the value of the field is `_0` " ]
#[ inline ]
pub fn is_0 ( & self ) -> bool {
* self = = BOFFMSKR ::_0
}
#[ doc = " Checks if the value of the field is `_1` " ]
#[ inline ]
pub fn is_1 ( & self ) -> bool {
* self = = BOFFMSKR ::_1
}
}
#[ doc = r " Value of the field " ]
pub struct PSEG2R {
bits : u8 ,
}
impl PSEG2R {
#[ doc = r " Value of the field as raw bits " ]
#[ inline ]
pub fn bits ( & self ) -> u8 {
self . bits
}
}
#[ doc = r " Value of the field " ]
pub struct PSEG1R {
bits : u8 ,
}
impl PSEG1R {
#[ doc = r " Value of the field as raw bits " ]
#[ inline ]
pub fn bits ( & self ) -> u8 {
self . bits
}
}
#[ doc = r " Value of the field " ]
pub struct RJWR {
bits : u8 ,
}
impl RJWR {
#[ doc = r " Value of the field as raw bits " ]
#[ inline ]
pub fn bits ( & self ) -> u8 {
self . bits
}
}
#[ doc = r " Value of the field " ]
pub struct PRESDIVR {
bits : u8 ,
}
impl PRESDIVR {
#[ doc = r " Value of the field as raw bits " ]
#[ inline ]
pub fn bits ( & self ) -> u8 {
self . bits
}
}
#[ doc = r " Proxy " ]
pub struct _PROPSEGW < ' a > {
w : & ' a mut W ,
}
impl < ' a > _PROPSEGW < ' a > {
#[ doc = r " Writes raw bits to the field " ]
#[ inline ]
pub unsafe fn bits ( self , value : u8 ) -> & ' a mut W {
const MASK : u8 = 7 ;
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 `LOM` " ]
pub enum LOMW {
2018-02-06 14:15:10 +00:00
#[ doc = " Listen-Only mode is deactivated. " ]
_0 ,
#[ doc = " FlexCAN module operates in Listen-Only mode. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl LOMW {
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _bits ( & self ) -> bool {
match * self {
LOMW ::_0 = > false ,
LOMW ::_1 = > true ,
}
}
}
#[ doc = r " Proxy " ]
pub struct _LOMW < ' a > {
w : & ' a mut W ,
}
impl < ' a > _LOMW < ' a > {
#[ doc = r " Writes `variant` to the field " ]
#[ inline ]
pub fn variant ( self , variant : LOMW ) -> & ' a mut W {
{
self . bit ( variant . _bits ( ) )
}
}
#[ doc = " Listen-Only mode is deactivated. " ]
#[ inline ]
pub fn _0 ( self ) -> & ' a mut W {
self . variant ( LOMW ::_0 )
}
#[ doc = " FlexCAN module operates in Listen-Only mode. " ]
#[ inline ]
pub fn _1 ( self ) -> & ' a mut W {
self . variant ( LOMW ::_1 )
}
#[ doc = r " Sets the field bit " ]
pub fn set_bit ( self ) -> & ' a mut W {
self . bit ( true )
}
#[ doc = r " Clears the field bit " ]
pub fn clear_bit ( self ) -> & ' a mut W {
self . bit ( false )
}
#[ doc = r " Writes raw bits to the field " ]
#[ inline ]
pub fn bit ( self , value : bool ) -> & ' a mut W {
const MASK : 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 `LBUF` " ]
pub enum LBUFW {
2018-02-06 14:15:10 +00:00
#[ doc = " Buffer with highest priority is transmitted first. " ]
_0 ,
#[ doc = " Lowest number buffer is transmitted first. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl LBUFW {
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _bits ( & self ) -> bool {
match * self {
LBUFW ::_0 = > false ,
LBUFW ::_1 = > true ,
}
}
}
#[ doc = r " Proxy " ]
pub struct _LBUFW < ' a > {
w : & ' a mut W ,
}
impl < ' a > _LBUFW < ' a > {
#[ doc = r " Writes `variant` to the field " ]
#[ inline ]
pub fn variant ( self , variant : LBUFW ) -> & ' a mut W {
{
self . bit ( variant . _bits ( ) )
}
}
#[ doc = " Buffer with highest priority is transmitted first. " ]
#[ inline ]
pub fn _0 ( self ) -> & ' a mut W {
self . variant ( LBUFW ::_0 )
}
#[ doc = " Lowest number buffer is transmitted first. " ]
#[ inline ]
pub fn _1 ( self ) -> & ' a mut W {
self . variant ( LBUFW ::_1 )
}
#[ doc = r " Sets the field bit " ]
pub fn set_bit ( self ) -> & ' a mut W {
self . bit ( true )
}
#[ doc = r " Clears the field bit " ]
pub fn clear_bit ( self ) -> & ' a mut W {
self . bit ( false )
}
#[ doc = r " Writes raw bits to the field " ]
#[ inline ]
pub fn bit ( self , value : bool ) -> & ' a mut W {
const MASK : 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 `TSYN` " ]
pub enum TSYNW {
2018-02-06 14:15:10 +00:00
#[ doc = " Timer Sync feature disabled " ]
_0 ,
#[ doc = " Timer Sync feature enabled " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl TSYNW {
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _bits ( & self ) -> bool {
match * self {
TSYNW ::_0 = > false ,
TSYNW ::_1 = > true ,
}
}
}
#[ doc = r " Proxy " ]
pub struct _TSYNW < ' a > {
w : & ' a mut W ,
}
impl < ' a > _TSYNW < ' a > {
#[ doc = r " Writes `variant` to the field " ]
#[ inline ]
pub fn variant ( self , variant : TSYNW ) -> & ' a mut W {
{
self . bit ( variant . _bits ( ) )
}
}
#[ doc = " Timer Sync feature disabled " ]
#[ inline ]
pub fn _0 ( self ) -> & ' a mut W {
self . variant ( TSYNW ::_0 )
}
#[ doc = " Timer Sync feature enabled " ]
#[ inline ]
pub fn _1 ( self ) -> & ' a mut W {
self . variant ( TSYNW ::_1 )
}
#[ doc = r " Sets the field bit " ]
pub fn set_bit ( self ) -> & ' a mut W {
self . bit ( true )
}
#[ doc = r " Clears the field bit " ]
pub fn clear_bit ( self ) -> & ' a mut W {
self . bit ( false )
}
#[ doc = r " Writes raw bits to the field " ]
#[ inline ]
pub fn bit ( self , value : bool ) -> & ' a mut W {
const MASK : 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 `BOFFREC` " ]
pub enum BOFFRECW {
2018-02-06 14:15:10 +00:00
#[ doc = " Automatic recovering from Bus Off state enabled. " ]
_0 ,
#[ doc = " Automatic recovering from Bus Off state disabled. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl BOFFRECW {
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _bits ( & self ) -> bool {
match * self {
BOFFRECW ::_0 = > false ,
BOFFRECW ::_1 = > true ,
}
}
}
#[ doc = r " Proxy " ]
pub struct _BOFFRECW < ' a > {
w : & ' a mut W ,
}
impl < ' a > _BOFFRECW < ' a > {
#[ doc = r " Writes `variant` to the field " ]
#[ inline ]
pub fn variant ( self , variant : BOFFRECW ) -> & ' a mut W {
{
self . bit ( variant . _bits ( ) )
}
}
#[ doc = " Automatic recovering from Bus Off state enabled. " ]
#[ inline ]
pub fn _0 ( self ) -> & ' a mut W {
self . variant ( BOFFRECW ::_0 )
}
#[ doc = " Automatic recovering from Bus Off state disabled. " ]
#[ inline ]
pub fn _1 ( self ) -> & ' a mut W {
self . variant ( BOFFRECW ::_1 )
}
#[ doc = r " Sets the field bit " ]
pub fn set_bit ( self ) -> & ' a mut W {
self . bit ( true )
}
#[ doc = r " Clears the field bit " ]
pub fn clear_bit ( self ) -> & ' a mut W {
self . bit ( false )
}
#[ doc = r " Writes raw bits to the field " ]
#[ inline ]
pub fn bit ( self , value : bool ) -> & ' a mut W {
const MASK : 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 `SMP` " ]
pub enum SMPW {
2018-02-06 14:15:10 +00:00
#[ doc = " Just one sample is used to determine the bit value. " ]
_0 ,
2017-09-23 18:09:53 +00:00
#[ doc = " Three samples are used to determine the value of the received bit: the regular one (sample point) and 2 preceding samples; a majority rule is used. " ]
_1 ,
}
impl SMPW {
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _bits ( & self ) -> bool {
match * self {
SMPW ::_0 = > false ,
SMPW ::_1 = > 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 = " Just one sample is used to determine the bit value. " ]
#[ inline ]
pub fn _0 ( self ) -> & ' a mut W {
self . variant ( SMPW ::_0 )
}
#[ doc = " Three samples are used to determine the value of the received bit: the regular one (sample point) and 2 preceding samples; a majority rule is used. " ]
#[ inline ]
pub fn _1 ( self ) -> & ' a mut W {
self . variant ( SMPW ::_1 )
}
#[ doc = r " Sets the field bit " ]
pub fn set_bit ( self ) -> & ' a mut W {
self . bit ( true )
}
#[ doc = r " Clears the field bit " ]
pub fn clear_bit ( self ) -> & ' a mut W {
self . bit ( false )
}
#[ doc = r " Writes raw bits to the field " ]
#[ inline ]
pub fn bit ( self , value : bool ) -> & ' a mut W {
const MASK : 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 `RWRNMSK` " ]
pub enum RWRNMSKW {
2018-02-06 14:15:10 +00:00
#[ doc = " Rx Warning Interrupt disabled. " ]
_0 ,
#[ doc = " Rx Warning Interrupt enabled. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl RWRNMSKW {
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _bits ( & self ) -> bool {
match * self {
RWRNMSKW ::_0 = > false ,
RWRNMSKW ::_1 = > true ,
}
}
}
#[ doc = r " Proxy " ]
pub struct _RWRNMSKW < ' a > {
w : & ' a mut W ,
}
impl < ' a > _RWRNMSKW < ' a > {
#[ doc = r " Writes `variant` to the field " ]
#[ inline ]
pub fn variant ( self , variant : RWRNMSKW ) -> & ' a mut W {
{
self . bit ( variant . _bits ( ) )
}
}
#[ doc = " Rx Warning Interrupt disabled. " ]
#[ inline ]
pub fn _0 ( self ) -> & ' a mut W {
self . variant ( RWRNMSKW ::_0 )
}
#[ doc = " Rx Warning Interrupt enabled. " ]
#[ inline ]
pub fn _1 ( self ) -> & ' a mut W {
self . variant ( RWRNMSKW ::_1 )
}
#[ doc = r " Sets the field bit " ]
pub fn set_bit ( self ) -> & ' a mut W {
self . bit ( true )
}
#[ doc = r " Clears the field bit " ]
pub fn clear_bit ( self ) -> & ' a mut W {
self . bit ( false )
}
#[ doc = 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 `TWRNMSK` " ]
pub enum TWRNMSKW {
2018-02-06 14:15:10 +00:00
#[ doc = " Tx Warning Interrupt disabled. " ]
_0 ,
#[ doc = " Tx Warning Interrupt enabled. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl TWRNMSKW {
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _bits ( & self ) -> bool {
match * self {
TWRNMSKW ::_0 = > false ,
TWRNMSKW ::_1 = > true ,
}
}
}
#[ doc = r " Proxy " ]
pub struct _TWRNMSKW < ' a > {
w : & ' a mut W ,
}
impl < ' a > _TWRNMSKW < ' a > {
#[ doc = r " Writes `variant` to the field " ]
#[ inline ]
pub fn variant ( self , variant : TWRNMSKW ) -> & ' a mut W {
{
self . bit ( variant . _bits ( ) )
}
}
#[ doc = " Tx Warning Interrupt disabled. " ]
#[ inline ]
pub fn _0 ( self ) -> & ' a mut W {
self . variant ( TWRNMSKW ::_0 )
}
#[ doc = " Tx Warning Interrupt enabled. " ]
#[ inline ]
pub fn _1 ( self ) -> & ' a mut W {
self . variant ( TWRNMSKW ::_1 )
}
#[ doc = r " Sets the field bit " ]
pub fn set_bit ( self ) -> & ' a mut W {
self . bit ( true )
}
#[ doc = r " Clears the field bit " ]
pub fn clear_bit ( self ) -> & ' a mut W {
self . bit ( false )
}
#[ doc = 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 `LPB` " ]
pub enum LPBW {
2018-02-06 14:15:10 +00:00
#[ doc = " Loop Back disabled. " ]
_0 ,
#[ doc = " Loop Back enabled. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl LPBW {
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _bits ( & self ) -> bool {
match * self {
LPBW ::_0 = > false ,
LPBW ::_1 = > true ,
}
}
}
#[ doc = r " Proxy " ]
pub struct _LPBW < ' a > {
w : & ' a mut W ,
}
impl < ' a > _LPBW < ' a > {
#[ doc = r " Writes `variant` to the field " ]
#[ inline ]
pub fn variant ( self , variant : LPBW ) -> & ' a mut W {
{
self . bit ( variant . _bits ( ) )
}
}
#[ doc = " Loop Back disabled. " ]
#[ inline ]
pub fn _0 ( self ) -> & ' a mut W {
self . variant ( LPBW ::_0 )
}
#[ doc = " Loop Back enabled. " ]
#[ inline ]
pub fn _1 ( self ) -> & ' a mut W {
self . variant ( LPBW ::_1 )
}
#[ doc = r " Sets the field bit " ]
pub fn set_bit ( self ) -> & ' a mut W {
self . bit ( true )
}
#[ doc = r " Clears the field bit " ]
pub fn clear_bit ( self ) -> & ' a mut W {
self . bit ( false )
}
#[ doc = r " Writes raw bits to the field " ]
#[ inline ]
pub fn bit ( self , value : bool ) -> & ' a mut W {
const 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 `CLKSRC` " ]
pub enum CLKSRCW {
#[ doc = " The CAN engine clock source is the oscillator clock. Under this condition, the oscillator clock frequency must be lower than the bus clock. " ]
_0 ,
2018-02-06 14:15:10 +00:00
#[ doc = " The CAN engine clock source is the peripheral clock. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl CLKSRCW {
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _bits ( & self ) -> bool {
match * self {
CLKSRCW ::_0 = > false ,
CLKSRCW ::_1 = > true ,
}
}
}
#[ doc = r " Proxy " ]
pub struct _CLKSRCW < ' a > {
w : & ' a mut W ,
}
impl < ' a > _CLKSRCW < ' a > {
#[ doc = r " Writes `variant` to the field " ]
#[ inline ]
pub fn variant ( self , variant : CLKSRCW ) -> & ' a mut W {
{
self . bit ( variant . _bits ( ) )
}
}
#[ doc = " The CAN engine clock source is the oscillator clock. Under this condition, the oscillator clock frequency must be lower than the bus clock. " ]
#[ inline ]
pub fn _0 ( self ) -> & ' a mut W {
self . variant ( CLKSRCW ::_0 )
}
#[ doc = " The CAN engine clock source is the peripheral clock. " ]
#[ inline ]
pub fn _1 ( self ) -> & ' a mut W {
self . variant ( CLKSRCW ::_1 )
}
#[ doc = r " Sets the field bit " ]
pub fn set_bit ( self ) -> & ' a mut W {
self . bit ( true )
}
#[ doc = r " Clears the field bit " ]
pub fn clear_bit ( self ) -> & ' a mut W {
self . bit ( false )
}
#[ doc = 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 `ERRMSK` " ]
pub enum ERRMSKW {
2018-02-06 14:15:10 +00:00
#[ doc = " Error interrupt disabled. " ]
_0 ,
#[ doc = " Error interrupt enabled. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl ERRMSKW {
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _bits ( & self ) -> bool {
match * self {
ERRMSKW ::_0 = > false ,
ERRMSKW ::_1 = > true ,
}
}
}
#[ doc = r " Proxy " ]
pub struct _ERRMSKW < ' a > {
w : & ' a mut W ,
}
impl < ' a > _ERRMSKW < ' a > {
#[ doc = r " Writes `variant` to the field " ]
#[ inline ]
pub fn variant ( self , variant : ERRMSKW ) -> & ' a mut W {
{
self . bit ( variant . _bits ( ) )
}
}
#[ doc = " Error interrupt disabled. " ]
#[ inline ]
pub fn _0 ( self ) -> & ' a mut W {
self . variant ( ERRMSKW ::_0 )
}
#[ doc = " Error interrupt enabled. " ]
#[ inline ]
pub fn _1 ( self ) -> & ' a mut W {
self . variant ( ERRMSKW ::_1 )
}
#[ doc = r " Sets the field bit " ]
pub fn set_bit ( self ) -> & ' a mut W {
self . bit ( true )
}
#[ doc = r " Clears the field bit " ]
pub fn clear_bit ( self ) -> & ' a mut W {
self . bit ( false )
}
#[ doc = 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 `BOFFMSK` " ]
pub enum BOFFMSKW {
2018-02-06 14:15:10 +00:00
#[ doc = " Bus Off interrupt disabled. " ]
_0 ,
#[ doc = " Bus Off interrupt enabled. " ]
_1 ,
2017-09-23 18:09:53 +00:00
}
impl BOFFMSKW {
#[ allow(missing_docs) ]
#[ doc(hidden) ]
#[ inline ]
pub fn _bits ( & self ) -> bool {
match * self {
BOFFMSKW ::_0 = > false ,
BOFFMSKW ::_1 = > true ,
}
}
}
#[ doc = r " Proxy " ]
pub struct _BOFFMSKW < ' a > {
w : & ' a mut W ,
}
impl < ' a > _BOFFMSKW < ' a > {
#[ doc = r " Writes `variant` to the field " ]
#[ inline ]
pub fn variant ( self , variant : BOFFMSKW ) -> & ' a mut W {
{
self . bit ( variant . _bits ( ) )
}
}
#[ doc = " Bus Off interrupt disabled. " ]
#[ inline ]
pub fn _0 ( self ) -> & ' a mut W {
self . variant ( BOFFMSKW ::_0 )
}
#[ doc = " Bus Off interrupt enabled. " ]
#[ inline ]
pub fn _1 ( self ) -> & ' a mut W {
self . variant ( BOFFMSKW ::_1 )
}
#[ doc = r " Sets the field bit " ]
pub fn set_bit ( self ) -> & ' a mut W {
self . bit ( true )
}
#[ doc = r " Clears the field bit " ]
pub fn clear_bit ( self ) -> & ' a mut W {
self . bit ( false )
}
#[ doc = 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 _PSEG2W < ' a > {
w : & ' a mut W ,
}
impl < ' a > _PSEG2W < ' a > {
#[ doc = r " Writes raw bits to the field " ]
#[ inline ]
pub unsafe fn bits ( self , value : u8 ) -> & ' a mut W {
const MASK : u8 = 7 ;
const OFFSET : u8 = 16 ;
self . w . bits & = ! ( ( MASK as u32 ) < < OFFSET ) ;
self . w . bits | = ( ( value & MASK ) as u32 ) < < OFFSET ;
self . w
}
}
#[ doc = r " Proxy " ]
pub struct _PSEG1W < ' a > {
w : & ' a mut W ,
}
impl < ' a > _PSEG1W < ' a > {
#[ doc = r " Writes raw bits to the field " ]
#[ inline ]
pub unsafe fn bits ( self , value : u8 ) -> & ' a mut W {
const MASK : u8 = 7 ;
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 _RJWW < ' a > {
w : & ' a mut W ,
}
impl < ' a > _RJWW < ' a > {
#[ doc = r " Writes raw bits to the field " ]
#[ inline ]
pub unsafe fn bits ( self , value : u8 ) -> & ' a mut W {
const MASK : u8 = 3 ;
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 _PRESDIVW < ' a > {
w : & ' a mut W ,
}
impl < ' a > _PRESDIVW < ' a > {
#[ doc = r " Writes raw bits to the field " ]
#[ inline ]
pub unsafe fn bits ( self , value : u8 ) -> & ' a mut W {
const MASK : u8 = 255 ;
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 - Propagation Segment " ]
#[ inline ]
pub fn propseg ( & self ) -> PROPSEGR {
let bits = {
const MASK : u8 = 7 ;
const OFFSET : u8 = 0 ;
( ( self . bits > > OFFSET ) & MASK as u32 ) as u8
} ;
PROPSEGR { bits }
}
#[ doc = " Bit 3 - Listen-Only Mode " ]
#[ inline ]
pub fn lom ( & self ) -> LOMR {
LOMR ::_from ( {
const MASK : bool = true ;
const OFFSET : u8 = 3 ;
( ( self . bits > > OFFSET ) & MASK as u32 ) ! = 0
} )
}
#[ doc = " Bit 4 - Lowest Buffer Transmitted First " ]
#[ inline ]
pub fn lbuf ( & self ) -> LBUFR {
LBUFR ::_from ( {
const MASK : bool = true ;
const OFFSET : u8 = 4 ;
( ( self . bits > > OFFSET ) & MASK as u32 ) ! = 0
} )
}
#[ doc = " Bit 5 - Timer Sync " ]
#[ inline ]
pub fn tsyn ( & self ) -> TSYNR {
TSYNR ::_from ( {
const MASK : bool = true ;
const OFFSET : u8 = 5 ;
( ( self . bits > > OFFSET ) & MASK as u32 ) ! = 0
} )
}
#[ doc = " Bit 6 - Bus Off Recovery " ]
#[ inline ]
pub fn boffrec ( & self ) -> BOFFRECR {
BOFFRECR ::_from ( {
const MASK : bool = true ;
const OFFSET : u8 = 6 ;
( ( self . bits > > OFFSET ) & MASK as u32 ) ! = 0
} )
}
#[ doc = " Bit 7 - CAN Bit Sampling " ]
#[ inline ]
pub fn smp ( & self ) -> SMPR {
SMPR ::_from ( {
const MASK : bool = true ;
const OFFSET : u8 = 7 ;
( ( self . bits > > OFFSET ) & MASK as u32 ) ! = 0
} )
}
#[ doc = " Bit 10 - Rx Warning Interrupt Mask " ]
#[ inline ]
pub fn rwrnmsk ( & self ) -> RWRNMSKR {
RWRNMSKR ::_from ( {
const MASK : bool = true ;
const OFFSET : u8 = 10 ;
( ( self . bits > > OFFSET ) & MASK as u32 ) ! = 0
} )
}
#[ doc = " Bit 11 - Tx Warning Interrupt Mask " ]
#[ inline ]
pub fn twrnmsk ( & self ) -> TWRNMSKR {
TWRNMSKR ::_from ( {
const MASK : bool = true ;
const OFFSET : u8 = 11 ;
( ( self . bits > > OFFSET ) & MASK as u32 ) ! = 0
} )
}
#[ doc = " Bit 12 - Loop Back Mode " ]
#[ inline ]
pub fn lpb ( & self ) -> LPBR {
LPBR ::_from ( {
const MASK : bool = true ;
const OFFSET : u8 = 12 ;
( ( self . bits > > OFFSET ) & MASK as u32 ) ! = 0
} )
}
#[ doc = " Bit 13 - CAN Engine Clock Source " ]
#[ inline ]
pub fn clksrc ( & self ) -> CLKSRCR {
CLKSRCR ::_from ( {
const MASK : bool = true ;
const OFFSET : u8 = 13 ;
( ( self . bits > > OFFSET ) & MASK as u32 ) ! = 0
} )
}
#[ doc = " Bit 14 - Error Interrupt Mask " ]
#[ inline ]
pub fn errmsk ( & self ) -> ERRMSKR {
ERRMSKR ::_from ( {
const MASK : bool = true ;
const OFFSET : u8 = 14 ;
( ( self . bits > > OFFSET ) & MASK as u32 ) ! = 0
} )
}
#[ doc = " Bit 15 - Bus Off Interrupt Mask " ]
#[ inline ]
pub fn boffmsk ( & self ) -> BOFFMSKR {
BOFFMSKR ::_from ( {
const MASK : bool = true ;
const OFFSET : u8 = 15 ;
( ( self . bits > > OFFSET ) & MASK as u32 ) ! = 0
} )
}
#[ doc = " Bits 16:18 - Phase Segment 2 " ]
#[ inline ]
pub fn pseg2 ( & self ) -> PSEG2R {
let bits = {
const MASK : u8 = 7 ;
const OFFSET : u8 = 16 ;
( ( self . bits > > OFFSET ) & MASK as u32 ) as u8
} ;
PSEG2R { bits }
}
#[ doc = " Bits 19:21 - Phase Segment 1 " ]
#[ inline ]
pub fn pseg1 ( & self ) -> PSEG1R {
let bits = {
const MASK : u8 = 7 ;
const OFFSET : u8 = 19 ;
( ( self . bits > > OFFSET ) & MASK as u32 ) as u8
} ;
PSEG1R { bits }
}
#[ doc = " Bits 22:23 - Resync Jump Width " ]
#[ inline ]
pub fn rjw ( & self ) -> RJWR {
let bits = {
const MASK : u8 = 3 ;
const OFFSET : u8 = 22 ;
( ( self . bits > > OFFSET ) & MASK as u32 ) as u8
} ;
RJWR { bits }
}
#[ doc = " Bits 24:31 - Prescaler Division Factor " ]
#[ inline ]
pub fn presdiv ( & self ) -> PRESDIVR {
let bits = {
const MASK : u8 = 255 ;
const OFFSET : u8 = 24 ;
( ( self . bits > > OFFSET ) & MASK as u32 ) as u8
} ;
PRESDIVR { bits }
}
}
impl W {
#[ doc = r " Reset value of the register " ]
#[ inline ]
pub fn reset_value ( ) -> W {
W { bits : 0 }
}
#[ doc = r " 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 - Propagation Segment " ]
#[ inline ]
pub fn propseg ( & mut self ) -> _PROPSEGW {
_PROPSEGW { w : self }
}
#[ doc = " Bit 3 - Listen-Only Mode " ]
#[ inline ]
pub fn lom ( & mut self ) -> _LOMW {
_LOMW { w : self }
}
#[ doc = " Bit 4 - Lowest Buffer Transmitted First " ]
#[ inline ]
pub fn lbuf ( & mut self ) -> _LBUFW {
_LBUFW { w : self }
}
#[ doc = " Bit 5 - Timer Sync " ]
#[ inline ]
pub fn tsyn ( & mut self ) -> _TSYNW {
_TSYNW { w : self }
}
#[ doc = " Bit 6 - Bus Off Recovery " ]
#[ inline ]
pub fn boffrec ( & mut self ) -> _BOFFRECW {
_BOFFRECW { w : self }
}
#[ doc = " Bit 7 - CAN Bit Sampling " ]
#[ inline ]
pub fn smp ( & mut self ) -> _SMPW {
_SMPW { w : self }
}
#[ doc = " Bit 10 - Rx Warning Interrupt Mask " ]
#[ inline ]
pub fn rwrnmsk ( & mut self ) -> _RWRNMSKW {
_RWRNMSKW { w : self }
}
#[ doc = " Bit 11 - Tx Warning Interrupt Mask " ]
#[ inline ]
pub fn twrnmsk ( & mut self ) -> _TWRNMSKW {
_TWRNMSKW { w : self }
}
#[ doc = " Bit 12 - Loop Back Mode " ]
#[ inline ]
pub fn lpb ( & mut self ) -> _LPBW {
_LPBW { w : self }
}
#[ doc = " Bit 13 - CAN Engine Clock Source " ]
#[ inline ]
pub fn clksrc ( & mut self ) -> _CLKSRCW {
_CLKSRCW { w : self }
}
#[ doc = " Bit 14 - Error Interrupt Mask " ]
#[ inline ]
pub fn errmsk ( & mut self ) -> _ERRMSKW {
_ERRMSKW { w : self }
}
#[ doc = " Bit 15 - Bus Off Interrupt Mask " ]
#[ inline ]
pub fn boffmsk ( & mut self ) -> _BOFFMSKW {
_BOFFMSKW { w : self }
}
#[ doc = " Bits 16:18 - Phase Segment 2 " ]
#[ inline ]
pub fn pseg2 ( & mut self ) -> _PSEG2W {
_PSEG2W { w : self }
}
#[ doc = " Bits 19:21 - Phase Segment 1 " ]
#[ inline ]
pub fn pseg1 ( & mut self ) -> _PSEG1W {
_PSEG1W { w : self }
}
#[ doc = " Bits 22:23 - Resync Jump Width " ]
#[ inline ]
pub fn rjw ( & mut self ) -> _RJWW {
_RJWW { w : self }
}
#[ doc = " Bits 24:31 - Prescaler Division Factor " ]
#[ inline ]
pub fn presdiv ( & mut self ) -> _PRESDIVW {
_PRESDIVW { w : self }
}
}