1# [doc = "Register `DOE31_0` reader"] pub type R = crate :: R < DOE31_0_SPEC > ; # [doc = "Register `DOE31_0` writer"] pub type W = crate :: W < DOE31_0_SPEC > ; # [doc = "Field `DOE31_0_DIO0` reader - Enables data output for DIO0."] pub type DOE31_0_DIO0_R = crate :: BitReader < DOE31_0_DIO0_A > ; # [doc = "Enables data output for DIO0.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO0_A { # [doc = "0: DISABLE"] DOE31_0_DIO0_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO0_ENABLE = 1 , } impl From < DOE31_0_DIO0_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO0_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO0_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO0_A { match self . bits { false => DOE31_0_DIO0_A :: DOE31_0_DIO0_DISABLE , true => DOE31_0_DIO0_A :: DOE31_0_DIO0_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio0_disable (& self) -> bool { * self == DOE31_0_DIO0_A :: DOE31_0_DIO0_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio0_enable (& self) -> bool { * self == DOE31_0_DIO0_A :: DOE31_0_DIO0_ENABLE } } # [doc = "Field `DOE31_0_DIO0` writer - Enables data output for DIO0."] pub type DOE31_0_DIO0_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO0_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO0_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio0_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO0_A :: DOE31_0_DIO0_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio0_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO0_A :: DOE31_0_DIO0_ENABLE) } } # [doc = "Field `DOE31_0_DIO1` reader - Enables data output for DIO1."] pub type DOE31_0_DIO1_R = crate :: BitReader < DOE31_0_DIO1_A > ; # [doc = "Enables data output for DIO1.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO1_A { # [doc = "0: DISABLE"] DOE31_0_DIO1_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO1_ENABLE = 1 , } impl From < DOE31_0_DIO1_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO1_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO1_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO1_A { match self . bits { false => DOE31_0_DIO1_A :: DOE31_0_DIO1_DISABLE , true => DOE31_0_DIO1_A :: DOE31_0_DIO1_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio1_disable (& self) -> bool { * self == DOE31_0_DIO1_A :: DOE31_0_DIO1_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio1_enable (& self) -> bool { * self == DOE31_0_DIO1_A :: DOE31_0_DIO1_ENABLE } } # [doc = "Field `DOE31_0_DIO1` writer - Enables data output for DIO1."] pub type DOE31_0_DIO1_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO1_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO1_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio1_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO1_A :: DOE31_0_DIO1_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio1_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO1_A :: DOE31_0_DIO1_ENABLE) } } # [doc = "Field `DOE31_0_DIO2` reader - Enables data output for DIO2."] pub type DOE31_0_DIO2_R = crate :: BitReader < DOE31_0_DIO2_A > ; # [doc = "Enables data output for DIO2.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO2_A { # [doc = "0: DISABLE"] DOE31_0_DIO2_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO2_ENABLE = 1 , } impl From < DOE31_0_DIO2_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO2_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO2_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO2_A { match self . bits { false => DOE31_0_DIO2_A :: DOE31_0_DIO2_DISABLE , true => DOE31_0_DIO2_A :: DOE31_0_DIO2_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio2_disable (& self) -> bool { * self == DOE31_0_DIO2_A :: DOE31_0_DIO2_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio2_enable (& self) -> bool { * self == DOE31_0_DIO2_A :: DOE31_0_DIO2_ENABLE } } # [doc = "Field `DOE31_0_DIO2` writer - Enables data output for DIO2."] pub type DOE31_0_DIO2_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO2_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO2_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio2_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO2_A :: DOE31_0_DIO2_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio2_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO2_A :: DOE31_0_DIO2_ENABLE) } } # [doc = "Field `DOE31_0_DIO3` reader - Enables data output for DIO3."] pub type DOE31_0_DIO3_R = crate :: BitReader < DOE31_0_DIO3_A > ; # [doc = "Enables data output for DIO3.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO3_A { # [doc = "0: DISABLE"] DOE31_0_DIO3_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO3_ENABLE = 1 , } impl From < DOE31_0_DIO3_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO3_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO3_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO3_A { match self . bits { false => DOE31_0_DIO3_A :: DOE31_0_DIO3_DISABLE , true => DOE31_0_DIO3_A :: DOE31_0_DIO3_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio3_disable (& self) -> bool { * self == DOE31_0_DIO3_A :: DOE31_0_DIO3_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio3_enable (& self) -> bool { * self == DOE31_0_DIO3_A :: DOE31_0_DIO3_ENABLE } } # [doc = "Field `DOE31_0_DIO3` writer - Enables data output for DIO3."] pub type DOE31_0_DIO3_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO3_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO3_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio3_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO3_A :: DOE31_0_DIO3_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio3_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO3_A :: DOE31_0_DIO3_ENABLE) } } # [doc = "Field `DOE31_0_DIO4` reader - Enables data output for DIO4."] pub type DOE31_0_DIO4_R = crate :: BitReader < DOE31_0_DIO4_A > ; # [doc = "Enables data output for DIO4.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO4_A { # [doc = "0: DISABLE"] DOE31_0_DIO4_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO4_ENABLE = 1 , } impl From < DOE31_0_DIO4_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO4_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO4_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO4_A { match self . bits { false => DOE31_0_DIO4_A :: DOE31_0_DIO4_DISABLE , true => DOE31_0_DIO4_A :: DOE31_0_DIO4_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio4_disable (& self) -> bool { * self == DOE31_0_DIO4_A :: DOE31_0_DIO4_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio4_enable (& self) -> bool { * self == DOE31_0_DIO4_A :: DOE31_0_DIO4_ENABLE } } # [doc = "Field `DOE31_0_DIO4` writer - Enables data output for DIO4."] pub type DOE31_0_DIO4_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO4_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO4_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio4_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO4_A :: DOE31_0_DIO4_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio4_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO4_A :: DOE31_0_DIO4_ENABLE) } } # [doc = "Field `DOE31_0_DIO5` reader - Enables data output for DIO5."] pub type DOE31_0_DIO5_R = crate :: BitReader < DOE31_0_DIO5_A > ; # [doc = "Enables data output for DIO5.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO5_A { # [doc = "0: DISABLE"] DOE31_0_DIO5_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO5_ENABLE = 1 , } impl From < DOE31_0_DIO5_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO5_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO5_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO5_A { match self . bits { false => DOE31_0_DIO5_A :: DOE31_0_DIO5_DISABLE , true => DOE31_0_DIO5_A :: DOE31_0_DIO5_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio5_disable (& self) -> bool { * self == DOE31_0_DIO5_A :: DOE31_0_DIO5_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio5_enable (& self) -> bool { * self == DOE31_0_DIO5_A :: DOE31_0_DIO5_ENABLE } } # [doc = "Field `DOE31_0_DIO5` writer - Enables data output for DIO5."] pub type DOE31_0_DIO5_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO5_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO5_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio5_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO5_A :: DOE31_0_DIO5_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio5_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO5_A :: DOE31_0_DIO5_ENABLE) } } # [doc = "Field `DOE31_0_DIO6` reader - Enables data output for DIO6."] pub type DOE31_0_DIO6_R = crate :: BitReader < DOE31_0_DIO6_A > ; # [doc = "Enables data output for DIO6.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO6_A { # [doc = "0: DISABLE"] DOE31_0_DIO6_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO6_ENABLE = 1 , } impl From < DOE31_0_DIO6_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO6_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO6_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO6_A { match self . bits { false => DOE31_0_DIO6_A :: DOE31_0_DIO6_DISABLE , true => DOE31_0_DIO6_A :: DOE31_0_DIO6_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio6_disable (& self) -> bool { * self == DOE31_0_DIO6_A :: DOE31_0_DIO6_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio6_enable (& self) -> bool { * self == DOE31_0_DIO6_A :: DOE31_0_DIO6_ENABLE } } # [doc = "Field `DOE31_0_DIO6` writer - Enables data output for DIO6."] pub type DOE31_0_DIO6_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO6_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO6_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio6_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO6_A :: DOE31_0_DIO6_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio6_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO6_A :: DOE31_0_DIO6_ENABLE) } } # [doc = "Field `DOE31_0_DIO7` reader - Enables data output for DIO7."] pub type DOE31_0_DIO7_R = crate :: BitReader < DOE31_0_DIO7_A > ; # [doc = "Enables data output for DIO7.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO7_A { # [doc = "0: DISABLE"] DOE31_0_DIO7_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO7_ENABLE = 1 , } impl From < DOE31_0_DIO7_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO7_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO7_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO7_A { match self . bits { false => DOE31_0_DIO7_A :: DOE31_0_DIO7_DISABLE , true => DOE31_0_DIO7_A :: DOE31_0_DIO7_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio7_disable (& self) -> bool { * self == DOE31_0_DIO7_A :: DOE31_0_DIO7_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio7_enable (& self) -> bool { * self == DOE31_0_DIO7_A :: DOE31_0_DIO7_ENABLE } } # [doc = "Field `DOE31_0_DIO7` writer - Enables data output for DIO7."] pub type DOE31_0_DIO7_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO7_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO7_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio7_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO7_A :: DOE31_0_DIO7_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio7_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO7_A :: DOE31_0_DIO7_ENABLE) } } # [doc = "Field `DOE31_0_DIO8` reader - Enables data output for DIO8."] pub type DOE31_0_DIO8_R = crate :: BitReader < DOE31_0_DIO8_A > ; # [doc = "Enables data output for DIO8.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO8_A { # [doc = "0: DISABLE"] DOE31_0_DIO8_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO8_ENABLE = 1 , } impl From < DOE31_0_DIO8_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO8_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO8_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO8_A { match self . bits { false => DOE31_0_DIO8_A :: DOE31_0_DIO8_DISABLE , true => DOE31_0_DIO8_A :: DOE31_0_DIO8_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio8_disable (& self) -> bool { * self == DOE31_0_DIO8_A :: DOE31_0_DIO8_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio8_enable (& self) -> bool { * self == DOE31_0_DIO8_A :: DOE31_0_DIO8_ENABLE } } # [doc = "Field `DOE31_0_DIO8` writer - Enables data output for DIO8."] pub type DOE31_0_DIO8_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO8_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO8_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio8_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO8_A :: DOE31_0_DIO8_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio8_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO8_A :: DOE31_0_DIO8_ENABLE) } } # [doc = "Field `DOE31_0_DIO9` reader - Enables data output for DIO9."] pub type DOE31_0_DIO9_R = crate :: BitReader < DOE31_0_DIO9_A > ; # [doc = "Enables data output for DIO9.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO9_A { # [doc = "0: DISABLE"] DOE31_0_DIO9_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO9_ENABLE = 1 , } impl From < DOE31_0_DIO9_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO9_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO9_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO9_A { match self . bits { false => DOE31_0_DIO9_A :: DOE31_0_DIO9_DISABLE , true => DOE31_0_DIO9_A :: DOE31_0_DIO9_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio9_disable (& self) -> bool { * self == DOE31_0_DIO9_A :: DOE31_0_DIO9_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio9_enable (& self) -> bool { * self == DOE31_0_DIO9_A :: DOE31_0_DIO9_ENABLE } } # [doc = "Field `DOE31_0_DIO9` writer - Enables data output for DIO9."] pub type DOE31_0_DIO9_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO9_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO9_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio9_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO9_A :: DOE31_0_DIO9_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio9_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO9_A :: DOE31_0_DIO9_ENABLE) } } # [doc = "Field `DOE31_0_DIO10` reader - Enables data output for DIO10."] pub type DOE31_0_DIO10_R = crate :: BitReader < DOE31_0_DIO10_A > ; # [doc = "Enables data output for DIO10.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO10_A { # [doc = "0: DISABLE"] DOE31_0_DIO10_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO10_ENABLE = 1 , } impl From < DOE31_0_DIO10_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO10_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO10_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO10_A { match self . bits { false => DOE31_0_DIO10_A :: DOE31_0_DIO10_DISABLE , true => DOE31_0_DIO10_A :: DOE31_0_DIO10_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio10_disable (& self) -> bool { * self == DOE31_0_DIO10_A :: DOE31_0_DIO10_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio10_enable (& self) -> bool { * self == DOE31_0_DIO10_A :: DOE31_0_DIO10_ENABLE } } # [doc = "Field `DOE31_0_DIO10` writer - Enables data output for DIO10."] pub type DOE31_0_DIO10_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO10_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO10_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio10_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO10_A :: DOE31_0_DIO10_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio10_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO10_A :: DOE31_0_DIO10_ENABLE) } } # [doc = "Field `DOE31_0_DIO11` reader - Enables data output for DIO11."] pub type DOE31_0_DIO11_R = crate :: BitReader < DOE31_0_DIO11_A > ; # [doc = "Enables data output for DIO11.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO11_A { # [doc = "0: DISABLE"] DOE31_0_DIO11_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO11_ENABLE = 1 , } impl From < DOE31_0_DIO11_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO11_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO11_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO11_A { match self . bits { false => DOE31_0_DIO11_A :: DOE31_0_DIO11_DISABLE , true => DOE31_0_DIO11_A :: DOE31_0_DIO11_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio11_disable (& self) -> bool { * self == DOE31_0_DIO11_A :: DOE31_0_DIO11_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio11_enable (& self) -> bool { * self == DOE31_0_DIO11_A :: DOE31_0_DIO11_ENABLE } } # [doc = "Field `DOE31_0_DIO11` writer - Enables data output for DIO11."] pub type DOE31_0_DIO11_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO11_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO11_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio11_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO11_A :: DOE31_0_DIO11_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio11_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO11_A :: DOE31_0_DIO11_ENABLE) } } # [doc = "Field `DOE31_0_DIO12` reader - Enables data output for DIO12."] pub type DOE31_0_DIO12_R = crate :: BitReader < DOE31_0_DIO12_A > ; # [doc = "Enables data output for DIO12.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO12_A { # [doc = "0: DISABLE"] DOE31_0_DIO12_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO12_ENABLE = 1 , } impl From < DOE31_0_DIO12_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO12_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO12_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO12_A { match self . bits { false => DOE31_0_DIO12_A :: DOE31_0_DIO12_DISABLE , true => DOE31_0_DIO12_A :: DOE31_0_DIO12_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio12_disable (& self) -> bool { * self == DOE31_0_DIO12_A :: DOE31_0_DIO12_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio12_enable (& self) -> bool { * self == DOE31_0_DIO12_A :: DOE31_0_DIO12_ENABLE } } # [doc = "Field `DOE31_0_DIO12` writer - Enables data output for DIO12."] pub type DOE31_0_DIO12_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO12_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO12_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio12_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO12_A :: DOE31_0_DIO12_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio12_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO12_A :: DOE31_0_DIO12_ENABLE) } } # [doc = "Field `DOE31_0_DIO13` reader - Enables data output for DIO13."] pub type DOE31_0_DIO13_R = crate :: BitReader < DOE31_0_DIO13_A > ; # [doc = "Enables data output for DIO13.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO13_A { # [doc = "0: DISABLE"] DOE31_0_DIO13_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO13_ENABLE = 1 , } impl From < DOE31_0_DIO13_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO13_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO13_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO13_A { match self . bits { false => DOE31_0_DIO13_A :: DOE31_0_DIO13_DISABLE , true => DOE31_0_DIO13_A :: DOE31_0_DIO13_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio13_disable (& self) -> bool { * self == DOE31_0_DIO13_A :: DOE31_0_DIO13_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio13_enable (& self) -> bool { * self == DOE31_0_DIO13_A :: DOE31_0_DIO13_ENABLE } } # [doc = "Field `DOE31_0_DIO13` writer - Enables data output for DIO13."] pub type DOE31_0_DIO13_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO13_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO13_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio13_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO13_A :: DOE31_0_DIO13_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio13_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO13_A :: DOE31_0_DIO13_ENABLE) } } # [doc = "Field `DOE31_0_DIO14` reader - Enables data output for DIO14."] pub type DOE31_0_DIO14_R = crate :: BitReader < DOE31_0_DIO14_A > ; # [doc = "Enables data output for DIO14.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO14_A { # [doc = "0: DISABLE"] DOE31_0_DIO14_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO14_ENABLE = 1 , } impl From < DOE31_0_DIO14_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO14_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO14_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO14_A { match self . bits { false => DOE31_0_DIO14_A :: DOE31_0_DIO14_DISABLE , true => DOE31_0_DIO14_A :: DOE31_0_DIO14_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio14_disable (& self) -> bool { * self == DOE31_0_DIO14_A :: DOE31_0_DIO14_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio14_enable (& self) -> bool { * self == DOE31_0_DIO14_A :: DOE31_0_DIO14_ENABLE } } # [doc = "Field `DOE31_0_DIO14` writer - Enables data output for DIO14."] pub type DOE31_0_DIO14_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO14_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO14_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio14_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO14_A :: DOE31_0_DIO14_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio14_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO14_A :: DOE31_0_DIO14_ENABLE) } } # [doc = "Field `DOE31_0_DIO15` reader - Enables data output for DIO15."] pub type DOE31_0_DIO15_R = crate :: BitReader < DOE31_0_DIO15_A > ; # [doc = "Enables data output for DIO15.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO15_A { # [doc = "0: DISABLE"] DOE31_0_DIO15_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO15_ENABLE = 1 , } impl From < DOE31_0_DIO15_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO15_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO15_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO15_A { match self . bits { false => DOE31_0_DIO15_A :: DOE31_0_DIO15_DISABLE , true => DOE31_0_DIO15_A :: DOE31_0_DIO15_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio15_disable (& self) -> bool { * self == DOE31_0_DIO15_A :: DOE31_0_DIO15_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio15_enable (& self) -> bool { * self == DOE31_0_DIO15_A :: DOE31_0_DIO15_ENABLE } } # [doc = "Field `DOE31_0_DIO15` writer - Enables data output for DIO15."] pub type DOE31_0_DIO15_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO15_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO15_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio15_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO15_A :: DOE31_0_DIO15_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio15_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO15_A :: DOE31_0_DIO15_ENABLE) } } # [doc = "Field `DOE31_0_DIO16` reader - Enables data output for DIO16."] pub type DOE31_0_DIO16_R = crate :: BitReader < DOE31_0_DIO16_A > ; # [doc = "Enables data output for DIO16.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO16_A { # [doc = "0: DISABLE"] DOE31_0_DIO16_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO16_ENABLE = 1 , } impl From < DOE31_0_DIO16_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO16_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO16_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO16_A { match self . bits { false => DOE31_0_DIO16_A :: DOE31_0_DIO16_DISABLE , true => DOE31_0_DIO16_A :: DOE31_0_DIO16_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio16_disable (& self) -> bool { * self == DOE31_0_DIO16_A :: DOE31_0_DIO16_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio16_enable (& self) -> bool { * self == DOE31_0_DIO16_A :: DOE31_0_DIO16_ENABLE } } # [doc = "Field `DOE31_0_DIO16` writer - Enables data output for DIO16."] pub type DOE31_0_DIO16_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO16_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO16_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio16_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO16_A :: DOE31_0_DIO16_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio16_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO16_A :: DOE31_0_DIO16_ENABLE) } } # [doc = "Field `DOE31_0_DIO17` reader - Enables data output for DIO17."] pub type DOE31_0_DIO17_R = crate :: BitReader < DOE31_0_DIO17_A > ; # [doc = "Enables data output for DIO17.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO17_A { # [doc = "0: DISABLE"] DOE31_0_DIO17_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO17_ENABLE = 1 , } impl From < DOE31_0_DIO17_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO17_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO17_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO17_A { match self . bits { false => DOE31_0_DIO17_A :: DOE31_0_DIO17_DISABLE , true => DOE31_0_DIO17_A :: DOE31_0_DIO17_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio17_disable (& self) -> bool { * self == DOE31_0_DIO17_A :: DOE31_0_DIO17_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio17_enable (& self) -> bool { * self == DOE31_0_DIO17_A :: DOE31_0_DIO17_ENABLE } } # [doc = "Field `DOE31_0_DIO17` writer - Enables data output for DIO17."] pub type DOE31_0_DIO17_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO17_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO17_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio17_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO17_A :: DOE31_0_DIO17_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio17_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO17_A :: DOE31_0_DIO17_ENABLE) } } # [doc = "Field `DOE31_0_DIO18` reader - Enables data output for DIO18."] pub type DOE31_0_DIO18_R = crate :: BitReader < DOE31_0_DIO18_A > ; # [doc = "Enables data output for DIO18.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO18_A { # [doc = "0: DISABLE"] DOE31_0_DIO18_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO18_ENABLE = 1 , } impl From < DOE31_0_DIO18_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO18_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO18_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO18_A { match self . bits { false => DOE31_0_DIO18_A :: DOE31_0_DIO18_DISABLE , true => DOE31_0_DIO18_A :: DOE31_0_DIO18_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio18_disable (& self) -> bool { * self == DOE31_0_DIO18_A :: DOE31_0_DIO18_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio18_enable (& self) -> bool { * self == DOE31_0_DIO18_A :: DOE31_0_DIO18_ENABLE } } # [doc = "Field `DOE31_0_DIO18` writer - Enables data output for DIO18."] pub type DOE31_0_DIO18_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO18_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO18_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio18_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO18_A :: DOE31_0_DIO18_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio18_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO18_A :: DOE31_0_DIO18_ENABLE) } } # [doc = "Field `DOE31_0_DIO19` reader - Enables data output for DIO19."] pub type DOE31_0_DIO19_R = crate :: BitReader < DOE31_0_DIO19_A > ; # [doc = "Enables data output for DIO19.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO19_A { # [doc = "0: DISABLE"] DOE31_0_DIO19_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO19_ENABLE = 1 , } impl From < DOE31_0_DIO19_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO19_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO19_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO19_A { match self . bits { false => DOE31_0_DIO19_A :: DOE31_0_DIO19_DISABLE , true => DOE31_0_DIO19_A :: DOE31_0_DIO19_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio19_disable (& self) -> bool { * self == DOE31_0_DIO19_A :: DOE31_0_DIO19_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio19_enable (& self) -> bool { * self == DOE31_0_DIO19_A :: DOE31_0_DIO19_ENABLE } } # [doc = "Field `DOE31_0_DIO19` writer - Enables data output for DIO19."] pub type DOE31_0_DIO19_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO19_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO19_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio19_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO19_A :: DOE31_0_DIO19_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio19_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO19_A :: DOE31_0_DIO19_ENABLE) } } # [doc = "Field `DOE31_0_DIO20` reader - Enables data output for DIO20."] pub type DOE31_0_DIO20_R = crate :: BitReader < DOE31_0_DIO20_A > ; # [doc = "Enables data output for DIO20.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO20_A { # [doc = "0: DISABLE"] DOE31_0_DIO20_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO20_ENABLE = 1 , } impl From < DOE31_0_DIO20_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO20_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO20_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO20_A { match self . bits { false => DOE31_0_DIO20_A :: DOE31_0_DIO20_DISABLE , true => DOE31_0_DIO20_A :: DOE31_0_DIO20_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio20_disable (& self) -> bool { * self == DOE31_0_DIO20_A :: DOE31_0_DIO20_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio20_enable (& self) -> bool { * self == DOE31_0_DIO20_A :: DOE31_0_DIO20_ENABLE } } # [doc = "Field `DOE31_0_DIO20` writer - Enables data output for DIO20."] pub type DOE31_0_DIO20_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO20_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO20_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio20_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO20_A :: DOE31_0_DIO20_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio20_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO20_A :: DOE31_0_DIO20_ENABLE) } } # [doc = "Field `DOE31_0_DIO21` reader - Enables data output for DIO21."] pub type DOE31_0_DIO21_R = crate :: BitReader < DOE31_0_DIO21_A > ; # [doc = "Enables data output for DIO21.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO21_A { # [doc = "0: DISABLE"] DOE31_0_DIO21_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO21_ENABLE = 1 , } impl From < DOE31_0_DIO21_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO21_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO21_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO21_A { match self . bits { false => DOE31_0_DIO21_A :: DOE31_0_DIO21_DISABLE , true => DOE31_0_DIO21_A :: DOE31_0_DIO21_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio21_disable (& self) -> bool { * self == DOE31_0_DIO21_A :: DOE31_0_DIO21_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio21_enable (& self) -> bool { * self == DOE31_0_DIO21_A :: DOE31_0_DIO21_ENABLE } } # [doc = "Field `DOE31_0_DIO21` writer - Enables data output for DIO21."] pub type DOE31_0_DIO21_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO21_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO21_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio21_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO21_A :: DOE31_0_DIO21_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio21_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO21_A :: DOE31_0_DIO21_ENABLE) } } # [doc = "Field `DOE31_0_DIO22` reader - Enables data output for DIO22."] pub type DOE31_0_DIO22_R = crate :: BitReader < DOE31_0_DIO22_A > ; # [doc = "Enables data output for DIO22.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO22_A { # [doc = "0: DISABLE"] DOE31_0_DIO22_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO22_ENABLE = 1 , } impl From < DOE31_0_DIO22_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO22_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO22_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO22_A { match self . bits { false => DOE31_0_DIO22_A :: DOE31_0_DIO22_DISABLE , true => DOE31_0_DIO22_A :: DOE31_0_DIO22_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio22_disable (& self) -> bool { * self == DOE31_0_DIO22_A :: DOE31_0_DIO22_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio22_enable (& self) -> bool { * self == DOE31_0_DIO22_A :: DOE31_0_DIO22_ENABLE } } # [doc = "Field `DOE31_0_DIO22` writer - Enables data output for DIO22."] pub type DOE31_0_DIO22_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO22_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO22_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio22_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO22_A :: DOE31_0_DIO22_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio22_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO22_A :: DOE31_0_DIO22_ENABLE) } } # [doc = "Field `DOE31_0_DIO23` reader - Enables data output for DIO23."] pub type DOE31_0_DIO23_R = crate :: BitReader < DOE31_0_DIO23_A > ; # [doc = "Enables data output for DIO23.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO23_A { # [doc = "0: DISABLE"] DOE31_0_DIO23_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO23_ENABLE = 1 , } impl From < DOE31_0_DIO23_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO23_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO23_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO23_A { match self . bits { false => DOE31_0_DIO23_A :: DOE31_0_DIO23_DISABLE , true => DOE31_0_DIO23_A :: DOE31_0_DIO23_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio23_disable (& self) -> bool { * self == DOE31_0_DIO23_A :: DOE31_0_DIO23_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio23_enable (& self) -> bool { * self == DOE31_0_DIO23_A :: DOE31_0_DIO23_ENABLE } } # [doc = "Field `DOE31_0_DIO23` writer - Enables data output for DIO23."] pub type DOE31_0_DIO23_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO23_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO23_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio23_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO23_A :: DOE31_0_DIO23_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio23_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO23_A :: DOE31_0_DIO23_ENABLE) } } # [doc = "Field `DOE31_0_DIO24` reader - Enables data output for DIO24."] pub type DOE31_0_DIO24_R = crate :: BitReader < DOE31_0_DIO24_A > ; # [doc = "Enables data output for DIO24.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO24_A { # [doc = "0: DISABLE"] DOE31_0_DIO24_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO24_ENABLE = 1 , } impl From < DOE31_0_DIO24_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO24_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO24_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO24_A { match self . bits { false => DOE31_0_DIO24_A :: DOE31_0_DIO24_DISABLE , true => DOE31_0_DIO24_A :: DOE31_0_DIO24_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio24_disable (& self) -> bool { * self == DOE31_0_DIO24_A :: DOE31_0_DIO24_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio24_enable (& self) -> bool { * self == DOE31_0_DIO24_A :: DOE31_0_DIO24_ENABLE } } # [doc = "Field `DOE31_0_DIO24` writer - Enables data output for DIO24."] pub type DOE31_0_DIO24_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO24_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO24_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio24_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO24_A :: DOE31_0_DIO24_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio24_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO24_A :: DOE31_0_DIO24_ENABLE) } } # [doc = "Field `DOE31_0_DIO25` reader - Enables data output for DIO25."] pub type DOE31_0_DIO25_R = crate :: BitReader < DOE31_0_DIO25_A > ; # [doc = "Enables data output for DIO25.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO25_A { # [doc = "0: DISABLE"] DOE31_0_DIO25_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO25_ENABLE = 1 , } impl From < DOE31_0_DIO25_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO25_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO25_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO25_A { match self . bits { false => DOE31_0_DIO25_A :: DOE31_0_DIO25_DISABLE , true => DOE31_0_DIO25_A :: DOE31_0_DIO25_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio25_disable (& self) -> bool { * self == DOE31_0_DIO25_A :: DOE31_0_DIO25_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio25_enable (& self) -> bool { * self == DOE31_0_DIO25_A :: DOE31_0_DIO25_ENABLE } } # [doc = "Field `DOE31_0_DIO25` writer - Enables data output for DIO25."] pub type DOE31_0_DIO25_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO25_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO25_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio25_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO25_A :: DOE31_0_DIO25_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio25_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO25_A :: DOE31_0_DIO25_ENABLE) } } # [doc = "Field `DOE31_0_DIO26` reader - Enables data output for DIO26."] pub type DOE31_0_DIO26_R = crate :: BitReader < DOE31_0_DIO26_A > ; # [doc = "Enables data output for DIO26.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO26_A { # [doc = "0: DISABLE"] DOE31_0_DIO26_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO26_ENABLE = 1 , } impl From < DOE31_0_DIO26_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO26_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO26_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO26_A { match self . bits { false => DOE31_0_DIO26_A :: DOE31_0_DIO26_DISABLE , true => DOE31_0_DIO26_A :: DOE31_0_DIO26_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio26_disable (& self) -> bool { * self == DOE31_0_DIO26_A :: DOE31_0_DIO26_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio26_enable (& self) -> bool { * self == DOE31_0_DIO26_A :: DOE31_0_DIO26_ENABLE } } # [doc = "Field `DOE31_0_DIO26` writer - Enables data output for DIO26."] pub type DOE31_0_DIO26_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO26_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO26_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio26_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO26_A :: DOE31_0_DIO26_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio26_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO26_A :: DOE31_0_DIO26_ENABLE) } } # [doc = "Field `DOE31_0_DIO27` reader - Enables data output for DIO27."] pub type DOE31_0_DIO27_R = crate :: BitReader < DOE31_0_DIO27_A > ; # [doc = "Enables data output for DIO27.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO27_A { # [doc = "0: DISABLE"] DOE31_0_DIO27_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO27_ENABLE = 1 , } impl From < DOE31_0_DIO27_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO27_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO27_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO27_A { match self . bits { false => DOE31_0_DIO27_A :: DOE31_0_DIO27_DISABLE , true => DOE31_0_DIO27_A :: DOE31_0_DIO27_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio27_disable (& self) -> bool { * self == DOE31_0_DIO27_A :: DOE31_0_DIO27_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio27_enable (& self) -> bool { * self == DOE31_0_DIO27_A :: DOE31_0_DIO27_ENABLE } } # [doc = "Field `DOE31_0_DIO27` writer - Enables data output for DIO27."] pub type DOE31_0_DIO27_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO27_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO27_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio27_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO27_A :: DOE31_0_DIO27_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio27_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO27_A :: DOE31_0_DIO27_ENABLE) } } # [doc = "Field `DOE31_0_DIO28` reader - Enables data output for DIO28."] pub type DOE31_0_DIO28_R = crate :: BitReader < DOE31_0_DIO28_A > ; # [doc = "Enables data output for DIO28.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO28_A { # [doc = "0: DISABLE"] DOE31_0_DIO28_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO28_ENABLE = 1 , } impl From < DOE31_0_DIO28_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO28_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO28_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO28_A { match self . bits { false => DOE31_0_DIO28_A :: DOE31_0_DIO28_DISABLE , true => DOE31_0_DIO28_A :: DOE31_0_DIO28_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio28_disable (& self) -> bool { * self == DOE31_0_DIO28_A :: DOE31_0_DIO28_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio28_enable (& self) -> bool { * self == DOE31_0_DIO28_A :: DOE31_0_DIO28_ENABLE } } # [doc = "Field `DOE31_0_DIO28` writer - Enables data output for DIO28."] pub type DOE31_0_DIO28_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO28_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO28_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio28_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO28_A :: DOE31_0_DIO28_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio28_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO28_A :: DOE31_0_DIO28_ENABLE) } } # [doc = "Field `DOE31_0_DIO29` reader - Enables data output for DIO29."] pub type DOE31_0_DIO29_R = crate :: BitReader < DOE31_0_DIO29_A > ; # [doc = "Enables data output for DIO29.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO29_A { # [doc = "0: DISABLE"] DOE31_0_DIO29_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO29_ENABLE = 1 , } impl From < DOE31_0_DIO29_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO29_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO29_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO29_A { match self . bits { false => DOE31_0_DIO29_A :: DOE31_0_DIO29_DISABLE , true => DOE31_0_DIO29_A :: DOE31_0_DIO29_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio29_disable (& self) -> bool { * self == DOE31_0_DIO29_A :: DOE31_0_DIO29_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio29_enable (& self) -> bool { * self == DOE31_0_DIO29_A :: DOE31_0_DIO29_ENABLE } } # [doc = "Field `DOE31_0_DIO29` writer - Enables data output for DIO29."] pub type DOE31_0_DIO29_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO29_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO29_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio29_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO29_A :: DOE31_0_DIO29_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio29_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO29_A :: DOE31_0_DIO29_ENABLE) } } # [doc = "Field `DOE31_0_DIO30` reader - Enables data output for DIO30."] pub type DOE31_0_DIO30_R = crate :: BitReader < DOE31_0_DIO30_A > ; # [doc = "Enables data output for DIO30.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO30_A { # [doc = "0: DISABLE"] DOE31_0_DIO30_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO30_ENABLE = 1 , } impl From < DOE31_0_DIO30_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO30_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO30_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO30_A { match self . bits { false => DOE31_0_DIO30_A :: DOE31_0_DIO30_DISABLE , true => DOE31_0_DIO30_A :: DOE31_0_DIO30_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio30_disable (& self) -> bool { * self == DOE31_0_DIO30_A :: DOE31_0_DIO30_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio30_enable (& self) -> bool { * self == DOE31_0_DIO30_A :: DOE31_0_DIO30_ENABLE } } # [doc = "Field `DOE31_0_DIO30` writer - Enables data output for DIO30."] pub type DOE31_0_DIO30_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO30_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO30_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio30_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO30_A :: DOE31_0_DIO30_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio30_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO30_A :: DOE31_0_DIO30_ENABLE) } } # [doc = "Field `DOE31_0_DIO31` reader - Enables data output for DIO31."] pub type DOE31_0_DIO31_R = crate :: BitReader < DOE31_0_DIO31_A > ; # [doc = "Enables data output for DIO31.\n\nValue on reset: 0"] # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum DOE31_0_DIO31_A { # [doc = "0: DISABLE"] DOE31_0_DIO31_DISABLE = 0 , # [doc = "1: ENABLE"] DOE31_0_DIO31_ENABLE = 1 , } impl From < DOE31_0_DIO31_A > for bool { # [inline (always)] fn from (variant : DOE31_0_DIO31_A) -> Self { variant as u8 != 0 } } impl DOE31_0_DIO31_R { # [doc = "Get enumerated values variant"] # [inline (always)] pub const fn variant (& self) -> DOE31_0_DIO31_A { match self . bits { false => DOE31_0_DIO31_A :: DOE31_0_DIO31_DISABLE , true => DOE31_0_DIO31_A :: DOE31_0_DIO31_ENABLE , } } # [doc = "DISABLE"] # [inline (always)] pub fn is_doe31_0_dio31_disable (& self) -> bool { * self == DOE31_0_DIO31_A :: DOE31_0_DIO31_DISABLE } # [doc = "ENABLE"] # [inline (always)] pub fn is_doe31_0_dio31_enable (& self) -> bool { * self == DOE31_0_DIO31_A :: DOE31_0_DIO31_ENABLE } } # [doc = "Field `DOE31_0_DIO31` writer - Enables data output for DIO31."] pub type DOE31_0_DIO31_W < 'a , REG , const O : u8 > = crate :: BitWriter < 'a , REG , O , DOE31_0_DIO31_A > ; impl < 'a , REG , const O : u8 > DOE31_0_DIO31_W < 'a , REG , O > where REG : crate :: Writable + crate :: RegisterSpec , { # [doc = "DISABLE"] # [inline (always)] pub fn doe31_0_dio31_disable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO31_A :: DOE31_0_DIO31_DISABLE) } # [doc = "ENABLE"] # [inline (always)] pub fn doe31_0_dio31_enable (self) -> & 'a mut crate :: W < REG > { self . variant (DOE31_0_DIO31_A :: DOE31_0_DIO31_ENABLE) } } impl R { # [doc = "Bit 0 - Enables data output for DIO0."] # [inline (always)] pub fn doe31_0_dio0 (& self) -> DOE31_0_DIO0_R { DOE31_0_DIO0_R :: new ((self . bits & 1) != 0) } # [doc = "Bit 1 - Enables data output for DIO1."] # [inline (always)] pub fn doe31_0_dio1 (& self) -> DOE31_0_DIO1_R { DOE31_0_DIO1_R :: new (((self . bits >> 1) & 1) != 0) } # [doc = "Bit 2 - Enables data output for DIO2."] # [inline (always)] pub fn doe31_0_dio2 (& self) -> DOE31_0_DIO2_R { DOE31_0_DIO2_R :: new (((self . bits >> 2) & 1) != 0) } # [doc = "Bit 3 - Enables data output for DIO3."] # [inline (always)] pub fn doe31_0_dio3 (& self) -> DOE31_0_DIO3_R { DOE31_0_DIO3_R :: new (((self . bits >> 3) & 1) != 0) } # [doc = "Bit 4 - Enables data output for DIO4."] # [inline (always)] pub fn doe31_0_dio4 (& self) -> DOE31_0_DIO4_R { DOE31_0_DIO4_R :: new (((self . bits >> 4) & 1) != 0) } # [doc = "Bit 5 - Enables data output for DIO5."] # [inline (always)] pub fn doe31_0_dio5 (& self) -> DOE31_0_DIO5_R { DOE31_0_DIO5_R :: new (((self . bits >> 5) & 1) != 0) } # [doc = "Bit 6 - Enables data output for DIO6."] # [inline (always)] pub fn doe31_0_dio6 (& self) -> DOE31_0_DIO6_R { DOE31_0_DIO6_R :: new (((self . bits >> 6) & 1) != 0) } # [doc = "Bit 7 - Enables data output for DIO7."] # [inline (always)] pub fn doe31_0_dio7 (& self) -> DOE31_0_DIO7_R { DOE31_0_DIO7_R :: new (((self . bits >> 7) & 1) != 0) } # [doc = "Bit 8 - Enables data output for DIO8."] # [inline (always)] pub fn doe31_0_dio8 (& self) -> DOE31_0_DIO8_R { DOE31_0_DIO8_R :: new (((self . bits >> 8) & 1) != 0) } # [doc = "Bit 9 - Enables data output for DIO9."] # [inline (always)] pub fn doe31_0_dio9 (& self) -> DOE31_0_DIO9_R { DOE31_0_DIO9_R :: new (((self . bits >> 9) & 1) != 0) } # [doc = "Bit 10 - Enables data output for DIO10."] # [inline (always)] pub fn doe31_0_dio10 (& self) -> DOE31_0_DIO10_R { DOE31_0_DIO10_R :: new (((self . bits >> 10) & 1) != 0) } # [doc = "Bit 11 - Enables data output for DIO11."] # [inline (always)] pub fn doe31_0_dio11 (& self) -> DOE31_0_DIO11_R { DOE31_0_DIO11_R :: new (((self . bits >> 11) & 1) != 0) } # [doc = "Bit 12 - Enables data output for DIO12."] # [inline (always)] pub fn doe31_0_dio12 (& self) -> DOE31_0_DIO12_R { DOE31_0_DIO12_R :: new (((self . bits >> 12) & 1) != 0) } # [doc = "Bit 13 - Enables data output for DIO13."] # [inline (always)] pub fn doe31_0_dio13 (& self) -> DOE31_0_DIO13_R { DOE31_0_DIO13_R :: new (((self . bits >> 13) & 1) != 0) } # [doc = "Bit 14 - Enables data output for DIO14."] # [inline (always)] pub fn doe31_0_dio14 (& self) -> DOE31_0_DIO14_R { DOE31_0_DIO14_R :: new (((self . bits >> 14) & 1) != 0) } # [doc = "Bit 15 - Enables data output for DIO15."] # [inline (always)] pub fn doe31_0_dio15 (& self) -> DOE31_0_DIO15_R { DOE31_0_DIO15_R :: new (((self . bits >> 15) & 1) != 0) } # [doc = "Bit 16 - Enables data output for DIO16."] # [inline (always)] pub fn doe31_0_dio16 (& self) -> DOE31_0_DIO16_R { DOE31_0_DIO16_R :: new (((self . bits >> 16) & 1) != 0) } # [doc = "Bit 17 - Enables data output for DIO17."] # [inline (always)] pub fn doe31_0_dio17 (& self) -> DOE31_0_DIO17_R { DOE31_0_DIO17_R :: new (((self . bits >> 17) & 1) != 0) } # [doc = "Bit 18 - Enables data output for DIO18."] # [inline (always)] pub fn doe31_0_dio18 (& self) -> DOE31_0_DIO18_R { DOE31_0_DIO18_R :: new (((self . bits >> 18) & 1) != 0) } # [doc = "Bit 19 - Enables data output for DIO19."] # [inline (always)] pub fn doe31_0_dio19 (& self) -> DOE31_0_DIO19_R { DOE31_0_DIO19_R :: new (((self . bits >> 19) & 1) != 0) } # [doc = "Bit 20 - Enables data output for DIO20."] # [inline (always)] pub fn doe31_0_dio20 (& self) -> DOE31_0_DIO20_R { DOE31_0_DIO20_R :: new (((self . bits >> 20) & 1) != 0) } # [doc = "Bit 21 - Enables data output for DIO21."] # [inline (always)] pub fn doe31_0_dio21 (& self) -> DOE31_0_DIO21_R { DOE31_0_DIO21_R :: new (((self . bits >> 21) & 1) != 0) } # [doc = "Bit 22 - Enables data output for DIO22."] # [inline (always)] pub fn doe31_0_dio22 (& self) -> DOE31_0_DIO22_R { DOE31_0_DIO22_R :: new (((self . bits >> 22) & 1) != 0) } # [doc = "Bit 23 - Enables data output for DIO23."] # [inline (always)] pub fn doe31_0_dio23 (& self) -> DOE31_0_DIO23_R { DOE31_0_DIO23_R :: new (((self . bits >> 23) & 1) != 0) } # [doc = "Bit 24 - Enables data output for DIO24."] # [inline (always)] pub fn doe31_0_dio24 (& self) -> DOE31_0_DIO24_R { DOE31_0_DIO24_R :: new (((self . bits >> 24) & 1) != 0) } # [doc = "Bit 25 - Enables data output for DIO25."] # [inline (always)] pub fn doe31_0_dio25 (& self) -> DOE31_0_DIO25_R { DOE31_0_DIO25_R :: new (((self . bits >> 25) & 1) != 0) } # [doc = "Bit 26 - Enables data output for DIO26."] # [inline (always)] pub fn doe31_0_dio26 (& self) -> DOE31_0_DIO26_R { DOE31_0_DIO26_R :: new (((self . bits >> 26) & 1) != 0) } # [doc = "Bit 27 - Enables data output for DIO27."] # [inline (always)] pub fn doe31_0_dio27 (& self) -> DOE31_0_DIO27_R { DOE31_0_DIO27_R :: new (((self . bits >> 27) & 1) != 0) } # [doc = "Bit 28 - Enables data output for DIO28."] # [inline (always)] pub fn doe31_0_dio28 (& self) -> DOE31_0_DIO28_R { DOE31_0_DIO28_R :: new (((self . bits >> 28) & 1) != 0) } # [doc = "Bit 29 - Enables data output for DIO29."] # [inline (always)] pub fn doe31_0_dio29 (& self) -> DOE31_0_DIO29_R { DOE31_0_DIO29_R :: new (((self . bits >> 29) & 1) != 0) } # [doc = "Bit 30 - Enables data output for DIO30."] # [inline (always)] pub fn doe31_0_dio30 (& self) -> DOE31_0_DIO30_R { DOE31_0_DIO30_R :: new (((self . bits >> 30) & 1) != 0) } # [doc = "Bit 31 - Enables data output for DIO31."] # [inline (always)] pub fn doe31_0_dio31 (& self) -> DOE31_0_DIO31_R { DOE31_0_DIO31_R :: new (((self . bits >> 31) & 1) != 0) } } impl W { # [doc = "Bit 0 - Enables data output for DIO0."] # [inline (always)] # [must_use] pub fn doe31_0_dio0 (& mut self) -> DOE31_0_DIO0_W < DOE31_0_SPEC , 0 > { DOE31_0_DIO0_W :: new (self) } # [doc = "Bit 1 - Enables data output for DIO1."] # [inline (always)] # [must_use] pub fn doe31_0_dio1 (& mut self) -> DOE31_0_DIO1_W < DOE31_0_SPEC , 1 > { DOE31_0_DIO1_W :: new (self) } # [doc = "Bit 2 - Enables data output for DIO2."] # [inline (always)] # [must_use] pub fn doe31_0_dio2 (& mut self) -> DOE31_0_DIO2_W < DOE31_0_SPEC , 2 > { DOE31_0_DIO2_W :: new (self) } # [doc = "Bit 3 - Enables data output for DIO3."] # [inline (always)] # [must_use] pub fn doe31_0_dio3 (& mut self) -> DOE31_0_DIO3_W < DOE31_0_SPEC , 3 > { DOE31_0_DIO3_W :: new (self) } # [doc = "Bit 4 - Enables data output for DIO4."] # [inline (always)] # [must_use] pub fn doe31_0_dio4 (& mut self) -> DOE31_0_DIO4_W < DOE31_0_SPEC , 4 > { DOE31_0_DIO4_W :: new (self) } # [doc = "Bit 5 - Enables data output for DIO5."] # [inline (always)] # [must_use] pub fn doe31_0_dio5 (& mut self) -> DOE31_0_DIO5_W < DOE31_0_SPEC , 5 > { DOE31_0_DIO5_W :: new (self) } # [doc = "Bit 6 - Enables data output for DIO6."] # [inline (always)] # [must_use] pub fn doe31_0_dio6 (& mut self) -> DOE31_0_DIO6_W < DOE31_0_SPEC , 6 > { DOE31_0_DIO6_W :: new (self) } # [doc = "Bit 7 - Enables data output for DIO7."] # [inline (always)] # [must_use] pub fn doe31_0_dio7 (& mut self) -> DOE31_0_DIO7_W < DOE31_0_SPEC , 7 > { DOE31_0_DIO7_W :: new (self) } # [doc = "Bit 8 - Enables data output for DIO8."] # [inline (always)] # [must_use] pub fn doe31_0_dio8 (& mut self) -> DOE31_0_DIO8_W < DOE31_0_SPEC , 8 > { DOE31_0_DIO8_W :: new (self) } # [doc = "Bit 9 - Enables data output for DIO9."] # [inline (always)] # [must_use] pub fn doe31_0_dio9 (& mut self) -> DOE31_0_DIO9_W < DOE31_0_SPEC , 9 > { DOE31_0_DIO9_W :: new (self) } # [doc = "Bit 10 - Enables data output for DIO10."] # [inline (always)] # [must_use] pub fn doe31_0_dio10 (& mut self) -> DOE31_0_DIO10_W < DOE31_0_SPEC , 10 > { DOE31_0_DIO10_W :: new (self) } # [doc = "Bit 11 - Enables data output for DIO11."] # [inline (always)] # [must_use] pub fn doe31_0_dio11 (& mut self) -> DOE31_0_DIO11_W < DOE31_0_SPEC , 11 > { DOE31_0_DIO11_W :: new (self) } # [doc = "Bit 12 - Enables data output for DIO12."] # [inline (always)] # [must_use] pub fn doe31_0_dio12 (& mut self) -> DOE31_0_DIO12_W < DOE31_0_SPEC , 12 > { DOE31_0_DIO12_W :: new (self) } # [doc = "Bit 13 - Enables data output for DIO13."] # [inline (always)] # [must_use] pub fn doe31_0_dio13 (& mut self) -> DOE31_0_DIO13_W < DOE31_0_SPEC , 13 > { DOE31_0_DIO13_W :: new (self) } # [doc = "Bit 14 - Enables data output for DIO14."] # [inline (always)] # [must_use] pub fn doe31_0_dio14 (& mut self) -> DOE31_0_DIO14_W < DOE31_0_SPEC , 14 > { DOE31_0_DIO14_W :: new (self) } # [doc = "Bit 15 - Enables data output for DIO15."] # [inline (always)] # [must_use] pub fn doe31_0_dio15 (& mut self) -> DOE31_0_DIO15_W < DOE31_0_SPEC , 15 > { DOE31_0_DIO15_W :: new (self) } # [doc = "Bit 16 - Enables data output for DIO16."] # [inline (always)] # [must_use] pub fn doe31_0_dio16 (& mut self) -> DOE31_0_DIO16_W < DOE31_0_SPEC , 16 > { DOE31_0_DIO16_W :: new (self) } # [doc = "Bit 17 - Enables data output for DIO17."] # [inline (always)] # [must_use] pub fn doe31_0_dio17 (& mut self) -> DOE31_0_DIO17_W < DOE31_0_SPEC , 17 > { DOE31_0_DIO17_W :: new (self) } # [doc = "Bit 18 - Enables data output for DIO18."] # [inline (always)] # [must_use] pub fn doe31_0_dio18 (& mut self) -> DOE31_0_DIO18_W < DOE31_0_SPEC , 18 > { DOE31_0_DIO18_W :: new (self) } # [doc = "Bit 19 - Enables data output for DIO19."] # [inline (always)] # [must_use] pub fn doe31_0_dio19 (& mut self) -> DOE31_0_DIO19_W < DOE31_0_SPEC , 19 > { DOE31_0_DIO19_W :: new (self) } # [doc = "Bit 20 - Enables data output for DIO20."] # [inline (always)] # [must_use] pub fn doe31_0_dio20 (& mut self) -> DOE31_0_DIO20_W < DOE31_0_SPEC , 20 > { DOE31_0_DIO20_W :: new (self) } # [doc = "Bit 21 - Enables data output for DIO21."] # [inline (always)] # [must_use] pub fn doe31_0_dio21 (& mut self) -> DOE31_0_DIO21_W < DOE31_0_SPEC , 21 > { DOE31_0_DIO21_W :: new (self) } # [doc = "Bit 22 - Enables data output for DIO22."] # [inline (always)] # [must_use] pub fn doe31_0_dio22 (& mut self) -> DOE31_0_DIO22_W < DOE31_0_SPEC , 22 > { DOE31_0_DIO22_W :: new (self) } # [doc = "Bit 23 - Enables data output for DIO23."] # [inline (always)] # [must_use] pub fn doe31_0_dio23 (& mut self) -> DOE31_0_DIO23_W < DOE31_0_SPEC , 23 > { DOE31_0_DIO23_W :: new (self) } # [doc = "Bit 24 - Enables data output for DIO24."] # [inline (always)] # [must_use] pub fn doe31_0_dio24 (& mut self) -> DOE31_0_DIO24_W < DOE31_0_SPEC , 24 > { DOE31_0_DIO24_W :: new (self) } # [doc = "Bit 25 - Enables data output for DIO25."] # [inline (always)] # [must_use] pub fn doe31_0_dio25 (& mut self) -> DOE31_0_DIO25_W < DOE31_0_SPEC , 25 > { DOE31_0_DIO25_W :: new (self) } # [doc = "Bit 26 - Enables data output for DIO26."] # [inline (always)] # [must_use] pub fn doe31_0_dio26 (& mut self) -> DOE31_0_DIO26_W < DOE31_0_SPEC , 26 > { DOE31_0_DIO26_W :: new (self) } # [doc = "Bit 27 - Enables data output for DIO27."] # [inline (always)] # [must_use] pub fn doe31_0_dio27 (& mut self) -> DOE31_0_DIO27_W < DOE31_0_SPEC , 27 > { DOE31_0_DIO27_W :: new (self) } # [doc = "Bit 28 - Enables data output for DIO28."] # [inline (always)] # [must_use] pub fn doe31_0_dio28 (& mut self) -> DOE31_0_DIO28_W < DOE31_0_SPEC , 28 > { DOE31_0_DIO28_W :: new (self) } # [doc = "Bit 29 - Enables data output for DIO29."] # [inline (always)] # [must_use] pub fn doe31_0_dio29 (& mut self) -> DOE31_0_DIO29_W < DOE31_0_SPEC , 29 > { DOE31_0_DIO29_W :: new (self) } # [doc = "Bit 30 - Enables data output for DIO30."] # [inline (always)] # [must_use] pub fn doe31_0_dio30 (& mut self) -> DOE31_0_DIO30_W < DOE31_0_SPEC , 30 > { DOE31_0_DIO30_W :: new (self) } # [doc = "Bit 31 - Enables data output for DIO31."] # [inline (always)] # [must_use] pub fn doe31_0_dio31 (& mut self) -> DOE31_0_DIO31_W < DOE31_0_SPEC , 31 > { DOE31_0_DIO31_W :: new (self) } # [doc = r" Writes raw bits to the register."] # [doc = r""] # [doc = r" # Safety"] # [doc = r""] # [doc = r" Passing incorrect value can cause undefined behaviour. See reference manual"] # [inline (always)] pub unsafe fn bits (& mut self , bits : u32) -> & mut Self { self . bits = bits ; self } } # [doc = "Data output enable 31 to 0\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`doe31_0::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`doe31_0::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."] pub struct DOE31_0_SPEC ; impl crate :: RegisterSpec for DOE31_0_SPEC { type Ux = u32 ; } # [doc = "`read()` method returns [`doe31_0::R`](R) reader structure"] impl crate :: Readable for DOE31_0_SPEC { } # [doc = "`write(|w| ..)` method takes [`doe31_0::W`](W) writer structure"] impl crate :: Writable for DOE31_0_SPEC { const ZERO_TO_MODIFY_FIELDS_BITMAP : Self :: Ux = 0 ; const ONE_TO_MODIFY_FIELDS_BITMAP : Self :: Ux = 0 ; } # [doc = "`reset()` method sets DOE31_0 to value 0"] impl crate :: Resettable for DOE31_0_SPEC { const RESET_VALUE : Self :: Ux = 0 ; }