#[doc = "Register `CFG` reader"]
pub type R = crate::R<CfgSpec>;
#[doc = "Register `CFG` writer"]
pub type W = crate::W<CfgSpec>;
#[doc = "Enable Capture 0\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Capen0 {
    #[doc = "0: Disable"]
    Capen0isdisabled = 0,
    #[doc = "1: Enable"]
    Capen0isenabled = 1,
}
impl From<Capen0> for bool {
    #[inline(always)]
    fn from(variant: Capen0) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `CAPEN0` reader - Enable Capture 0"]
pub type Capen0R = crate::BitReader<Capen0>;
impl Capen0R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Capen0 {
        match self.bits {
            false => Capen0::Capen0isdisabled,
            true => Capen0::Capen0isenabled,
        }
    }
    #[doc = "Disable"]
    #[inline(always)]
    pub fn is_capen0isdisabled(&self) -> bool {
        *self == Capen0::Capen0isdisabled
    }
    #[doc = "Enable"]
    #[inline(always)]
    pub fn is_capen0isenabled(&self) -> bool {
        *self == Capen0::Capen0isenabled
    }
}
#[doc = "Field `CAPEN0` writer - Enable Capture 0"]
pub type Capen0W<'a, REG> = crate::BitWriter<'a, REG, Capen0>;
impl<'a, REG> Capen0W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Disable"]
    #[inline(always)]
    pub fn capen0isdisabled(self) -> &'a mut crate::W<REG> {
        self.variant(Capen0::Capen0isdisabled)
    }
    #[doc = "Enable"]
    #[inline(always)]
    pub fn capen0isenabled(self) -> &'a mut crate::W<REG> {
        self.variant(Capen0::Capen0isenabled)
    }
}
#[doc = "Enable Capture 1\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Capen1 {
    #[doc = "0: Disable"]
    Capen1isdisabled = 0,
    #[doc = "1: Enable"]
    Capen1isenabled = 1,
}
impl From<Capen1> for bool {
    #[inline(always)]
    fn from(variant: Capen1) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `CAPEN1` reader - Enable Capture 1"]
pub type Capen1R = crate::BitReader<Capen1>;
impl Capen1R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Capen1 {
        match self.bits {
            false => Capen1::Capen1isdisabled,
            true => Capen1::Capen1isenabled,
        }
    }
    #[doc = "Disable"]
    #[inline(always)]
    pub fn is_capen1isdisabled(&self) -> bool {
        *self == Capen1::Capen1isdisabled
    }
    #[doc = "Enable"]
    #[inline(always)]
    pub fn is_capen1isenabled(&self) -> bool {
        *self == Capen1::Capen1isenabled
    }
}
#[doc = "Field `CAPEN1` writer - Enable Capture 1"]
pub type Capen1W<'a, REG> = crate::BitWriter<'a, REG, Capen1>;
impl<'a, REG> Capen1W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Disable"]
    #[inline(always)]
    pub fn capen1isdisabled(self) -> &'a mut crate::W<REG> {
        self.variant(Capen1::Capen1isdisabled)
    }
    #[doc = "Enable"]
    #[inline(always)]
    pub fn capen1isenabled(self) -> &'a mut crate::W<REG> {
        self.variant(Capen1::Capen1isenabled)
    }
}
#[doc = "Enable Capture 2\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Capen2 {
    #[doc = "0: Disable"]
    Capen2isdisabled = 0,
    #[doc = "1: Enable"]
    Capen2isenabled = 1,
}
impl From<Capen2> for bool {
    #[inline(always)]
    fn from(variant: Capen2) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `CAPEN2` reader - Enable Capture 2"]
pub type Capen2R = crate::BitReader<Capen2>;
impl Capen2R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Capen2 {
        match self.bits {
            false => Capen2::Capen2isdisabled,
            true => Capen2::Capen2isenabled,
        }
    }
    #[doc = "Disable"]
    #[inline(always)]
    pub fn is_capen2isdisabled(&self) -> bool {
        *self == Capen2::Capen2isdisabled
    }
    #[doc = "Enable"]
    #[inline(always)]
    pub fn is_capen2isenabled(&self) -> bool {
        *self == Capen2::Capen2isenabled
    }
}
#[doc = "Field `CAPEN2` writer - Enable Capture 2"]
pub type Capen2W<'a, REG> = crate::BitWriter<'a, REG, Capen2>;
impl<'a, REG> Capen2W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Disable"]
    #[inline(always)]
    pub fn capen2isdisabled(self) -> &'a mut crate::W<REG> {
        self.variant(Capen2::Capen2isdisabled)
    }
    #[doc = "Enable"]
    #[inline(always)]
    pub fn capen2isenabled(self) -> &'a mut crate::W<REG> {
        self.variant(Capen2::Capen2isenabled)
    }
}
#[doc = "Enable Capture 3\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Capen3 {
    #[doc = "0: Disable"]
    Capen3isdisabled = 0,
    #[doc = "1: Enable"]
    Capen3isenabled = 1,
}
impl From<Capen3> for bool {
    #[inline(always)]
    fn from(variant: Capen3) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `CAPEN3` reader - Enable Capture 3"]
pub type Capen3R = crate::BitReader<Capen3>;
impl Capen3R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Capen3 {
        match self.bits {
            false => Capen3::Capen3isdisabled,
            true => Capen3::Capen3isenabled,
        }
    }
    #[doc = "Disable"]
    #[inline(always)]
    pub fn is_capen3isdisabled(&self) -> bool {
        *self == Capen3::Capen3isdisabled
    }
    #[doc = "Enable"]
    #[inline(always)]
    pub fn is_capen3isenabled(&self) -> bool {
        *self == Capen3::Capen3isenabled
    }
}
#[doc = "Field `CAPEN3` writer - Enable Capture 3"]
pub type Capen3W<'a, REG> = crate::BitWriter<'a, REG, Capen3>;
impl<'a, REG> Capen3W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Disable"]
    #[inline(always)]
    pub fn capen3isdisabled(self) -> &'a mut crate::W<REG> {
        self.variant(Capen3::Capen3isdisabled)
    }
    #[doc = "Enable"]
    #[inline(always)]
    pub fn capen3isenabled(self) -> &'a mut crate::W<REG> {
        self.variant(Capen3::Capen3isenabled)
    }
}
#[doc = "Capture Polarity 0\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Cappol0 {
    #[doc = "0: Positive"]
    Cappol0posedgecapture = 0,
    #[doc = "1: Negative"]
    Cappol0negedgecapture = 1,
}
impl From<Cappol0> for bool {
    #[inline(always)]
    fn from(variant: Cappol0) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `CAPPOL0` reader - Capture Polarity 0"]
pub type Cappol0R = crate::BitReader<Cappol0>;
impl Cappol0R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Cappol0 {
        match self.bits {
            false => Cappol0::Cappol0posedgecapture,
            true => Cappol0::Cappol0negedgecapture,
        }
    }
    #[doc = "Positive"]
    #[inline(always)]
    pub fn is_cappol0posedgecapture(&self) -> bool {
        *self == Cappol0::Cappol0posedgecapture
    }
    #[doc = "Negative"]
    #[inline(always)]
    pub fn is_cappol0negedgecapture(&self) -> bool {
        *self == Cappol0::Cappol0negedgecapture
    }
}
#[doc = "Field `CAPPOL0` writer - Capture Polarity 0"]
pub type Cappol0W<'a, REG> = crate::BitWriter<'a, REG, Cappol0>;
impl<'a, REG> Cappol0W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Positive"]
    #[inline(always)]
    pub fn cappol0posedgecapture(self) -> &'a mut crate::W<REG> {
        self.variant(Cappol0::Cappol0posedgecapture)
    }
    #[doc = "Negative"]
    #[inline(always)]
    pub fn cappol0negedgecapture(self) -> &'a mut crate::W<REG> {
        self.variant(Cappol0::Cappol0negedgecapture)
    }
}
#[doc = "Capture-Polarity 1\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Cappol1 {
    #[doc = "0: Positive"]
    Cappol1posedgecapture = 0,
    #[doc = "1: Negative"]
    Cappol1negedgecapture = 1,
}
impl From<Cappol1> for bool {
    #[inline(always)]
    fn from(variant: Cappol1) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `CAPPOL1` reader - Capture-Polarity 1"]
pub type Cappol1R = crate::BitReader<Cappol1>;
impl Cappol1R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Cappol1 {
        match self.bits {
            false => Cappol1::Cappol1posedgecapture,
            true => Cappol1::Cappol1negedgecapture,
        }
    }
    #[doc = "Positive"]
    #[inline(always)]
    pub fn is_cappol1posedgecapture(&self) -> bool {
        *self == Cappol1::Cappol1posedgecapture
    }
    #[doc = "Negative"]
    #[inline(always)]
    pub fn is_cappol1negedgecapture(&self) -> bool {
        *self == Cappol1::Cappol1negedgecapture
    }
}
#[doc = "Field `CAPPOL1` writer - Capture-Polarity 1"]
pub type Cappol1W<'a, REG> = crate::BitWriter<'a, REG, Cappol1>;
impl<'a, REG> Cappol1W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Positive"]
    #[inline(always)]
    pub fn cappol1posedgecapture(self) -> &'a mut crate::W<REG> {
        self.variant(Cappol1::Cappol1posedgecapture)
    }
    #[doc = "Negative"]
    #[inline(always)]
    pub fn cappol1negedgecapture(self) -> &'a mut crate::W<REG> {
        self.variant(Cappol1::Cappol1negedgecapture)
    }
}
#[doc = "Capture Polarity 2\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Cappol2 {
    #[doc = "0: Positive"]
    Cappol2posedgecapture = 0,
    #[doc = "1: Negative"]
    Cappol2negedgecapture = 1,
}
impl From<Cappol2> for bool {
    #[inline(always)]
    fn from(variant: Cappol2) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `CAPPOL2` reader - Capture Polarity 2"]
pub type Cappol2R = crate::BitReader<Cappol2>;
impl Cappol2R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Cappol2 {
        match self.bits {
            false => Cappol2::Cappol2posedgecapture,
            true => Cappol2::Cappol2negedgecapture,
        }
    }
    #[doc = "Positive"]
    #[inline(always)]
    pub fn is_cappol2posedgecapture(&self) -> bool {
        *self == Cappol2::Cappol2posedgecapture
    }
    #[doc = "Negative"]
    #[inline(always)]
    pub fn is_cappol2negedgecapture(&self) -> bool {
        *self == Cappol2::Cappol2negedgecapture
    }
}
#[doc = "Field `CAPPOL2` writer - Capture Polarity 2"]
pub type Cappol2W<'a, REG> = crate::BitWriter<'a, REG, Cappol2>;
impl<'a, REG> Cappol2W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Positive"]
    #[inline(always)]
    pub fn cappol2posedgecapture(self) -> &'a mut crate::W<REG> {
        self.variant(Cappol2::Cappol2posedgecapture)
    }
    #[doc = "Negative"]
    #[inline(always)]
    pub fn cappol2negedgecapture(self) -> &'a mut crate::W<REG> {
        self.variant(Cappol2::Cappol2negedgecapture)
    }
}
#[doc = "Capture Polarity 3\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Cappol3 {
    #[doc = "0: Positive"]
    Cappol3posedgecapture = 0,
    #[doc = "1: Negative"]
    Cappol3negedgecapture = 1,
}
impl From<Cappol3> for bool {
    #[inline(always)]
    fn from(variant: Cappol3) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `CAPPOL3` reader - Capture Polarity 3"]
pub type Cappol3R = crate::BitReader<Cappol3>;
impl Cappol3R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Cappol3 {
        match self.bits {
            false => Cappol3::Cappol3posedgecapture,
            true => Cappol3::Cappol3negedgecapture,
        }
    }
    #[doc = "Positive"]
    #[inline(always)]
    pub fn is_cappol3posedgecapture(&self) -> bool {
        *self == Cappol3::Cappol3posedgecapture
    }
    #[doc = "Negative"]
    #[inline(always)]
    pub fn is_cappol3negedgecapture(&self) -> bool {
        *self == Cappol3::Cappol3negedgecapture
    }
}
#[doc = "Field `CAPPOL3` writer - Capture Polarity 3"]
pub type Cappol3W<'a, REG> = crate::BitWriter<'a, REG, Cappol3>;
impl<'a, REG> Cappol3W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Positive"]
    #[inline(always)]
    pub fn cappol3posedgecapture(self) -> &'a mut crate::W<REG> {
        self.variant(Cappol3::Cappol3posedgecapture)
    }
    #[doc = "Negative"]
    #[inline(always)]
    pub fn cappol3negedgecapture(self) -> &'a mut crate::W<REG> {
        self.variant(Cappol3::Cappol3negedgecapture)
    }
}
impl R {
    #[doc = "Bit 0 - Enable Capture 0"]
    #[inline(always)]
    pub fn capen0(&self) -> Capen0R {
        Capen0R::new((self.bits & 1) != 0)
    }
    #[doc = "Bit 1 - Enable Capture 1"]
    #[inline(always)]
    pub fn capen1(&self) -> Capen1R {
        Capen1R::new(((self.bits >> 1) & 1) != 0)
    }
    #[doc = "Bit 2 - Enable Capture 2"]
    #[inline(always)]
    pub fn capen2(&self) -> Capen2R {
        Capen2R::new(((self.bits >> 2) & 1) != 0)
    }
    #[doc = "Bit 3 - Enable Capture 3"]
    #[inline(always)]
    pub fn capen3(&self) -> Capen3R {
        Capen3R::new(((self.bits >> 3) & 1) != 0)
    }
    #[doc = "Bit 8 - Capture Polarity 0"]
    #[inline(always)]
    pub fn cappol0(&self) -> Cappol0R {
        Cappol0R::new(((self.bits >> 8) & 1) != 0)
    }
    #[doc = "Bit 9 - Capture-Polarity 1"]
    #[inline(always)]
    pub fn cappol1(&self) -> Cappol1R {
        Cappol1R::new(((self.bits >> 9) & 1) != 0)
    }
    #[doc = "Bit 10 - Capture Polarity 2"]
    #[inline(always)]
    pub fn cappol2(&self) -> Cappol2R {
        Cappol2R::new(((self.bits >> 10) & 1) != 0)
    }
    #[doc = "Bit 11 - Capture Polarity 3"]
    #[inline(always)]
    pub fn cappol3(&self) -> Cappol3R {
        Cappol3R::new(((self.bits >> 11) & 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("CFG")
            .field("capen0", &self.capen0())
            .field("capen1", &self.capen1())
            .field("capen2", &self.capen2())
            .field("capen3", &self.capen3())
            .field("cappol0", &self.cappol0())
            .field("cappol1", &self.cappol1())
            .field("cappol2", &self.cappol2())
            .field("cappol3", &self.cappol3())
            .finish()
    }
}
impl W {
    #[doc = "Bit 0 - Enable Capture 0"]
    #[inline(always)]
    pub fn capen0(&mut self) -> Capen0W<'_, CfgSpec> {
        Capen0W::new(self, 0)
    }
    #[doc = "Bit 1 - Enable Capture 1"]
    #[inline(always)]
    pub fn capen1(&mut self) -> Capen1W<'_, CfgSpec> {
        Capen1W::new(self, 1)
    }
    #[doc = "Bit 2 - Enable Capture 2"]
    #[inline(always)]
    pub fn capen2(&mut self) -> Capen2W<'_, CfgSpec> {
        Capen2W::new(self, 2)
    }
    #[doc = "Bit 3 - Enable Capture 3"]
    #[inline(always)]
    pub fn capen3(&mut self) -> Capen3W<'_, CfgSpec> {
        Capen3W::new(self, 3)
    }
    #[doc = "Bit 8 - Capture Polarity 0"]
    #[inline(always)]
    pub fn cappol0(&mut self) -> Cappol0W<'_, CfgSpec> {
        Cappol0W::new(self, 8)
    }
    #[doc = "Bit 9 - Capture-Polarity 1"]
    #[inline(always)]
    pub fn cappol1(&mut self) -> Cappol1W<'_, CfgSpec> {
        Cappol1W::new(self, 9)
    }
    #[doc = "Bit 10 - Capture Polarity 2"]
    #[inline(always)]
    pub fn cappol2(&mut self) -> Cappol2W<'_, CfgSpec> {
        Cappol2W::new(self, 10)
    }
    #[doc = "Bit 11 - Capture Polarity 3"]
    #[inline(always)]
    pub fn cappol3(&mut self) -> Cappol3W<'_, CfgSpec> {
        Cappol3W::new(self, 11)
    }
}
#[doc = "Capture Configuration\n\nYou can [`read`](crate::Reg::read) this register and get [`cfg::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`cfg::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CfgSpec;
impl crate::RegisterSpec for CfgSpec {
    type Ux = u32;
}
#[doc = "`read()` method returns [`cfg::R`](R) reader structure"]
impl crate::Readable for CfgSpec {}
#[doc = "`write(|w| ..)` method takes [`cfg::W`](W) writer structure"]
impl crate::Writable for CfgSpec {
    type Safety = crate::Unsafe;
}
#[doc = "`reset()` method sets CFG to value 0"]
impl crate::Resettable for CfgSpec {}
