# [ doc = r" Value read from the register" ] pub struct R { bits : u32 } # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 } impl super :: INTENSET { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & self , f : F ) where for < 'w > F : FnOnce ( & R , & 'w mut W ) -> & 'w mut W { let bits = self . register . get ( ) ; let r = R { bits : bits } ; let mut w = W { bits : bits } ; f ( & r , & mut w ) ; self . register . set ( w . bits ) ; } # [ doc = r" Reads the contents of the register" ] # [ inline ] pub fn read ( & self ) -> R { R { bits : self . register . get ( ) } } # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let mut w = W :: reset_value ( ) ; f ( & mut w ) ; 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 `STARTED`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum STARTEDR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl STARTEDR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { STARTEDR :: DISABLED => false , STARTEDR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> STARTEDR { match value { false => STARTEDR :: DISABLED , true => STARTEDR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == STARTEDR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == STARTEDR :: ENABLED } } # [ doc = "Possible values of the field `END`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ENDR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl ENDR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { ENDR :: DISABLED => false , ENDR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> ENDR { match value { false => ENDR :: DISABLED , true => ENDR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == ENDR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == ENDR :: ENABLED } } # [ doc = "Possible values of the field `DONE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DONER { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl DONER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { DONER :: DISABLED => false , DONER :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DONER { match value { false => DONER :: DISABLED , true => DONER :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == DONER :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == DONER :: ENABLED } } # [ doc = "Possible values of the field `RESULTDONE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum RESULTDONER { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl RESULTDONER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { RESULTDONER :: DISABLED => false , RESULTDONER :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> RESULTDONER { match value { false => RESULTDONER :: DISABLED , true => RESULTDONER :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == RESULTDONER :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == RESULTDONER :: ENABLED } } # [ doc = "Possible values of the field `CALIBRATEDONE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CALIBRATEDONER { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl CALIBRATEDONER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { CALIBRATEDONER :: DISABLED => false , CALIBRATEDONER :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CALIBRATEDONER { match value { false => CALIBRATEDONER :: DISABLED , true => CALIBRATEDONER :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == CALIBRATEDONER :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == CALIBRATEDONER :: ENABLED } } # [ doc = "Possible values of the field `STOPPED`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum STOPPEDR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl STOPPEDR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { STOPPEDR :: DISABLED => false , STOPPEDR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> STOPPEDR { match value { false => STOPPEDR :: DISABLED , true => STOPPEDR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == STOPPEDR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == STOPPEDR :: ENABLED } } # [ doc = "Possible values of the field `CH0LIMITH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CH0LIMITHR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl CH0LIMITHR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { CH0LIMITHR :: DISABLED => false , CH0LIMITHR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CH0LIMITHR { match value { false => CH0LIMITHR :: DISABLED , true => CH0LIMITHR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == CH0LIMITHR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == CH0LIMITHR :: ENABLED } } # [ doc = "Possible values of the field `CH0LIMITL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CH0LIMITLR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl CH0LIMITLR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { CH0LIMITLR :: DISABLED => false , CH0LIMITLR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CH0LIMITLR { match value { false => CH0LIMITLR :: DISABLED , true => CH0LIMITLR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == CH0LIMITLR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == CH0LIMITLR :: ENABLED } } # [ doc = "Possible values of the field `CH1LIMITH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CH1LIMITHR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl CH1LIMITHR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { CH1LIMITHR :: DISABLED => false , CH1LIMITHR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CH1LIMITHR { match value { false => CH1LIMITHR :: DISABLED , true => CH1LIMITHR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == CH1LIMITHR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == CH1LIMITHR :: ENABLED } } # [ doc = "Possible values of the field `CH1LIMITL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CH1LIMITLR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl CH1LIMITLR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { CH1LIMITLR :: DISABLED => false , CH1LIMITLR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CH1LIMITLR { match value { false => CH1LIMITLR :: DISABLED , true => CH1LIMITLR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == CH1LIMITLR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == CH1LIMITLR :: ENABLED } } # [ doc = "Possible values of the field `CH2LIMITH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CH2LIMITHR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl CH2LIMITHR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { CH2LIMITHR :: DISABLED => false , CH2LIMITHR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CH2LIMITHR { match value { false => CH2LIMITHR :: DISABLED , true => CH2LIMITHR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == CH2LIMITHR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == CH2LIMITHR :: ENABLED } } # [ doc = "Possible values of the field `CH2LIMITL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CH2LIMITLR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl CH2LIMITLR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { CH2LIMITLR :: DISABLED => false , CH2LIMITLR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CH2LIMITLR { match value { false => CH2LIMITLR :: DISABLED , true => CH2LIMITLR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == CH2LIMITLR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == CH2LIMITLR :: ENABLED } } # [ doc = "Possible values of the field `CH3LIMITH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CH3LIMITHR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl CH3LIMITHR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { CH3LIMITHR :: DISABLED => false , CH3LIMITHR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CH3LIMITHR { match value { false => CH3LIMITHR :: DISABLED , true => CH3LIMITHR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == CH3LIMITHR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == CH3LIMITHR :: ENABLED } } # [ doc = "Possible values of the field `CH3LIMITL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CH3LIMITLR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl CH3LIMITLR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { CH3LIMITLR :: DISABLED => false , CH3LIMITLR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CH3LIMITLR { match value { false => CH3LIMITLR :: DISABLED , true => CH3LIMITLR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == CH3LIMITLR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == CH3LIMITLR :: ENABLED } } # [ doc = "Possible values of the field `CH4LIMITH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CH4LIMITHR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl CH4LIMITHR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { CH4LIMITHR :: DISABLED => false , CH4LIMITHR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CH4LIMITHR { match value { false => CH4LIMITHR :: DISABLED , true => CH4LIMITHR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == CH4LIMITHR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == CH4LIMITHR :: ENABLED } } # [ doc = "Possible values of the field `CH4LIMITL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CH4LIMITLR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl CH4LIMITLR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { CH4LIMITLR :: DISABLED => false , CH4LIMITLR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CH4LIMITLR { match value { false => CH4LIMITLR :: DISABLED , true => CH4LIMITLR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == CH4LIMITLR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == CH4LIMITLR :: ENABLED } } # [ doc = "Possible values of the field `CH5LIMITH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CH5LIMITHR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl CH5LIMITHR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { CH5LIMITHR :: DISABLED => false , CH5LIMITHR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CH5LIMITHR { match value { false => CH5LIMITHR :: DISABLED , true => CH5LIMITHR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == CH5LIMITHR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == CH5LIMITHR :: ENABLED } } # [ doc = "Possible values of the field `CH5LIMITL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CH5LIMITLR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl CH5LIMITLR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { CH5LIMITLR :: DISABLED => false , CH5LIMITLR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CH5LIMITLR { match value { false => CH5LIMITLR :: DISABLED , true => CH5LIMITLR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == CH5LIMITLR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == CH5LIMITLR :: ENABLED } } # [ doc = "Possible values of the field `CH6LIMITH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CH6LIMITHR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl CH6LIMITHR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { CH6LIMITHR :: DISABLED => false , CH6LIMITHR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CH6LIMITHR { match value { false => CH6LIMITHR :: DISABLED , true => CH6LIMITHR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == CH6LIMITHR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == CH6LIMITHR :: ENABLED } } # [ doc = "Possible values of the field `CH6LIMITL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CH6LIMITLR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl CH6LIMITLR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { CH6LIMITLR :: DISABLED => false , CH6LIMITLR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CH6LIMITLR { match value { false => CH6LIMITLR :: DISABLED , true => CH6LIMITLR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == CH6LIMITLR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == CH6LIMITLR :: ENABLED } } # [ doc = "Possible values of the field `CH7LIMITH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CH7LIMITHR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl CH7LIMITHR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { CH7LIMITHR :: DISABLED => false , CH7LIMITHR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CH7LIMITHR { match value { false => CH7LIMITHR :: DISABLED , true => CH7LIMITHR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == CH7LIMITHR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == CH7LIMITHR :: ENABLED } } # [ doc = "Possible values of the field `CH7LIMITL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CH7LIMITLR { # [ doc = "Read: Disabled" ] DISABLED , # [ doc = "Read: Enabled" ] ENABLED , } impl CH7LIMITLR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" 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 { CH7LIMITLR :: DISABLED => false , CH7LIMITLR :: ENABLED => true , } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CH7LIMITLR { match value { false => CH7LIMITLR :: DISABLED , true => CH7LIMITLR :: ENABLED , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == CH7LIMITLR :: DISABLED } # [ doc = "Checks if the value of the field is `ENABLED`" ] # [ inline ] pub fn is_enabled ( & self ) -> bool { * self == CH7LIMITLR :: ENABLED } } # [ doc = "Values that can be written to the field `STARTED`" ] pub enum STARTEDW { # [ doc = "Enable" ] SET , } impl STARTEDW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { STARTEDW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _STARTEDW < 'a > { w : & 'a mut W } impl < 'a > _STARTEDW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : STARTEDW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( STARTEDW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub fn bit ( self , value : bool ) -> & 'a mut W { const MASK : 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 `END`" ] pub enum ENDW { # [ doc = "Enable" ] SET , } impl ENDW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { ENDW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _ENDW < 'a > { w : & 'a mut W } impl < 'a > _ENDW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ENDW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ENDW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub fn bit ( self , value : bool ) -> & 'a mut W { const MASK : 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 `DONE`" ] pub enum DONEW { # [ doc = "Enable" ] SET , } impl DONEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DONEW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _DONEW < 'a > { w : & 'a mut W } impl < 'a > _DONEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DONEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( DONEW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub fn bit ( self , value : bool ) -> & 'a mut W { const MASK : 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 `RESULTDONE`" ] pub enum RESULTDONEW { # [ doc = "Enable" ] SET , } impl RESULTDONEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { RESULTDONEW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _RESULTDONEW < 'a > { w : & 'a mut W } impl < 'a > _RESULTDONEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : RESULTDONEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( RESULTDONEW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub fn bit ( self , value : bool ) -> & 'a mut W { const MASK : 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 `CALIBRATEDONE`" ] pub enum CALIBRATEDONEW { # [ doc = "Enable" ] SET , } impl CALIBRATEDONEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CALIBRATEDONEW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _CALIBRATEDONEW < 'a > { w : & 'a mut W } impl < 'a > _CALIBRATEDONEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CALIBRATEDONEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( CALIBRATEDONEW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub fn bit ( self , value : bool ) -> & 'a mut W { const MASK : 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 `STOPPED`" ] pub enum STOPPEDW { # [ doc = "Enable" ] SET , } impl STOPPEDW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { STOPPEDW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _STOPPEDW < 'a > { w : & 'a mut W } impl < 'a > _STOPPEDW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : STOPPEDW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( STOPPEDW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub fn bit ( self , value : bool ) -> & 'a mut W { const MASK : 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 `CH0LIMITH`" ] pub enum CH0LIMITHW { # [ doc = "Enable" ] SET , } impl CH0LIMITHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CH0LIMITHW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _CH0LIMITHW < 'a > { w : & 'a mut W } impl < 'a > _CH0LIMITHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CH0LIMITHW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( CH0LIMITHW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub fn bit ( self , value : bool ) -> & 'a mut W { const MASK : 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 `CH0LIMITL`" ] pub enum CH0LIMITLW { # [ doc = "Enable" ] SET , } impl CH0LIMITLW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CH0LIMITLW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _CH0LIMITLW < 'a > { w : & 'a mut W } impl < 'a > _CH0LIMITLW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CH0LIMITLW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( CH0LIMITLW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub fn bit ( self , value : bool ) -> & 'a mut W { const MASK : 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 `CH1LIMITH`" ] pub enum CH1LIMITHW { # [ doc = "Enable" ] SET , } impl CH1LIMITHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CH1LIMITHW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _CH1LIMITHW < 'a > { w : & 'a mut W } impl < 'a > _CH1LIMITHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CH1LIMITHW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( CH1LIMITHW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub fn bit ( self , value : bool ) -> & 'a mut W { const MASK : 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 `CH1LIMITL`" ] pub enum CH1LIMITLW { # [ doc = "Enable" ] SET , } impl CH1LIMITLW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CH1LIMITLW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _CH1LIMITLW < 'a > { w : & 'a mut W } impl < 'a > _CH1LIMITLW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CH1LIMITLW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( CH1LIMITLW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub fn bit ( self , value : bool ) -> & 'a mut W { const 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 `CH2LIMITH`" ] pub enum CH2LIMITHW { # [ doc = "Enable" ] SET , } impl CH2LIMITHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CH2LIMITHW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _CH2LIMITHW < 'a > { w : & 'a mut W } impl < 'a > _CH2LIMITHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CH2LIMITHW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( CH2LIMITHW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 `CH2LIMITL`" ] pub enum CH2LIMITLW { # [ doc = "Enable" ] SET , } impl CH2LIMITLW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CH2LIMITLW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _CH2LIMITLW < 'a > { w : & 'a mut W } impl < 'a > _CH2LIMITLW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CH2LIMITLW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( CH2LIMITLW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 `CH3LIMITH`" ] pub enum CH3LIMITHW { # [ doc = "Enable" ] SET , } impl CH3LIMITHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CH3LIMITHW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _CH3LIMITHW < 'a > { w : & 'a mut W } impl < 'a > _CH3LIMITHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CH3LIMITHW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( CH3LIMITHW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub fn bit ( self , value : bool ) -> & 'a mut W { const MASK : 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 `CH3LIMITL`" ] pub enum CH3LIMITLW { # [ doc = "Enable" ] SET , } impl CH3LIMITLW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CH3LIMITLW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _CH3LIMITLW < 'a > { w : & 'a mut W } impl < 'a > _CH3LIMITLW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CH3LIMITLW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( CH3LIMITLW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 `CH4LIMITH`" ] pub enum CH4LIMITHW { # [ doc = "Enable" ] SET , } impl CH4LIMITHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CH4LIMITHW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _CH4LIMITHW < 'a > { w : & 'a mut W } impl < 'a > _CH4LIMITHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CH4LIMITHW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( CH4LIMITHW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 `CH4LIMITL`" ] pub enum CH4LIMITLW { # [ doc = "Enable" ] SET , } impl CH4LIMITLW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CH4LIMITLW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _CH4LIMITLW < 'a > { w : & 'a mut W } impl < 'a > _CH4LIMITLW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CH4LIMITLW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( CH4LIMITLW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 `CH5LIMITH`" ] pub enum CH5LIMITHW { # [ doc = "Enable" ] SET , } impl CH5LIMITHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CH5LIMITHW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _CH5LIMITHW < 'a > { w : & 'a mut W } impl < 'a > _CH5LIMITHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CH5LIMITHW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( CH5LIMITHW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 `CH5LIMITL`" ] pub enum CH5LIMITLW { # [ doc = "Enable" ] SET , } impl CH5LIMITLW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CH5LIMITLW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _CH5LIMITLW < 'a > { w : & 'a mut W } impl < 'a > _CH5LIMITLW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CH5LIMITLW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( CH5LIMITLW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 `CH6LIMITH`" ] pub enum CH6LIMITHW { # [ doc = "Enable" ] SET , } impl CH6LIMITHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CH6LIMITHW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _CH6LIMITHW < 'a > { w : & 'a mut W } impl < 'a > _CH6LIMITHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CH6LIMITHW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( CH6LIMITHW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 `CH6LIMITL`" ] pub enum CH6LIMITLW { # [ doc = "Enable" ] SET , } impl CH6LIMITLW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CH6LIMITLW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _CH6LIMITLW < 'a > { w : & 'a mut W } impl < 'a > _CH6LIMITLW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CH6LIMITLW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( CH6LIMITLW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 `CH7LIMITH`" ] pub enum CH7LIMITHW { # [ doc = "Enable" ] SET , } impl CH7LIMITHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CH7LIMITHW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _CH7LIMITHW < 'a > { w : & 'a mut W } impl < 'a > _CH7LIMITHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CH7LIMITHW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( CH7LIMITHW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 `CH7LIMITL`" ] pub enum CH7LIMITLW { # [ doc = "Enable" ] SET , } impl CH7LIMITLW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CH7LIMITLW :: SET => true , } } } # [ doc = r" Proxy" ] pub struct _CH7LIMITLW < 'a > { w : & 'a mut W } impl < 'a > _CH7LIMITLW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CH7LIMITLW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Enable" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( CH7LIMITLW :: SET ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub fn bit ( self , value : bool ) -> & 'a mut W { const MASK : bool = true ; const OFFSET : u8 = 21 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Write '1' to Enable interrupt for STARTED event" ] # [ inline ] pub fn started ( & self ) -> STARTEDR { STARTEDR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 1 - Write '1' to Enable interrupt for END event" ] # [ inline ] pub fn end ( & self ) -> ENDR { ENDR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 2 - Write '1' to Enable interrupt for DONE event" ] # [ inline ] pub fn done ( & self ) -> DONER { DONER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 3 - Write '1' to Enable interrupt for RESULTDONE event" ] # [ inline ] pub fn resultdone ( & self ) -> RESULTDONER { RESULTDONER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 4 - Write '1' to Enable interrupt for CALIBRATEDONE event" ] # [ inline ] pub fn calibratedone ( & self ) -> CALIBRATEDONER { CALIBRATEDONER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 5 - Write '1' to Enable interrupt for STOPPED event" ] # [ inline ] pub fn stopped ( & self ) -> STOPPEDR { STOPPEDR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 6 - Write '1' to Enable interrupt for CH[0].LIMITH event" ] # [ inline ] pub fn ch0limith ( & self ) -> CH0LIMITHR { CH0LIMITHR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 7 - Write '1' to Enable interrupt for CH[0].LIMITL event" ] # [ inline ] pub fn ch0limitl ( & self ) -> CH0LIMITLR { CH0LIMITLR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 8 - Write '1' to Enable interrupt for CH[1].LIMITH event" ] # [ inline ] pub fn ch1limith ( & self ) -> CH1LIMITHR { CH1LIMITHR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 9 - Write '1' to Enable interrupt for CH[1].LIMITL event" ] # [ inline ] pub fn ch1limitl ( & self ) -> CH1LIMITLR { CH1LIMITLR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 10 - Write '1' to Enable interrupt for CH[2].LIMITH event" ] # [ inline ] pub fn ch2limith ( & self ) -> CH2LIMITHR { CH2LIMITHR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 11 - Write '1' to Enable interrupt for CH[2].LIMITL event" ] # [ inline ] pub fn ch2limitl ( & self ) -> CH2LIMITLR { CH2LIMITLR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 12 - Write '1' to Enable interrupt for CH[3].LIMITH event" ] # [ inline ] pub fn ch3limith ( & self ) -> CH3LIMITHR { CH3LIMITHR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 13 - Write '1' to Enable interrupt for CH[3].LIMITL event" ] # [ inline ] pub fn ch3limitl ( & self ) -> CH3LIMITLR { CH3LIMITLR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 14 - Write '1' to Enable interrupt for CH[4].LIMITH event" ] # [ inline ] pub fn ch4limith ( & self ) -> CH4LIMITHR { CH4LIMITHR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 15 - Write '1' to Enable interrupt for CH[4].LIMITL event" ] # [ inline ] pub fn ch4limitl ( & self ) -> CH4LIMITLR { CH4LIMITLR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 16 - Write '1' to Enable interrupt for CH[5].LIMITH event" ] # [ inline ] pub fn ch5limith ( & self ) -> CH5LIMITHR { CH5LIMITHR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 17 - Write '1' to Enable interrupt for CH[5].LIMITL event" ] # [ inline ] pub fn ch5limitl ( & self ) -> CH5LIMITLR { CH5LIMITLR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 18 - Write '1' to Enable interrupt for CH[6].LIMITH event" ] # [ inline ] pub fn ch6limith ( & self ) -> CH6LIMITHR { CH6LIMITHR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 19 - Write '1' to Enable interrupt for CH[6].LIMITL event" ] # [ inline ] pub fn ch6limitl ( & self ) -> CH6LIMITLR { CH6LIMITLR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 20 - Write '1' to Enable interrupt for CH[7].LIMITH event" ] # [ inline ] pub fn ch7limith ( & self ) -> CH7LIMITHR { CH7LIMITHR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 21 - Write '1' to Enable interrupt for CH[7].LIMITL event" ] # [ inline ] pub fn ch7limitl ( & self ) -> CH7LIMITLR { CH7LIMITLR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( 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 - Write '1' to Enable interrupt for STARTED event" ] # [ inline ] pub fn started ( & mut self ) -> _STARTEDW { _STARTEDW { w : self } } # [ doc = "Bit 1 - Write '1' to Enable interrupt for END event" ] # [ inline ] pub fn end ( & mut self ) -> _ENDW { _ENDW { w : self } } # [ doc = "Bit 2 - Write '1' to Enable interrupt for DONE event" ] # [ inline ] pub fn done ( & mut self ) -> _DONEW { _DONEW { w : self } } # [ doc = "Bit 3 - Write '1' to Enable interrupt for RESULTDONE event" ] # [ inline ] pub fn resultdone ( & mut self ) -> _RESULTDONEW { _RESULTDONEW { w : self } } # [ doc = "Bit 4 - Write '1' to Enable interrupt for CALIBRATEDONE event" ] # [ inline ] pub fn calibratedone ( & mut self ) -> _CALIBRATEDONEW { _CALIBRATEDONEW { w : self } } # [ doc = "Bit 5 - Write '1' to Enable interrupt for STOPPED event" ] # [ inline ] pub fn stopped ( & mut self ) -> _STOPPEDW { _STOPPEDW { w : self } } # [ doc = "Bit 6 - Write '1' to Enable interrupt for CH[0].LIMITH event" ] # [ inline ] pub fn ch0limith ( & mut self ) -> _CH0LIMITHW { _CH0LIMITHW { w : self } } # [ doc = "Bit 7 - Write '1' to Enable interrupt for CH[0].LIMITL event" ] # [ inline ] pub fn ch0limitl ( & mut self ) -> _CH0LIMITLW { _CH0LIMITLW { w : self } } # [ doc = "Bit 8 - Write '1' to Enable interrupt for CH[1].LIMITH event" ] # [ inline ] pub fn ch1limith ( & mut self ) -> _CH1LIMITHW { _CH1LIMITHW { w : self } } # [ doc = "Bit 9 - Write '1' to Enable interrupt for CH[1].LIMITL event" ] # [ inline ] pub fn ch1limitl ( & mut self ) -> _CH1LIMITLW { _CH1LIMITLW { w : self } } # [ doc = "Bit 10 - Write '1' to Enable interrupt for CH[2].LIMITH event" ] # [ inline ] pub fn ch2limith ( & mut self ) -> _CH2LIMITHW { _CH2LIMITHW { w : self } } # [ doc = "Bit 11 - Write '1' to Enable interrupt for CH[2].LIMITL event" ] # [ inline ] pub fn ch2limitl ( & mut self ) -> _CH2LIMITLW { _CH2LIMITLW { w : self } } # [ doc = "Bit 12 - Write '1' to Enable interrupt for CH[3].LIMITH event" ] # [ inline ] pub fn ch3limith ( & mut self ) -> _CH3LIMITHW { _CH3LIMITHW { w : self } } # [ doc = "Bit 13 - Write '1' to Enable interrupt for CH[3].LIMITL event" ] # [ inline ] pub fn ch3limitl ( & mut self ) -> _CH3LIMITLW { _CH3LIMITLW { w : self } } # [ doc = "Bit 14 - Write '1' to Enable interrupt for CH[4].LIMITH event" ] # [ inline ] pub fn ch4limith ( & mut self ) -> _CH4LIMITHW { _CH4LIMITHW { w : self } } # [ doc = "Bit 15 - Write '1' to Enable interrupt for CH[4].LIMITL event" ] # [ inline ] pub fn ch4limitl ( & mut self ) -> _CH4LIMITLW { _CH4LIMITLW { w : self } } # [ doc = "Bit 16 - Write '1' to Enable interrupt for CH[5].LIMITH event" ] # [ inline ] pub fn ch5limith ( & mut self ) -> _CH5LIMITHW { _CH5LIMITHW { w : self } } # [ doc = "Bit 17 - Write '1' to Enable interrupt for CH[5].LIMITL event" ] # [ inline ] pub fn ch5limitl ( & mut self ) -> _CH5LIMITLW { _CH5LIMITLW { w : self } } # [ doc = "Bit 18 - Write '1' to Enable interrupt for CH[6].LIMITH event" ] # [ inline ] pub fn ch6limith ( & mut self ) -> _CH6LIMITHW { _CH6LIMITHW { w : self } } # [ doc = "Bit 19 - Write '1' to Enable interrupt for CH[6].LIMITL event" ] # [ inline ] pub fn ch6limitl ( & mut self ) -> _CH6LIMITLW { _CH6LIMITLW { w : self } } # [ doc = "Bit 20 - Write '1' to Enable interrupt for CH[7].LIMITH event" ] # [ inline ] pub fn ch7limith ( & mut self ) -> _CH7LIMITHW { _CH7LIMITHW { w : self } } # [ doc = "Bit 21 - Write '1' to Enable interrupt for CH[7].LIMITL event" ] # [ inline ] pub fn ch7limitl ( & mut self ) -> _CH7LIMITLW { _CH7LIMITLW { w : self } } }