#[doc = r" Value read from the register"]
pub struct R {
bits: u32,
}
impl super::STATUS1 {
#[doc = r" Reads the contents of the register"]
#[inline]
pub fn read(&self) -> R {
R {
bits: self.register.get(),
}
}
}
#[doc = r" Value of the field"]
pub struct THCMP_BRANGE0R {
bits: bool,
}
impl THCMP_BRANGE0R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_ARANGE0R {
bits: bool,
}
impl THCMP_ARANGE0R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_DCROSS0R {
bits: bool,
}
impl THCMP_DCROSS0R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_UCROSS0R {
bits: bool,
}
impl THCMP_UCROSS0R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct OVERRUN_0R {
bits: bool,
}
impl OVERRUN_0R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_BRANGE1R {
bits: bool,
}
impl THCMP_BRANGE1R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_ARANGE1R {
bits: bool,
}
impl THCMP_ARANGE1R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_DCROSS1R {
bits: bool,
}
impl THCMP_DCROSS1R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_UCROSS1R {
bits: bool,
}
impl THCMP_UCROSS1R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct OVERRUN_1R {
bits: bool,
}
impl OVERRUN_1R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_BRANGE2R {
bits: bool,
}
impl THCMP_BRANGE2R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_ARANGE2R {
bits: bool,
}
impl THCMP_ARANGE2R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_DCROSS2R {
bits: bool,
}
impl THCMP_DCROSS2R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_UCROSS2R {
bits: bool,
}
impl THCMP_UCROSS2R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct OVERRUN_2R {
bits: bool,
}
impl OVERRUN_2R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_BRANGE3R {
bits: bool,
}
impl THCMP_BRANGE3R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_ARANGE3R {
bits: bool,
}
impl THCMP_ARANGE3R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_DCROSS3R {
bits: bool,
}
impl THCMP_DCROSS3R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_UCROSS3R {
bits: bool,
}
impl THCMP_UCROSS3R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct OVERRUN_3R {
bits: bool,
}
impl OVERRUN_3R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_BRANGE4R {
bits: bool,
}
impl THCMP_BRANGE4R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_ARANGE4R {
bits: bool,
}
impl THCMP_ARANGE4R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_DCROSS4R {
bits: bool,
}
impl THCMP_DCROSS4R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_UCROSS4R {
bits: bool,
}
impl THCMP_UCROSS4R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct OVERRUN_4R {
bits: bool,
}
impl OVERRUN_4R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_BRANGE5R {
bits: bool,
}
impl THCMP_BRANGE5R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_ARANGE5R {
bits: bool,
}
impl THCMP_ARANGE5R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_DCROSS5R {
bits: bool,
}
impl THCMP_DCROSS5R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct THCMP_UCROSS5R {
bits: bool,
}
impl THCMP_UCROSS5R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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"]
pub struct OVERRUN_5R {
bits: bool,
}
impl OVERRUN_5R {
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
self.bits
}
#[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()
}
}
impl R {
#[doc = r" Value of the register as raw bits"]
#[inline]
pub fn bits(&self) -> u32 {
self.bits
}
#[doc = "Bit 0 - Input channel 0 result below range"]
#[inline]
pub fn thcmp_brange0(&self) -> THCMP_BRANGE0R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 0;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_BRANGE0R { bits }
}
#[doc = "Bit 1 - Input channel 0 result above range"]
#[inline]
pub fn thcmp_arange0(&self) -> THCMP_ARANGE0R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 1;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_ARANGE0R { bits }
}
#[doc = "Bit 2 - Input channel 0 result downward threshold crossing detected"]
#[inline]
pub fn thcmp_dcross0(&self) -> THCMP_DCROSS0R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 2;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_DCROSS0R { bits }
}
#[doc = "Bit 3 - Input channel 0 result upward threshold crossing detected"]
#[inline]
pub fn thcmp_ucross0(&self) -> THCMP_UCROSS0R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 3;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_UCROSS0R { bits }
}
#[doc = "Bit 4 - A new conversion on channel m completed and has overwritten the previous contents of register LAST_SAMPLE [0] before it has been read"]
#[inline]
pub fn overrun_0(&self) -> OVERRUN_0R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 4;
((self.bits >> OFFSET) & MASK as u32) != 0
};
OVERRUN_0R { bits }
}
#[doc = "Bit 5 - Input channel 1 result below range"]
#[inline]
pub fn thcmp_brange1(&self) -> THCMP_BRANGE1R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 5;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_BRANGE1R { bits }
}
#[doc = "Bit 6 - Input channel 1 result above range"]
#[inline]
pub fn thcmp_arange1(&self) -> THCMP_ARANGE1R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 6;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_ARANGE1R { bits }
}
#[doc = "Bit 7 - Input channel 1 result downward threshold crossing detected"]
#[inline]
pub fn thcmp_dcross1(&self) -> THCMP_DCROSS1R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 7;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_DCROSS1R { bits }
}
#[doc = "Bit 8 - Input channel 1 result upward threshold crossing detected"]
#[inline]
pub fn thcmp_ucross1(&self) -> THCMP_UCROSS1R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 8;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_UCROSS1R { bits }
}
#[doc = "Bit 9 - A new conversion on channel m completed and has overwritten the previous contents of register LAST_SAMPLE [1] before it has been read"]
#[inline]
pub fn overrun_1(&self) -> OVERRUN_1R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 9;
((self.bits >> OFFSET) & MASK as u32) != 0
};
OVERRUN_1R { bits }
}
#[doc = "Bit 10 - Input channel 2 result below range"]
#[inline]
pub fn thcmp_brange2(&self) -> THCMP_BRANGE2R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 10;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_BRANGE2R { bits }
}
#[doc = "Bit 11 - Input channel 2 result above range"]
#[inline]
pub fn thcmp_arange2(&self) -> THCMP_ARANGE2R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 11;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_ARANGE2R { bits }
}
#[doc = "Bit 12 - Input channel 2 result downward threshold crossing detected"]
#[inline]
pub fn thcmp_dcross2(&self) -> THCMP_DCROSS2R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 12;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_DCROSS2R { bits }
}
#[doc = "Bit 13 - Input channel 2 result upward threshold crossing detected"]
#[inline]
pub fn thcmp_ucross2(&self) -> THCMP_UCROSS2R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 13;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_UCROSS2R { bits }
}
#[doc = "Bit 14 - A new conversion on channel m completed and has overwritten the previous contents of register LAST_SAMPLE [2] before it has been read"]
#[inline]
pub fn overrun_2(&self) -> OVERRUN_2R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 14;
((self.bits >> OFFSET) & MASK as u32) != 0
};
OVERRUN_2R { bits }
}
#[doc = "Bit 15 - Input channel 3 result below range"]
#[inline]
pub fn thcmp_brange3(&self) -> THCMP_BRANGE3R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 15;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_BRANGE3R { bits }
}
#[doc = "Bit 16 - Input channel 3 result above range"]
#[inline]
pub fn thcmp_arange3(&self) -> THCMP_ARANGE3R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 16;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_ARANGE3R { bits }
}
#[doc = "Bit 17 - Input channel 3 result downward threshold crossing detected"]
#[inline]
pub fn thcmp_dcross3(&self) -> THCMP_DCROSS3R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 17;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_DCROSS3R { bits }
}
#[doc = "Bit 18 - Input channel 3 result upward threshold crossing detected"]
#[inline]
pub fn thcmp_ucross3(&self) -> THCMP_UCROSS3R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 18;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_UCROSS3R { bits }
}
#[doc = "Bit 19 - A new conversion on channel m completed and has overwritten the previous contents of register LAST_SAMPLE [3] before it has been read"]
#[inline]
pub fn overrun_3(&self) -> OVERRUN_3R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 19;
((self.bits >> OFFSET) & MASK as u32) != 0
};
OVERRUN_3R { bits }
}
#[doc = "Bit 20 - Input channel 4 result below range"]
#[inline]
pub fn thcmp_brange4(&self) -> THCMP_BRANGE4R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 20;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_BRANGE4R { bits }
}
#[doc = "Bit 21 - Input channel 4 result above range"]
#[inline]
pub fn thcmp_arange4(&self) -> THCMP_ARANGE4R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 21;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_ARANGE4R { bits }
}
#[doc = "Bit 22 - Input channel 4 result downward threshold crossing detected"]
#[inline]
pub fn thcmp_dcross4(&self) -> THCMP_DCROSS4R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 22;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_DCROSS4R { bits }
}
#[doc = "Bit 23 - Input channel 4 result upward threshold crossing detected"]
#[inline]
pub fn thcmp_ucross4(&self) -> THCMP_UCROSS4R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 23;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_UCROSS4R { bits }
}
#[doc = "Bit 24 - A new conversion on channel m completed and has overwritten the previous contents of register LAST_SAMPLE [4] before it has been read"]
#[inline]
pub fn overrun_4(&self) -> OVERRUN_4R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 24;
((self.bits >> OFFSET) & MASK as u32) != 0
};
OVERRUN_4R { bits }
}
#[doc = "Bit 25 - Input channel 5 result below range"]
#[inline]
pub fn thcmp_brange5(&self) -> THCMP_BRANGE5R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 25;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_BRANGE5R { bits }
}
#[doc = "Bit 26 - Input channel 5 result above range"]
#[inline]
pub fn thcmp_arange5(&self) -> THCMP_ARANGE5R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 26;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_ARANGE5R { bits }
}
#[doc = "Bit 27 - Input channel 5 result downward threshold crossing detected"]
#[inline]
pub fn thcmp_dcross5(&self) -> THCMP_DCROSS5R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 27;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_DCROSS5R { bits }
}
#[doc = "Bit 28 - Input channel 5 result upward threshold crossing detected"]
#[inline]
pub fn thcmp_ucross5(&self) -> THCMP_UCROSS5R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 28;
((self.bits >> OFFSET) & MASK as u32) != 0
};
THCMP_UCROSS5R { bits }
}
#[doc = "Bit 29 - A new conversion on channel m completed and has overwritten the previous contents of register LAST_SAMPLE [5] before it has been read"]
#[inline]
pub fn overrun_5(&self) -> OVERRUN_5R {
let bits = {
const MASK: bool = true;
const OFFSET: u8 = 29;
((self.bits >> OFFSET) & MASK as u32) != 0
};
OVERRUN_5R { bits }
}
}