1813 lines
50 KiB
Rust
1813 lines
50 KiB
Rust
#[doc = r" Value read from the register"]
|
|
pub struct R {
|
|
bits: u32,
|
|
}
|
|
impl super::ADC14IFGR0 {
|
|
#[doc = r" Reads the contents of the register"]
|
|
#[inline]
|
|
pub fn read(&self) -> R {
|
|
R {
|
|
bits: self.register.get(),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG0`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG0R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG0_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG0_1,
|
|
}
|
|
impl ADC14IFG0R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG0R::ADC14IFG0_0 => false,
|
|
ADC14IFG0R::ADC14IFG0_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG0R {
|
|
match value {
|
|
false => ADC14IFG0R::ADC14IFG0_0,
|
|
true => ADC14IFG0R::ADC14IFG0_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG0_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg0_0(&self) -> bool {
|
|
*self == ADC14IFG0R::ADC14IFG0_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG0_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg0_1(&self) -> bool {
|
|
*self == ADC14IFG0R::ADC14IFG0_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG1`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG1R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG1_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG1_1,
|
|
}
|
|
impl ADC14IFG1R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG1R::ADC14IFG1_0 => false,
|
|
ADC14IFG1R::ADC14IFG1_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG1R {
|
|
match value {
|
|
false => ADC14IFG1R::ADC14IFG1_0,
|
|
true => ADC14IFG1R::ADC14IFG1_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG1_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg1_0(&self) -> bool {
|
|
*self == ADC14IFG1R::ADC14IFG1_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG1_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg1_1(&self) -> bool {
|
|
*self == ADC14IFG1R::ADC14IFG1_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG2`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG2R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG2_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG2_1,
|
|
}
|
|
impl ADC14IFG2R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG2R::ADC14IFG2_0 => false,
|
|
ADC14IFG2R::ADC14IFG2_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG2R {
|
|
match value {
|
|
false => ADC14IFG2R::ADC14IFG2_0,
|
|
true => ADC14IFG2R::ADC14IFG2_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG2_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg2_0(&self) -> bool {
|
|
*self == ADC14IFG2R::ADC14IFG2_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG2_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg2_1(&self) -> bool {
|
|
*self == ADC14IFG2R::ADC14IFG2_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG3`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG3R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG3_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG3_1,
|
|
}
|
|
impl ADC14IFG3R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG3R::ADC14IFG3_0 => false,
|
|
ADC14IFG3R::ADC14IFG3_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG3R {
|
|
match value {
|
|
false => ADC14IFG3R::ADC14IFG3_0,
|
|
true => ADC14IFG3R::ADC14IFG3_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG3_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg3_0(&self) -> bool {
|
|
*self == ADC14IFG3R::ADC14IFG3_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG3_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg3_1(&self) -> bool {
|
|
*self == ADC14IFG3R::ADC14IFG3_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG4`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG4R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG4_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG4_1,
|
|
}
|
|
impl ADC14IFG4R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG4R::ADC14IFG4_0 => false,
|
|
ADC14IFG4R::ADC14IFG4_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG4R {
|
|
match value {
|
|
false => ADC14IFG4R::ADC14IFG4_0,
|
|
true => ADC14IFG4R::ADC14IFG4_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG4_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg4_0(&self) -> bool {
|
|
*self == ADC14IFG4R::ADC14IFG4_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG4_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg4_1(&self) -> bool {
|
|
*self == ADC14IFG4R::ADC14IFG4_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG5`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG5R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG5_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG5_1,
|
|
}
|
|
impl ADC14IFG5R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG5R::ADC14IFG5_0 => false,
|
|
ADC14IFG5R::ADC14IFG5_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG5R {
|
|
match value {
|
|
false => ADC14IFG5R::ADC14IFG5_0,
|
|
true => ADC14IFG5R::ADC14IFG5_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG5_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg5_0(&self) -> bool {
|
|
*self == ADC14IFG5R::ADC14IFG5_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG5_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg5_1(&self) -> bool {
|
|
*self == ADC14IFG5R::ADC14IFG5_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG6`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG6R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG6_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG6_1,
|
|
}
|
|
impl ADC14IFG6R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG6R::ADC14IFG6_0 => false,
|
|
ADC14IFG6R::ADC14IFG6_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG6R {
|
|
match value {
|
|
false => ADC14IFG6R::ADC14IFG6_0,
|
|
true => ADC14IFG6R::ADC14IFG6_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG6_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg6_0(&self) -> bool {
|
|
*self == ADC14IFG6R::ADC14IFG6_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG6_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg6_1(&self) -> bool {
|
|
*self == ADC14IFG6R::ADC14IFG6_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG7`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG7R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG7_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG7_1,
|
|
}
|
|
impl ADC14IFG7R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG7R::ADC14IFG7_0 => false,
|
|
ADC14IFG7R::ADC14IFG7_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG7R {
|
|
match value {
|
|
false => ADC14IFG7R::ADC14IFG7_0,
|
|
true => ADC14IFG7R::ADC14IFG7_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG7_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg7_0(&self) -> bool {
|
|
*self == ADC14IFG7R::ADC14IFG7_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG7_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg7_1(&self) -> bool {
|
|
*self == ADC14IFG7R::ADC14IFG7_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG8`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG8R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG8_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG8_1,
|
|
}
|
|
impl ADC14IFG8R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG8R::ADC14IFG8_0 => false,
|
|
ADC14IFG8R::ADC14IFG8_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG8R {
|
|
match value {
|
|
false => ADC14IFG8R::ADC14IFG8_0,
|
|
true => ADC14IFG8R::ADC14IFG8_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG8_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg8_0(&self) -> bool {
|
|
*self == ADC14IFG8R::ADC14IFG8_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG8_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg8_1(&self) -> bool {
|
|
*self == ADC14IFG8R::ADC14IFG8_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG9`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG9R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG9_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG9_1,
|
|
}
|
|
impl ADC14IFG9R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG9R::ADC14IFG9_0 => false,
|
|
ADC14IFG9R::ADC14IFG9_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG9R {
|
|
match value {
|
|
false => ADC14IFG9R::ADC14IFG9_0,
|
|
true => ADC14IFG9R::ADC14IFG9_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG9_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg9_0(&self) -> bool {
|
|
*self == ADC14IFG9R::ADC14IFG9_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG9_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg9_1(&self) -> bool {
|
|
*self == ADC14IFG9R::ADC14IFG9_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG10`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG10R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG10_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG10_1,
|
|
}
|
|
impl ADC14IFG10R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG10R::ADC14IFG10_0 => false,
|
|
ADC14IFG10R::ADC14IFG10_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG10R {
|
|
match value {
|
|
false => ADC14IFG10R::ADC14IFG10_0,
|
|
true => ADC14IFG10R::ADC14IFG10_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG10_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg10_0(&self) -> bool {
|
|
*self == ADC14IFG10R::ADC14IFG10_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG10_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg10_1(&self) -> bool {
|
|
*self == ADC14IFG10R::ADC14IFG10_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG11`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG11R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG11_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG11_1,
|
|
}
|
|
impl ADC14IFG11R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG11R::ADC14IFG11_0 => false,
|
|
ADC14IFG11R::ADC14IFG11_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG11R {
|
|
match value {
|
|
false => ADC14IFG11R::ADC14IFG11_0,
|
|
true => ADC14IFG11R::ADC14IFG11_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG11_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg11_0(&self) -> bool {
|
|
*self == ADC14IFG11R::ADC14IFG11_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG11_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg11_1(&self) -> bool {
|
|
*self == ADC14IFG11R::ADC14IFG11_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG12`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG12R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG12_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG12_1,
|
|
}
|
|
impl ADC14IFG12R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG12R::ADC14IFG12_0 => false,
|
|
ADC14IFG12R::ADC14IFG12_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG12R {
|
|
match value {
|
|
false => ADC14IFG12R::ADC14IFG12_0,
|
|
true => ADC14IFG12R::ADC14IFG12_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG12_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg12_0(&self) -> bool {
|
|
*self == ADC14IFG12R::ADC14IFG12_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG12_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg12_1(&self) -> bool {
|
|
*self == ADC14IFG12R::ADC14IFG12_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG13`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG13R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG13_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG13_1,
|
|
}
|
|
impl ADC14IFG13R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG13R::ADC14IFG13_0 => false,
|
|
ADC14IFG13R::ADC14IFG13_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG13R {
|
|
match value {
|
|
false => ADC14IFG13R::ADC14IFG13_0,
|
|
true => ADC14IFG13R::ADC14IFG13_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG13_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg13_0(&self) -> bool {
|
|
*self == ADC14IFG13R::ADC14IFG13_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG13_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg13_1(&self) -> bool {
|
|
*self == ADC14IFG13R::ADC14IFG13_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG14`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG14R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG14_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG14_1,
|
|
}
|
|
impl ADC14IFG14R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG14R::ADC14IFG14_0 => false,
|
|
ADC14IFG14R::ADC14IFG14_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG14R {
|
|
match value {
|
|
false => ADC14IFG14R::ADC14IFG14_0,
|
|
true => ADC14IFG14R::ADC14IFG14_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG14_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg14_0(&self) -> bool {
|
|
*self == ADC14IFG14R::ADC14IFG14_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG14_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg14_1(&self) -> bool {
|
|
*self == ADC14IFG14R::ADC14IFG14_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG15`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG15R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG15_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG15_1,
|
|
}
|
|
impl ADC14IFG15R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG15R::ADC14IFG15_0 => false,
|
|
ADC14IFG15R::ADC14IFG15_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG15R {
|
|
match value {
|
|
false => ADC14IFG15R::ADC14IFG15_0,
|
|
true => ADC14IFG15R::ADC14IFG15_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG15_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg15_0(&self) -> bool {
|
|
*self == ADC14IFG15R::ADC14IFG15_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG15_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg15_1(&self) -> bool {
|
|
*self == ADC14IFG15R::ADC14IFG15_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG16`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG16R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG16_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG16_1,
|
|
}
|
|
impl ADC14IFG16R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG16R::ADC14IFG16_0 => false,
|
|
ADC14IFG16R::ADC14IFG16_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG16R {
|
|
match value {
|
|
false => ADC14IFG16R::ADC14IFG16_0,
|
|
true => ADC14IFG16R::ADC14IFG16_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG16_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg16_0(&self) -> bool {
|
|
*self == ADC14IFG16R::ADC14IFG16_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG16_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg16_1(&self) -> bool {
|
|
*self == ADC14IFG16R::ADC14IFG16_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG17`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG17R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG17_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG17_1,
|
|
}
|
|
impl ADC14IFG17R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG17R::ADC14IFG17_0 => false,
|
|
ADC14IFG17R::ADC14IFG17_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG17R {
|
|
match value {
|
|
false => ADC14IFG17R::ADC14IFG17_0,
|
|
true => ADC14IFG17R::ADC14IFG17_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG17_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg17_0(&self) -> bool {
|
|
*self == ADC14IFG17R::ADC14IFG17_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG17_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg17_1(&self) -> bool {
|
|
*self == ADC14IFG17R::ADC14IFG17_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG18`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG18R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG18_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG18_1,
|
|
}
|
|
impl ADC14IFG18R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG18R::ADC14IFG18_0 => false,
|
|
ADC14IFG18R::ADC14IFG18_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG18R {
|
|
match value {
|
|
false => ADC14IFG18R::ADC14IFG18_0,
|
|
true => ADC14IFG18R::ADC14IFG18_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG18_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg18_0(&self) -> bool {
|
|
*self == ADC14IFG18R::ADC14IFG18_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG18_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg18_1(&self) -> bool {
|
|
*self == ADC14IFG18R::ADC14IFG18_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG19`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG19R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG19_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG19_1,
|
|
}
|
|
impl ADC14IFG19R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG19R::ADC14IFG19_0 => false,
|
|
ADC14IFG19R::ADC14IFG19_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG19R {
|
|
match value {
|
|
false => ADC14IFG19R::ADC14IFG19_0,
|
|
true => ADC14IFG19R::ADC14IFG19_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG19_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg19_0(&self) -> bool {
|
|
*self == ADC14IFG19R::ADC14IFG19_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG19_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg19_1(&self) -> bool {
|
|
*self == ADC14IFG19R::ADC14IFG19_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG20`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG20R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG20_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG20_1,
|
|
}
|
|
impl ADC14IFG20R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG20R::ADC14IFG20_0 => false,
|
|
ADC14IFG20R::ADC14IFG20_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG20R {
|
|
match value {
|
|
false => ADC14IFG20R::ADC14IFG20_0,
|
|
true => ADC14IFG20R::ADC14IFG20_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG20_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg20_0(&self) -> bool {
|
|
*self == ADC14IFG20R::ADC14IFG20_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG20_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg20_1(&self) -> bool {
|
|
*self == ADC14IFG20R::ADC14IFG20_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG21`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG21R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG21_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG21_1,
|
|
}
|
|
impl ADC14IFG21R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG21R::ADC14IFG21_0 => false,
|
|
ADC14IFG21R::ADC14IFG21_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG21R {
|
|
match value {
|
|
false => ADC14IFG21R::ADC14IFG21_0,
|
|
true => ADC14IFG21R::ADC14IFG21_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG21_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg21_0(&self) -> bool {
|
|
*self == ADC14IFG21R::ADC14IFG21_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG21_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg21_1(&self) -> bool {
|
|
*self == ADC14IFG21R::ADC14IFG21_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG22`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG22R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG22_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG22_1,
|
|
}
|
|
impl ADC14IFG22R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG22R::ADC14IFG22_0 => false,
|
|
ADC14IFG22R::ADC14IFG22_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG22R {
|
|
match value {
|
|
false => ADC14IFG22R::ADC14IFG22_0,
|
|
true => ADC14IFG22R::ADC14IFG22_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG22_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg22_0(&self) -> bool {
|
|
*self == ADC14IFG22R::ADC14IFG22_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG22_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg22_1(&self) -> bool {
|
|
*self == ADC14IFG22R::ADC14IFG22_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG23`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG23R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG23_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG23_1,
|
|
}
|
|
impl ADC14IFG23R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG23R::ADC14IFG23_0 => false,
|
|
ADC14IFG23R::ADC14IFG23_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG23R {
|
|
match value {
|
|
false => ADC14IFG23R::ADC14IFG23_0,
|
|
true => ADC14IFG23R::ADC14IFG23_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG23_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg23_0(&self) -> bool {
|
|
*self == ADC14IFG23R::ADC14IFG23_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG23_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg23_1(&self) -> bool {
|
|
*self == ADC14IFG23R::ADC14IFG23_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG24`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG24R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG24_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG24_1,
|
|
}
|
|
impl ADC14IFG24R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG24R::ADC14IFG24_0 => false,
|
|
ADC14IFG24R::ADC14IFG24_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG24R {
|
|
match value {
|
|
false => ADC14IFG24R::ADC14IFG24_0,
|
|
true => ADC14IFG24R::ADC14IFG24_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG24_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg24_0(&self) -> bool {
|
|
*self == ADC14IFG24R::ADC14IFG24_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG24_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg24_1(&self) -> bool {
|
|
*self == ADC14IFG24R::ADC14IFG24_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG25`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG25R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG25_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG25_1,
|
|
}
|
|
impl ADC14IFG25R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG25R::ADC14IFG25_0 => false,
|
|
ADC14IFG25R::ADC14IFG25_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG25R {
|
|
match value {
|
|
false => ADC14IFG25R::ADC14IFG25_0,
|
|
true => ADC14IFG25R::ADC14IFG25_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG25_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg25_0(&self) -> bool {
|
|
*self == ADC14IFG25R::ADC14IFG25_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG25_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg25_1(&self) -> bool {
|
|
*self == ADC14IFG25R::ADC14IFG25_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG26`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG26R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG26_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG26_1,
|
|
}
|
|
impl ADC14IFG26R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG26R::ADC14IFG26_0 => false,
|
|
ADC14IFG26R::ADC14IFG26_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG26R {
|
|
match value {
|
|
false => ADC14IFG26R::ADC14IFG26_0,
|
|
true => ADC14IFG26R::ADC14IFG26_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG26_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg26_0(&self) -> bool {
|
|
*self == ADC14IFG26R::ADC14IFG26_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG26_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg26_1(&self) -> bool {
|
|
*self == ADC14IFG26R::ADC14IFG26_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG27`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG27R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG27_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG27_1,
|
|
}
|
|
impl ADC14IFG27R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG27R::ADC14IFG27_0 => false,
|
|
ADC14IFG27R::ADC14IFG27_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG27R {
|
|
match value {
|
|
false => ADC14IFG27R::ADC14IFG27_0,
|
|
true => ADC14IFG27R::ADC14IFG27_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG27_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg27_0(&self) -> bool {
|
|
*self == ADC14IFG27R::ADC14IFG27_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG27_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg27_1(&self) -> bool {
|
|
*self == ADC14IFG27R::ADC14IFG27_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG28`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG28R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG28_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG28_1,
|
|
}
|
|
impl ADC14IFG28R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG28R::ADC14IFG28_0 => false,
|
|
ADC14IFG28R::ADC14IFG28_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG28R {
|
|
match value {
|
|
false => ADC14IFG28R::ADC14IFG28_0,
|
|
true => ADC14IFG28R::ADC14IFG28_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG28_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg28_0(&self) -> bool {
|
|
*self == ADC14IFG28R::ADC14IFG28_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG28_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg28_1(&self) -> bool {
|
|
*self == ADC14IFG28R::ADC14IFG28_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG29`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG29R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG29_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG29_1,
|
|
}
|
|
impl ADC14IFG29R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG29R::ADC14IFG29_0 => false,
|
|
ADC14IFG29R::ADC14IFG29_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG29R {
|
|
match value {
|
|
false => ADC14IFG29R::ADC14IFG29_0,
|
|
true => ADC14IFG29R::ADC14IFG29_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG29_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg29_0(&self) -> bool {
|
|
*self == ADC14IFG29R::ADC14IFG29_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG29_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg29_1(&self) -> bool {
|
|
*self == ADC14IFG29R::ADC14IFG29_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG30`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG30R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG30_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG30_1,
|
|
}
|
|
impl ADC14IFG30R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG30R::ADC14IFG30_0 => false,
|
|
ADC14IFG30R::ADC14IFG30_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG30R {
|
|
match value {
|
|
false => ADC14IFG30R::ADC14IFG30_0,
|
|
true => ADC14IFG30R::ADC14IFG30_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG30_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg30_0(&self) -> bool {
|
|
*self == ADC14IFG30R::ADC14IFG30_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG30_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg30_1(&self) -> bool {
|
|
*self == ADC14IFG30R::ADC14IFG30_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IFG31`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IFG31R {
|
|
#[doc = "No interrupt pending"]
|
|
ADC14IFG31_0,
|
|
#[doc = "Interrupt pending"]
|
|
ADC14IFG31_1,
|
|
}
|
|
impl ADC14IFG31R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" 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 {
|
|
ADC14IFG31R::ADC14IFG31_0 => false,
|
|
ADC14IFG31R::ADC14IFG31_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IFG31R {
|
|
match value {
|
|
false => ADC14IFG31R::ADC14IFG31_0,
|
|
true => ADC14IFG31R::ADC14IFG31_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG31_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg31_0(&self) -> bool {
|
|
*self == ADC14IFG31R::ADC14IFG31_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IFG31_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ifg31_1(&self) -> bool {
|
|
*self == ADC14IFG31R::ADC14IFG31_1
|
|
}
|
|
}
|
|
impl R {
|
|
#[doc = r" Value of the register as raw bits"]
|
|
#[inline]
|
|
pub fn bits(&self) -> u32 {
|
|
self.bits
|
|
}
|
|
#[doc = "Bit 0 - ADC14MEM0 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg0(&self) -> ADC14IFG0R {
|
|
ADC14IFG0R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 0;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 1 - ADC14MEM1 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg1(&self) -> ADC14IFG1R {
|
|
ADC14IFG1R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 1;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 2 - ADC14MEM2 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg2(&self) -> ADC14IFG2R {
|
|
ADC14IFG2R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 2;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 3 - ADC14MEM3 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg3(&self) -> ADC14IFG3R {
|
|
ADC14IFG3R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 3;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 4 - ADC14MEM4 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg4(&self) -> ADC14IFG4R {
|
|
ADC14IFG4R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 4;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 5 - ADC14MEM5 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg5(&self) -> ADC14IFG5R {
|
|
ADC14IFG5R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 5;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 6 - ADC14MEM6 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg6(&self) -> ADC14IFG6R {
|
|
ADC14IFG6R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 6;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 7 - ADC14MEM7 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg7(&self) -> ADC14IFG7R {
|
|
ADC14IFG7R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 7;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 8 - ADC14MEM8 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg8(&self) -> ADC14IFG8R {
|
|
ADC14IFG8R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 8;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 9 - ADC14MEM9 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg9(&self) -> ADC14IFG9R {
|
|
ADC14IFG9R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 9;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 10 - ADC14MEM10 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg10(&self) -> ADC14IFG10R {
|
|
ADC14IFG10R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 10;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 11 - ADC14MEM11 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg11(&self) -> ADC14IFG11R {
|
|
ADC14IFG11R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 11;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 12 - ADC14MEM12 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg12(&self) -> ADC14IFG12R {
|
|
ADC14IFG12R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 12;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 13 - ADC14MEM13 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg13(&self) -> ADC14IFG13R {
|
|
ADC14IFG13R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 13;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 14 - ADC14MEM14 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg14(&self) -> ADC14IFG14R {
|
|
ADC14IFG14R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 14;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 15 - ADC14MEM15 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg15(&self) -> ADC14IFG15R {
|
|
ADC14IFG15R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 15;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 16 - ADC14MEM16 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg16(&self) -> ADC14IFG16R {
|
|
ADC14IFG16R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 16;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 17 - ADC14MEM17 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg17(&self) -> ADC14IFG17R {
|
|
ADC14IFG17R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 17;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 18 - ADC14MEM18 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg18(&self) -> ADC14IFG18R {
|
|
ADC14IFG18R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 18;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 19 - ADC14MEM19 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg19(&self) -> ADC14IFG19R {
|
|
ADC14IFG19R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 19;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 20 - ADC14MEM20 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg20(&self) -> ADC14IFG20R {
|
|
ADC14IFG20R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 20;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 21 - ADC14MEM21 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg21(&self) -> ADC14IFG21R {
|
|
ADC14IFG21R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 21;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 22 - ADC14MEM22 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg22(&self) -> ADC14IFG22R {
|
|
ADC14IFG22R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 22;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 23 - ADC14MEM23 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg23(&self) -> ADC14IFG23R {
|
|
ADC14IFG23R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 23;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 24 - ADC14MEM24 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg24(&self) -> ADC14IFG24R {
|
|
ADC14IFG24R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 24;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 25 - ADC14MEM25 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg25(&self) -> ADC14IFG25R {
|
|
ADC14IFG25R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 25;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 26 - ADC14MEM26 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg26(&self) -> ADC14IFG26R {
|
|
ADC14IFG26R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 26;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 27 - ADC14MEM27 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg27(&self) -> ADC14IFG27R {
|
|
ADC14IFG27R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 27;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 28 - ADC14MEM28 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg28(&self) -> ADC14IFG28R {
|
|
ADC14IFG28R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 28;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 29 - ADC14MEM29 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg29(&self) -> ADC14IFG29R {
|
|
ADC14IFG29R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 29;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 30 - ADC14MEM30 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg30(&self) -> ADC14IFG30R {
|
|
ADC14IFG30R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 30;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 31 - ADC14MEM31 interrupt flag"]
|
|
#[inline]
|
|
pub fn adc14ifg31(&self) -> ADC14IFG31R {
|
|
ADC14IFG31R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 31;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
}
|