#[doc = "Register `FLAGS` reader"]
pub type R = crate::R<FlagsSpec>;
#[doc = "Register `FLAGS` writer"]
pub type W = crate::W<FlagsSpec>;
#[doc = "TIMEOUT fault flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ToFlag {
    #[doc = "0: A TIMEOUT fault has not occurred"]
    NoFlag = 0,
    #[doc = "1: A TIMEOUT fault has occurred"]
    Flag = 1,
}
impl From<ToFlag> for bool {
    #[inline(always)]
    fn from(variant: ToFlag) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `TO_FLAG` reader - TIMEOUT fault flag"]
pub type ToFlagR = crate::BitReader<ToFlag>;
impl ToFlagR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> ToFlag {
        match self.bits {
            false => ToFlag::NoFlag,
            true => ToFlag::Flag,
        }
    }
    #[doc = "A TIMEOUT fault has not occurred"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == ToFlag::NoFlag
    }
    #[doc = "A TIMEOUT fault has occurred"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == ToFlag::Flag
    }
}
#[doc = "Field `TO_FLAG` writer - TIMEOUT fault flag"]
pub type ToFlagW<'a, REG> = crate::BitWriter1C<'a, REG, ToFlag>;
impl<'a, REG> ToFlagW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "A TIMEOUT fault has not occurred"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(ToFlag::NoFlag)
    }
    #[doc = "A TIMEOUT fault has occurred"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(ToFlag::Flag)
    }
}
#[doc = "MISCOMPARE fault flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum MiscomFlag {
    #[doc = "0: A MISCOMPARE fault has not occurred"]
    NoFlag = 0,
    #[doc = "1: A MISCOMPARE fault has occurred"]
    Flag = 1,
}
impl From<MiscomFlag> for bool {
    #[inline(always)]
    fn from(variant: MiscomFlag) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MISCOM_FLAG` reader - MISCOMPARE fault flag"]
pub type MiscomFlagR = crate::BitReader<MiscomFlag>;
impl MiscomFlagR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> MiscomFlag {
        match self.bits {
            false => MiscomFlag::NoFlag,
            true => MiscomFlag::Flag,
        }
    }
    #[doc = "A MISCOMPARE fault has not occurred"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == MiscomFlag::NoFlag
    }
    #[doc = "A MISCOMPARE fault has occurred"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == MiscomFlag::Flag
    }
}
#[doc = "Field `MISCOM_FLAG` writer - MISCOMPARE fault flag"]
pub type MiscomFlagW<'a, REG> = crate::BitWriter1C<'a, REG, MiscomFlag>;
impl<'a, REG> MiscomFlagW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "A MISCOMPARE fault has not occurred"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(MiscomFlag::NoFlag)
    }
    #[doc = "A MISCOMPARE fault has occurred"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(MiscomFlag::Flag)
    }
}
#[doc = "SEQUENCE fault flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SeqFlag {
    #[doc = "0: A SEQUENCE fault has not occurred"]
    NoFlag = 0,
    #[doc = "1: A SEQUENCE fault has occurred"]
    Flag = 1,
}
impl From<SeqFlag> for bool {
    #[inline(always)]
    fn from(variant: SeqFlag) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `SEQ_FLAG` reader - SEQUENCE fault flag"]
pub type SeqFlagR = crate::BitReader<SeqFlag>;
impl SeqFlagR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> SeqFlag {
        match self.bits {
            false => SeqFlag::NoFlag,
            true => SeqFlag::Flag,
        }
    }
    #[doc = "A SEQUENCE fault has not occurred"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == SeqFlag::NoFlag
    }
    #[doc = "A SEQUENCE fault has occurred"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == SeqFlag::Flag
    }
}
#[doc = "Field `SEQ_FLAG` writer - SEQUENCE fault flag"]
pub type SeqFlagW<'a, REG> = crate::BitWriter1C<'a, REG, SeqFlag>;
impl<'a, REG> SeqFlagW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "A SEQUENCE fault has not occurred"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(SeqFlag::NoFlag)
    }
    #[doc = "A SEQUENCE fault has occurred"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(SeqFlag::Flag)
    }
}
#[doc = "CONTROL fault flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CntFlag {
    #[doc = "0: A CONTROL fault has not occurred"]
    NoFlag = 0,
    #[doc = "1: A CONTROL fault has occurred"]
    Flag = 1,
}
impl From<CntFlag> for bool {
    #[inline(always)]
    fn from(variant: CntFlag) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `CNT_FLAG` reader - CONTROL fault flag"]
pub type CntFlagR = crate::BitReader<CntFlag>;
impl CntFlagR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> CntFlag {
        match self.bits {
            false => CntFlag::NoFlag,
            true => CntFlag::Flag,
        }
    }
    #[doc = "A CONTROL fault has not occurred"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == CntFlag::NoFlag
    }
    #[doc = "A CONTROL fault has occurred"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == CntFlag::Flag
    }
}
#[doc = "Field `CNT_FLAG` writer - CONTROL fault flag"]
pub type CntFlagW<'a, REG> = crate::BitWriter1C<'a, REG, CntFlag>;
impl<'a, REG> CntFlagW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "A CONTROL fault has not occurred"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(CntFlag::NoFlag)
    }
    #[doc = "A CONTROL fault has occurred"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(CntFlag::Flag)
    }
}
#[doc = "STATE fault flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum StateFlag {
    #[doc = "0: A STATE fault has not occurred"]
    NoFlag = 0,
    #[doc = "1: A STATE fault has occurred"]
    Flag = 1,
}
impl From<StateFlag> for bool {
    #[inline(always)]
    fn from(variant: StateFlag) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `STATE_FLAG` reader - STATE fault flag"]
pub type StateFlagR = crate::BitReader<StateFlag>;
impl StateFlagR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> StateFlag {
        match self.bits {
            false => StateFlag::NoFlag,
            true => StateFlag::Flag,
        }
    }
    #[doc = "A STATE fault has not occurred"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == StateFlag::NoFlag
    }
    #[doc = "A STATE fault has occurred"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == StateFlag::Flag
    }
}
#[doc = "Field `STATE_FLAG` writer - STATE fault flag"]
pub type StateFlagW<'a, REG> = crate::BitWriter1C<'a, REG, StateFlag>;
impl<'a, REG> StateFlagW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "A STATE fault has not occurred"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(StateFlag::NoFlag)
    }
    #[doc = "A STATE fault has occurred"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(StateFlag::Flag)
    }
}
#[doc = "ADDRESS fault flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum AddrFlag {
    #[doc = "0: An ADDRESS fault has not occurred"]
    NoFlag = 0,
    #[doc = "1: An ADDRESS fault has occurred"]
    Flag = 1,
}
impl From<AddrFlag> for bool {
    #[inline(always)]
    fn from(variant: AddrFlag) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `ADDR_FLAG` reader - ADDRESS fault flag"]
pub type AddrFlagR = crate::BitReader<AddrFlag>;
impl AddrFlagR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> AddrFlag {
        match self.bits {
            false => AddrFlag::NoFlag,
            true => AddrFlag::Flag,
        }
    }
    #[doc = "An ADDRESS fault has not occurred"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == AddrFlag::NoFlag
    }
    #[doc = "An ADDRESS fault has occurred"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == AddrFlag::Flag
    }
}
#[doc = "Field `ADDR_FLAG` writer - ADDRESS fault flag"]
pub type AddrFlagW<'a, REG> = crate::BitWriter1C<'a, REG, AddrFlag>;
impl<'a, REG> AddrFlagW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "An ADDRESS fault has not occurred"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(AddrFlag::NoFlag)
    }
    #[doc = "An ADDRESS fault has occurred"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(AddrFlag::Flag)
    }
}
#[doc = "Power-on reset flag\n\nValue on reset: 1"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PorFlag {
    #[doc = "0: A Power-on reset event has not occurred"]
    NoFlag = 0,
    #[doc = "1: A Power-on reset event has occurred"]
    Flag = 1,
}
impl From<PorFlag> for bool {
    #[inline(always)]
    fn from(variant: PorFlag) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `POR_FLAG` reader - Power-on reset flag"]
pub type PorFlagR = crate::BitReader<PorFlag>;
impl PorFlagR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> PorFlag {
        match self.bits {
            false => PorFlag::NoFlag,
            true => PorFlag::Flag,
        }
    }
    #[doc = "A Power-on reset event has not occurred"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == PorFlag::NoFlag
    }
    #[doc = "A Power-on reset event has occurred"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == PorFlag::Flag
    }
}
#[doc = "Field `POR_FLAG` writer - Power-on reset flag"]
pub type PorFlagW<'a, REG> = crate::BitWriter1C<'a, REG, PorFlag>;
impl<'a, REG> PorFlagW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "A Power-on reset event has not occurred"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(PorFlag::NoFlag)
    }
    #[doc = "A Power-on reset event has occurred"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(PorFlag::Flag)
    }
}
impl R {
    #[doc = "Bit 0 - TIMEOUT fault flag"]
    #[inline(always)]
    pub fn to_flag(&self) -> ToFlagR {
        ToFlagR::new((self.bits & 1) != 0)
    }
    #[doc = "Bit 1 - MISCOMPARE fault flag"]
    #[inline(always)]
    pub fn miscom_flag(&self) -> MiscomFlagR {
        MiscomFlagR::new(((self.bits >> 1) & 1) != 0)
    }
    #[doc = "Bit 2 - SEQUENCE fault flag"]
    #[inline(always)]
    pub fn seq_flag(&self) -> SeqFlagR {
        SeqFlagR::new(((self.bits >> 2) & 1) != 0)
    }
    #[doc = "Bit 3 - CONTROL fault flag"]
    #[inline(always)]
    pub fn cnt_flag(&self) -> CntFlagR {
        CntFlagR::new(((self.bits >> 3) & 1) != 0)
    }
    #[doc = "Bit 4 - STATE fault flag"]
    #[inline(always)]
    pub fn state_flag(&self) -> StateFlagR {
        StateFlagR::new(((self.bits >> 4) & 1) != 0)
    }
    #[doc = "Bit 5 - ADDRESS fault flag"]
    #[inline(always)]
    pub fn addr_flag(&self) -> AddrFlagR {
        AddrFlagR::new(((self.bits >> 5) & 1) != 0)
    }
    #[doc = "Bit 16 - Power-on reset flag"]
    #[inline(always)]
    pub fn por_flag(&self) -> PorFlagR {
        PorFlagR::new(((self.bits >> 16) & 1) != 0)
    }
}
#[cfg(feature = "debug")]
impl core::fmt::Debug for R {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("FLAGS")
            .field("to_flag", &self.to_flag())
            .field("miscom_flag", &self.miscom_flag())
            .field("seq_flag", &self.seq_flag())
            .field("cnt_flag", &self.cnt_flag())
            .field("state_flag", &self.state_flag())
            .field("addr_flag", &self.addr_flag())
            .field("por_flag", &self.por_flag())
            .finish()
    }
}
impl W {
    #[doc = "Bit 0 - TIMEOUT fault flag"]
    #[inline(always)]
    pub fn to_flag(&mut self) -> ToFlagW<'_, FlagsSpec> {
        ToFlagW::new(self, 0)
    }
    #[doc = "Bit 1 - MISCOMPARE fault flag"]
    #[inline(always)]
    pub fn miscom_flag(&mut self) -> MiscomFlagW<'_, FlagsSpec> {
        MiscomFlagW::new(self, 1)
    }
    #[doc = "Bit 2 - SEQUENCE fault flag"]
    #[inline(always)]
    pub fn seq_flag(&mut self) -> SeqFlagW<'_, FlagsSpec> {
        SeqFlagW::new(self, 2)
    }
    #[doc = "Bit 3 - CONTROL fault flag"]
    #[inline(always)]
    pub fn cnt_flag(&mut self) -> CntFlagW<'_, FlagsSpec> {
        CntFlagW::new(self, 3)
    }
    #[doc = "Bit 4 - STATE fault flag"]
    #[inline(always)]
    pub fn state_flag(&mut self) -> StateFlagW<'_, FlagsSpec> {
        StateFlagW::new(self, 4)
    }
    #[doc = "Bit 5 - ADDRESS fault flag"]
    #[inline(always)]
    pub fn addr_flag(&mut self) -> AddrFlagW<'_, FlagsSpec> {
        AddrFlagW::new(self, 5)
    }
    #[doc = "Bit 16 - Power-on reset flag"]
    #[inline(always)]
    pub fn por_flag(&mut self) -> PorFlagW<'_, FlagsSpec> {
        PorFlagW::new(self, 16)
    }
}
#[doc = "Flags Register\n\nYou can [`read`](crate::Reg::read) this register and get [`flags::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`flags::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct FlagsSpec;
impl crate::RegisterSpec for FlagsSpec {
    type Ux = u32;
}
#[doc = "`read()` method returns [`flags::R`](R) reader structure"]
impl crate::Readable for FlagsSpec {}
#[doc = "`write(|w| ..)` method takes [`flags::W`](W) writer structure"]
impl crate::Writable for FlagsSpec {
    type Safety = crate::Unsafe;
    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0x0001_003f;
}
#[doc = "`reset()` method sets FLAGS to value 0x0001_0000"]
impl crate::Resettable for FlagsSpec {
    const RESET_VALUE: u32 = 0x0001_0000;
}
