#[doc = "Reader of register STAT"]
pub type R = crate::R<u32, super::STAT>;
#[doc = "Writer for register STAT"]
pub type W = crate::W<u32, super::STAT>;
#[doc = "Register STAT `reset()`'s with value 0"]
impl crate::ResetValue for super::STAT {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Possible values of the field `RDY0`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RDY0_A {
#[doc = "Result FIFO 0 data level not above watermark level."]
RDY0_0,
#[doc = "Result FIFO 0 holding data above watermark level."]
RDY0_1,
}
impl From<RDY0_A> for bool {
#[inline(always)]
fn from(variant: RDY0_A) -> Self {
match variant {
RDY0_A::RDY0_0 => false,
RDY0_A::RDY0_1 => true,
}
}
}
#[doc = "Reader of field `RDY0`"]
pub type RDY0_R = crate::R<bool, RDY0_A>;
impl RDY0_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> RDY0_A {
match self.bits {
false => RDY0_A::RDY0_0,
true => RDY0_A::RDY0_1,
}
}
#[doc = "Checks if the value of the field is `RDY0_0`"]
#[inline(always)]
pub fn is_rdy0_0(&self) -> bool {
*self == RDY0_A::RDY0_0
}
#[doc = "Checks if the value of the field is `RDY0_1`"]
#[inline(always)]
pub fn is_rdy0_1(&self) -> bool {
*self == RDY0_A::RDY0_1
}
}
#[doc = "Possible values of the field `FOF0`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FOF0_A {
#[doc = "No result FIFO 0 overflow has occurred since the last time the flag was cleared."]
FOF0_0,
#[doc = "At least one result FIFO 0 overflow has occurred since the last time the flag was cleared."]
FOF0_1,
}
impl From<FOF0_A> for bool {
#[inline(always)]
fn from(variant: FOF0_A) -> Self {
match variant {
FOF0_A::FOF0_0 => false,
FOF0_A::FOF0_1 => true,
}
}
}
#[doc = "Reader of field `FOF0`"]
pub type FOF0_R = crate::R<bool, FOF0_A>;
impl FOF0_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> FOF0_A {
match self.bits {
false => FOF0_A::FOF0_0,
true => FOF0_A::FOF0_1,
}
}
#[doc = "Checks if the value of the field is `FOF0_0`"]
#[inline(always)]
pub fn is_fof0_0(&self) -> bool {
*self == FOF0_A::FOF0_0
}
#[doc = "Checks if the value of the field is `FOF0_1`"]
#[inline(always)]
pub fn is_fof0_1(&self) -> bool {
*self == FOF0_A::FOF0_1
}
}
#[doc = "Write proxy for field `FOF0`"]
pub struct FOF0_W<'a> {
w: &'a mut W,
}
impl<'a> FOF0_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: FOF0_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "No result FIFO 0 overflow has occurred since the last time the flag was cleared."]
#[inline(always)]
pub fn fof0_0(self) -> &'a mut W {
self.variant(FOF0_A::FOF0_0)
}
#[doc = "At least one result FIFO 0 overflow has occurred since the last time the flag was cleared."]
#[inline(always)]
pub fn fof0_1(self) -> &'a mut W {
self.variant(FOF0_A::FOF0_1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
self.w
}
}
#[doc = "Possible values of the field `RDY1`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RDY1_A {
#[doc = "Result FIFO1 data level not above watermark level."]
RDY1_0,
#[doc = "Result FIFO1 holding data above watermark level."]
RDY1_1,
}
impl From<RDY1_A> for bool {
#[inline(always)]
fn from(variant: RDY1_A) -> Self {
match variant {
RDY1_A::RDY1_0 => false,
RDY1_A::RDY1_1 => true,
}
}
}
#[doc = "Reader of field `RDY1`"]
pub type RDY1_R = crate::R<bool, RDY1_A>;
impl RDY1_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> RDY1_A {
match self.bits {
false => RDY1_A::RDY1_0,
true => RDY1_A::RDY1_1,
}
}
#[doc = "Checks if the value of the field is `RDY1_0`"]
#[inline(always)]
pub fn is_rdy1_0(&self) -> bool {
*self == RDY1_A::RDY1_0
}
#[doc = "Checks if the value of the field is `RDY1_1`"]
#[inline(always)]
pub fn is_rdy1_1(&self) -> bool {
*self == RDY1_A::RDY1_1
}
}
#[doc = "Possible values of the field `FOF1`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FOF1_A {
#[doc = "No result FIFO1 overflow has occurred since the last time the flag was cleared."]
FOF1_0,
#[doc = "At least one result FIFO1 overflow has occurred since the last time the flag was cleared."]
FOF1_1,
}
impl From<FOF1_A> for bool {
#[inline(always)]
fn from(variant: FOF1_A) -> Self {
match variant {
FOF1_A::FOF1_0 => false,
FOF1_A::FOF1_1 => true,
}
}
}
#[doc = "Reader of field `FOF1`"]
pub type FOF1_R = crate::R<bool, FOF1_A>;
impl FOF1_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> FOF1_A {
match self.bits {
false => FOF1_A::FOF1_0,
true => FOF1_A::FOF1_1,
}
}
#[doc = "Checks if the value of the field is `FOF1_0`"]
#[inline(always)]
pub fn is_fof1_0(&self) -> bool {
*self == FOF1_A::FOF1_0
}
#[doc = "Checks if the value of the field is `FOF1_1`"]
#[inline(always)]
pub fn is_fof1_1(&self) -> bool {
*self == FOF1_A::FOF1_1
}
}
#[doc = "Write proxy for field `FOF1`"]
pub struct FOF1_W<'a> {
w: &'a mut W,
}
impl<'a> FOF1_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: FOF1_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "No result FIFO1 overflow has occurred since the last time the flag was cleared."]
#[inline(always)]
pub fn fof1_0(self) -> &'a mut W {
self.variant(FOF1_A::FOF1_0)
}
#[doc = "At least one result FIFO1 overflow has occurred since the last time the flag was cleared."]
#[inline(always)]
pub fn fof1_1(self) -> &'a mut W {
self.variant(FOF1_A::FOF1_1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
self.w
}
}
#[doc = "Possible values of the field `TEXC_INT`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TEXC_INT_A {
#[doc = "No trigger exceptions have occurred."]
TEXC_INT_0,
#[doc = "A trigger exception has occurred and is pending acknowledgement."]
TEXC_INT_1,
}
impl From<TEXC_INT_A> for bool {
#[inline(always)]
fn from(variant: TEXC_INT_A) -> Self {
match variant {
TEXC_INT_A::TEXC_INT_0 => false,
TEXC_INT_A::TEXC_INT_1 => true,
}
}
}
#[doc = "Reader of field `TEXC_INT`"]
pub type TEXC_INT_R = crate::R<bool, TEXC_INT_A>;
impl TEXC_INT_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> TEXC_INT_A {
match self.bits {
false => TEXC_INT_A::TEXC_INT_0,
true => TEXC_INT_A::TEXC_INT_1,
}
}
#[doc = "Checks if the value of the field is `TEXC_INT_0`"]
#[inline(always)]
pub fn is_texc_int_0(&self) -> bool {
*self == TEXC_INT_A::TEXC_INT_0
}
#[doc = "Checks if the value of the field is `TEXC_INT_1`"]
#[inline(always)]
pub fn is_texc_int_1(&self) -> bool {
*self == TEXC_INT_A::TEXC_INT_1
}
}
#[doc = "Write proxy for field `TEXC_INT`"]
pub struct TEXC_INT_W<'a> {
w: &'a mut W,
}
impl<'a> TEXC_INT_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: TEXC_INT_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "No trigger exceptions have occurred."]
#[inline(always)]
pub fn texc_int_0(self) -> &'a mut W {
self.variant(TEXC_INT_A::TEXC_INT_0)
}
#[doc = "A trigger exception has occurred and is pending acknowledgement."]
#[inline(always)]
pub fn texc_int_1(self) -> &'a mut W {
self.variant(TEXC_INT_A::TEXC_INT_1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
self.w
}
}
#[doc = "Possible values of the field `TCOMP_INT`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TCOMP_INT_A {
#[doc = "Either IE\\[TCOMP_IE\\] is set to 0, or no trigger sequences have run to completion."]
TCOMP_INT_0,
#[doc = "Trigger sequence has been completed and all data is stored in the associated FIFO."]
TCOMP_INT_1,
}
impl From<TCOMP_INT_A> for bool {
#[inline(always)]
fn from(variant: TCOMP_INT_A) -> Self {
match variant {
TCOMP_INT_A::TCOMP_INT_0 => false,
TCOMP_INT_A::TCOMP_INT_1 => true,
}
}
}
#[doc = "Reader of field `TCOMP_INT`"]
pub type TCOMP_INT_R = crate::R<bool, TCOMP_INT_A>;
impl TCOMP_INT_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> TCOMP_INT_A {
match self.bits {
false => TCOMP_INT_A::TCOMP_INT_0,
true => TCOMP_INT_A::TCOMP_INT_1,
}
}
#[doc = "Checks if the value of the field is `TCOMP_INT_0`"]
#[inline(always)]
pub fn is_tcomp_int_0(&self) -> bool {
*self == TCOMP_INT_A::TCOMP_INT_0
}
#[doc = "Checks if the value of the field is `TCOMP_INT_1`"]
#[inline(always)]
pub fn is_tcomp_int_1(&self) -> bool {
*self == TCOMP_INT_A::TCOMP_INT_1
}
}
#[doc = "Write proxy for field `TCOMP_INT`"]
pub struct TCOMP_INT_W<'a> {
w: &'a mut W,
}
impl<'a> TCOMP_INT_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: TCOMP_INT_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Either IE\\[TCOMP_IE\\] is set to 0, or no trigger sequences have run to completion."]
#[inline(always)]
pub fn tcomp_int_0(self) -> &'a mut W {
self.variant(TCOMP_INT_A::TCOMP_INT_0)
}
#[doc = "Trigger sequence has been completed and all data is stored in the associated FIFO."]
#[inline(always)]
pub fn tcomp_int_1(self) -> &'a mut W {
self.variant(TCOMP_INT_A::TCOMP_INT_1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
self.w
}
}
#[doc = "Possible values of the field `CAL_RDY`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CAL_RDY_A {
#[doc = "Calibration is incomplete or hasn't been ran."]
CAL_RDY_0,
#[doc = "The ADC is calibrated."]
CAL_RDY_1,
}
impl From<CAL_RDY_A> for bool {
#[inline(always)]
fn from(variant: CAL_RDY_A) -> Self {
match variant {
CAL_RDY_A::CAL_RDY_0 => false,
CAL_RDY_A::CAL_RDY_1 => true,
}
}
}
#[doc = "Reader of field `CAL_RDY`"]
pub type CAL_RDY_R = crate::R<bool, CAL_RDY_A>;
impl CAL_RDY_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CAL_RDY_A {
match self.bits {
false => CAL_RDY_A::CAL_RDY_0,
true => CAL_RDY_A::CAL_RDY_1,
}
}
#[doc = "Checks if the value of the field is `CAL_RDY_0`"]
#[inline(always)]
pub fn is_cal_rdy_0(&self) -> bool {
*self == CAL_RDY_A::CAL_RDY_0
}
#[doc = "Checks if the value of the field is `CAL_RDY_1`"]
#[inline(always)]
pub fn is_cal_rdy_1(&self) -> bool {
*self == CAL_RDY_A::CAL_RDY_1
}
}
#[doc = "Possible values of the field `ADC_ACTIVE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC_ACTIVE_A {
#[doc = "The ADC is IDLE. There are no pending triggers to service and no active commands are being processed."]
ADC_ACTIVE_0,
#[doc = "The ADC is processing a conversion, running through the power up delay, or servicing a trigger."]
ADC_ACTIVE_1,
}
impl From<ADC_ACTIVE_A> for bool {
#[inline(always)]
fn from(variant: ADC_ACTIVE_A) -> Self {
match variant {
ADC_ACTIVE_A::ADC_ACTIVE_0 => false,
ADC_ACTIVE_A::ADC_ACTIVE_1 => true,
}
}
}
#[doc = "Reader of field `ADC_ACTIVE`"]
pub type ADC_ACTIVE_R = crate::R<bool, ADC_ACTIVE_A>;
impl ADC_ACTIVE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> ADC_ACTIVE_A {
match self.bits {
false => ADC_ACTIVE_A::ADC_ACTIVE_0,
true => ADC_ACTIVE_A::ADC_ACTIVE_1,
}
}
#[doc = "Checks if the value of the field is `ADC_ACTIVE_0`"]
#[inline(always)]
pub fn is_adc_active_0(&self) -> bool {
*self == ADC_ACTIVE_A::ADC_ACTIVE_0
}
#[doc = "Checks if the value of the field is `ADC_ACTIVE_1`"]
#[inline(always)]
pub fn is_adc_active_1(&self) -> bool {
*self == ADC_ACTIVE_A::ADC_ACTIVE_1
}
}
#[doc = "Possible values of the field `TRGACT`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TRGACT_A {
#[doc = "Command (sequence) associated with Trigger 0 currently being executed."]
TRGACT_0,
#[doc = "Command (sequence) associated with Trigger 1 currently being executed."]
TRGACT_1,
#[doc = "Command (sequence) associated with Trigger 2 currently being executed."]
TRGACT_2,
#[doc = "Command (sequence) from the associated Trigger number is currently being executed."]
TRGACT_3,
#[doc = "Command (sequence) from the associated Trigger number is currently being executed."]
TRGACT_4,
#[doc = "Command (sequence) from the associated Trigger number is currently being executed."]
TRGACT_5,
#[doc = "Command (sequence) from the associated Trigger number is currently being executed."]
TRGACT_6,
#[doc = "Command (sequence) from the associated Trigger number is currently being executed."]
TRGACT_7,
#[doc = "Command (sequence) from the associated Trigger number is currently being executed."]
TRGACT_8,
#[doc = "Command (sequence) from the associated Trigger number is currently being executed."]
TRGACT_9,
}
impl From<TRGACT_A> for u8 {
#[inline(always)]
fn from(variant: TRGACT_A) -> Self {
match variant {
TRGACT_A::TRGACT_0 => 0,
TRGACT_A::TRGACT_1 => 1,
TRGACT_A::TRGACT_2 => 2,
TRGACT_A::TRGACT_3 => 3,
TRGACT_A::TRGACT_4 => 4,
TRGACT_A::TRGACT_5 => 5,
TRGACT_A::TRGACT_6 => 6,
TRGACT_A::TRGACT_7 => 7,
TRGACT_A::TRGACT_8 => 8,
TRGACT_A::TRGACT_9 => 9,
}
}
}
#[doc = "Reader of field `TRGACT`"]
pub type TRGACT_R = crate::R<u8, TRGACT_A>;
impl TRGACT_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<u8, TRGACT_A> {
use crate::Variant::*;
match self.bits {
0 => Val(TRGACT_A::TRGACT_0),
1 => Val(TRGACT_A::TRGACT_1),
2 => Val(TRGACT_A::TRGACT_2),
3 => Val(TRGACT_A::TRGACT_3),
4 => Val(TRGACT_A::TRGACT_4),
5 => Val(TRGACT_A::TRGACT_5),
6 => Val(TRGACT_A::TRGACT_6),
7 => Val(TRGACT_A::TRGACT_7),
8 => Val(TRGACT_A::TRGACT_8),
9 => Val(TRGACT_A::TRGACT_9),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `TRGACT_0`"]
#[inline(always)]
pub fn is_trgact_0(&self) -> bool {
*self == TRGACT_A::TRGACT_0
}
#[doc = "Checks if the value of the field is `TRGACT_1`"]
#[inline(always)]
pub fn is_trgact_1(&self) -> bool {
*self == TRGACT_A::TRGACT_1
}
#[doc = "Checks if the value of the field is `TRGACT_2`"]
#[inline(always)]
pub fn is_trgact_2(&self) -> bool {
*self == TRGACT_A::TRGACT_2
}
#[doc = "Checks if the value of the field is `TRGACT_3`"]
#[inline(always)]
pub fn is_trgact_3(&self) -> bool {
*self == TRGACT_A::TRGACT_3
}
#[doc = "Checks if the value of the field is `TRGACT_4`"]
#[inline(always)]
pub fn is_trgact_4(&self) -> bool {
*self == TRGACT_A::TRGACT_4
}
#[doc = "Checks if the value of the field is `TRGACT_5`"]
#[inline(always)]
pub fn is_trgact_5(&self) -> bool {
*self == TRGACT_A::TRGACT_5
}
#[doc = "Checks if the value of the field is `TRGACT_6`"]
#[inline(always)]
pub fn is_trgact_6(&self) -> bool {
*self == TRGACT_A::TRGACT_6
}
#[doc = "Checks if the value of the field is `TRGACT_7`"]
#[inline(always)]
pub fn is_trgact_7(&self) -> bool {
*self == TRGACT_A::TRGACT_7
}
#[doc = "Checks if the value of the field is `TRGACT_8`"]
#[inline(always)]
pub fn is_trgact_8(&self) -> bool {
*self == TRGACT_A::TRGACT_8
}
#[doc = "Checks if the value of the field is `TRGACT_9`"]
#[inline(always)]
pub fn is_trgact_9(&self) -> bool {
*self == TRGACT_A::TRGACT_9
}
}
#[doc = "Possible values of the field `CMDACT`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CMDACT_A {
#[doc = "No command is currently in progress."]
CMDACT_0,
#[doc = "Command 1 currently being executed."]
CMDACT_1,
#[doc = "Command 2 currently being executed."]
CMDACT_2,
#[doc = "Associated command number is currently being executed."]
CMDACT_3,
#[doc = "Associated command number is currently being executed."]
CMDACT_4,
#[doc = "Associated command number is currently being executed."]
CMDACT_5,
#[doc = "Associated command number is currently being executed."]
CMDACT_6,
#[doc = "Associated command number is currently being executed."]
CMDACT_7,
#[doc = "Associated command number is currently being executed."]
CMDACT_8,
#[doc = "Associated command number is currently being executed."]
CMDACT_9,
}
impl From<CMDACT_A> for u8 {
#[inline(always)]
fn from(variant: CMDACT_A) -> Self {
match variant {
CMDACT_A::CMDACT_0 => 0,
CMDACT_A::CMDACT_1 => 1,
CMDACT_A::CMDACT_2 => 2,
CMDACT_A::CMDACT_3 => 3,
CMDACT_A::CMDACT_4 => 4,
CMDACT_A::CMDACT_5 => 5,
CMDACT_A::CMDACT_6 => 6,
CMDACT_A::CMDACT_7 => 7,
CMDACT_A::CMDACT_8 => 8,
CMDACT_A::CMDACT_9 => 9,
}
}
}
#[doc = "Reader of field `CMDACT`"]
pub type CMDACT_R = crate::R<u8, CMDACT_A>;
impl CMDACT_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<u8, CMDACT_A> {
use crate::Variant::*;
match self.bits {
0 => Val(CMDACT_A::CMDACT_0),
1 => Val(CMDACT_A::CMDACT_1),
2 => Val(CMDACT_A::CMDACT_2),
3 => Val(CMDACT_A::CMDACT_3),
4 => Val(CMDACT_A::CMDACT_4),
5 => Val(CMDACT_A::CMDACT_5),
6 => Val(CMDACT_A::CMDACT_6),
7 => Val(CMDACT_A::CMDACT_7),
8 => Val(CMDACT_A::CMDACT_8),
9 => Val(CMDACT_A::CMDACT_9),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `CMDACT_0`"]
#[inline(always)]
pub fn is_cmdact_0(&self) -> bool {
*self == CMDACT_A::CMDACT_0
}
#[doc = "Checks if the value of the field is `CMDACT_1`"]
#[inline(always)]
pub fn is_cmdact_1(&self) -> bool {
*self == CMDACT_A::CMDACT_1
}
#[doc = "Checks if the value of the field is `CMDACT_2`"]
#[inline(always)]
pub fn is_cmdact_2(&self) -> bool {
*self == CMDACT_A::CMDACT_2
}
#[doc = "Checks if the value of the field is `CMDACT_3`"]
#[inline(always)]
pub fn is_cmdact_3(&self) -> bool {
*self == CMDACT_A::CMDACT_3
}
#[doc = "Checks if the value of the field is `CMDACT_4`"]
#[inline(always)]
pub fn is_cmdact_4(&self) -> bool {
*self == CMDACT_A::CMDACT_4
}
#[doc = "Checks if the value of the field is `CMDACT_5`"]
#[inline(always)]
pub fn is_cmdact_5(&self) -> bool {
*self == CMDACT_A::CMDACT_5
}
#[doc = "Checks if the value of the field is `CMDACT_6`"]
#[inline(always)]
pub fn is_cmdact_6(&self) -> bool {
*self == CMDACT_A::CMDACT_6
}
#[doc = "Checks if the value of the field is `CMDACT_7`"]
#[inline(always)]
pub fn is_cmdact_7(&self) -> bool {
*self == CMDACT_A::CMDACT_7
}
#[doc = "Checks if the value of the field is `CMDACT_8`"]
#[inline(always)]
pub fn is_cmdact_8(&self) -> bool {
*self == CMDACT_A::CMDACT_8
}
#[doc = "Checks if the value of the field is `CMDACT_9`"]
#[inline(always)]
pub fn is_cmdact_9(&self) -> bool {
*self == CMDACT_A::CMDACT_9
}
}
impl R {
#[doc = "Bit 0 - Result FIFO 0 Ready Flag"]
#[inline(always)]
pub fn rdy0(&self) -> RDY0_R {
RDY0_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - Result FIFO 0 Overflow Flag"]
#[inline(always)]
pub fn fof0(&self) -> FOF0_R {
FOF0_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - Result FIFO1 Ready Flag"]
#[inline(always)]
pub fn rdy1(&self) -> RDY1_R {
RDY1_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 3 - Result FIFO1 Overflow Flag"]
#[inline(always)]
pub fn fof1(&self) -> FOF1_R {
FOF1_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 8 - Interrupt Flag For High Priority Trigger Exception"]
#[inline(always)]
pub fn texc_int(&self) -> TEXC_INT_R {
TEXC_INT_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 9 - Interrupt Flag For Trigger Completion"]
#[inline(always)]
pub fn tcomp_int(&self) -> TCOMP_INT_R {
TCOMP_INT_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 10 - Calibration Ready"]
#[inline(always)]
pub fn cal_rdy(&self) -> CAL_RDY_R {
CAL_RDY_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 11 - ADC Active"]
#[inline(always)]
pub fn adc_active(&self) -> ADC_ACTIVE_R {
ADC_ACTIVE_R::new(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bits 16:19 - Trigger Active"]
#[inline(always)]
pub fn trgact(&self) -> TRGACT_R {
TRGACT_R::new(((self.bits >> 16) & 0x0f) as u8)
}
#[doc = "Bits 24:27 - Command Active"]
#[inline(always)]
pub fn cmdact(&self) -> CMDACT_R {
CMDACT_R::new(((self.bits >> 24) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bit 1 - Result FIFO 0 Overflow Flag"]
#[inline(always)]
pub fn fof0(&mut self) -> FOF0_W {
FOF0_W { w: self }
}
#[doc = "Bit 3 - Result FIFO1 Overflow Flag"]
#[inline(always)]
pub fn fof1(&mut self) -> FOF1_W {
FOF1_W { w: self }
}
#[doc = "Bit 8 - Interrupt Flag For High Priority Trigger Exception"]
#[inline(always)]
pub fn texc_int(&mut self) -> TEXC_INT_W {
TEXC_INT_W { w: self }
}
#[doc = "Bit 9 - Interrupt Flag For Trigger Completion"]
#[inline(always)]
pub fn tcomp_int(&mut self) -> TCOMP_INT_W {
TCOMP_INT_W { w: self }
}
}