#[doc = "Reader of register OVSAMPCTL"]
pub type R = crate::R<u32, super::OVSAMPCTL>;
#[doc = "Writer for register OVSAMPCTL"]
pub type W = crate::W<u32, super::OVSAMPCTL>;
#[doc = "Register OVSAMPCTL `reset()`'s with value 0"]
impl crate::ResetValue for super::OVSAMPCTL {
    type Type = u32;
    #[inline(always)]
    fn reset_value() -> Self::Type {
        0
    }
}
#[doc = "Triggered Oversampling\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TOVS_A {
    #[doc = "0: All oversampled conversions are done consecutively"]
    CONSECUTIVE = 0,
    #[doc = "1: Each oversampled conversion needs a trigger"]
    INDIVIDUAL = 1,
}
impl From<TOVS_A> for bool {
    #[inline(always)]
    fn from(variant: TOVS_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `TOVS`"]
pub type TOVS_R = crate::R<bool, TOVS_A>;
impl TOVS_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> TOVS_A {
        match self.bits {
            false => TOVS_A::CONSECUTIVE,
            true => TOVS_A::INDIVIDUAL,
        }
    }
    #[doc = "Checks if the value of the field is `CONSECUTIVE`"]
    #[inline(always)]
    pub fn is_consecutive(&self) -> bool {
        *self == TOVS_A::CONSECUTIVE
    }
    #[doc = "Checks if the value of the field is `INDIVIDUAL`"]
    #[inline(always)]
    pub fn is_individual(&self) -> bool {
        *self == TOVS_A::INDIVIDUAL
    }
}
#[doc = "Write proxy for field `TOVS`"]
pub struct TOVS_W<'a> {
    w: &'a mut W,
}
impl<'a> TOVS_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: TOVS_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "All oversampled conversions are done consecutively"]
    #[inline(always)]
    pub fn consecutive(self) -> &'a mut W {
        self.variant(TOVS_A::CONSECUTIVE)
    }
    #[doc = "Each oversampled conversion needs a trigger"]
    #[inline(always)]
    pub fn individual(self) -> &'a mut W {
        self.variant(TOVS_A::INDIVIDUAL)
    }
    #[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 = "Reader of field `OVSS`"]
pub type OVSS_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `OVSS`"]
pub struct OVSS_W<'a> {
    w: &'a mut W,
}
impl<'a> OVSS_W<'a> {
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x0f << 5)) | (((value as u32) & 0x0f) << 5);
        self.w
    }
}
#[doc = "Oversampling ratio\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum OVSR_A {
    #[doc = "0: 2x"]
    TIMES2 = 0,
    #[doc = "1: 4x"]
    TIMES4 = 1,
    #[doc = "2: 8x"]
    TIMES8 = 2,
    #[doc = "3: 16x"]
    TIMES16 = 3,
    #[doc = "4: 32x"]
    TIMES32 = 4,
    #[doc = "5: 64x"]
    TIMES64 = 5,
    #[doc = "6: 128x"]
    TIMES128 = 6,
    #[doc = "7: 256x"]
    TIMES256 = 7,
}
impl From<OVSR_A> for u8 {
    #[inline(always)]
    fn from(variant: OVSR_A) -> Self {
        variant as _
    }
}
#[doc = "Reader of field `OVSR`"]
pub type OVSR_R = crate::R<u8, OVSR_A>;
impl OVSR_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> OVSR_A {
        match self.bits {
            0 => OVSR_A::TIMES2,
            1 => OVSR_A::TIMES4,
            2 => OVSR_A::TIMES8,
            3 => OVSR_A::TIMES16,
            4 => OVSR_A::TIMES32,
            5 => OVSR_A::TIMES64,
            6 => OVSR_A::TIMES128,
            7 => OVSR_A::TIMES256,
            _ => unreachable!(),
        }
    }
    #[doc = "Checks if the value of the field is `TIMES2`"]
    #[inline(always)]
    pub fn is_times2(&self) -> bool {
        *self == OVSR_A::TIMES2
    }
    #[doc = "Checks if the value of the field is `TIMES4`"]
    #[inline(always)]
    pub fn is_times4(&self) -> bool {
        *self == OVSR_A::TIMES4
    }
    #[doc = "Checks if the value of the field is `TIMES8`"]
    #[inline(always)]
    pub fn is_times8(&self) -> bool {
        *self == OVSR_A::TIMES8
    }
    #[doc = "Checks if the value of the field is `TIMES16`"]
    #[inline(always)]
    pub fn is_times16(&self) -> bool {
        *self == OVSR_A::TIMES16
    }
    #[doc = "Checks if the value of the field is `TIMES32`"]
    #[inline(always)]
    pub fn is_times32(&self) -> bool {
        *self == OVSR_A::TIMES32
    }
    #[doc = "Checks if the value of the field is `TIMES64`"]
    #[inline(always)]
    pub fn is_times64(&self) -> bool {
        *self == OVSR_A::TIMES64
    }
    #[doc = "Checks if the value of the field is `TIMES128`"]
    #[inline(always)]
    pub fn is_times128(&self) -> bool {
        *self == OVSR_A::TIMES128
    }
    #[doc = "Checks if the value of the field is `TIMES256`"]
    #[inline(always)]
    pub fn is_times256(&self) -> bool {
        *self == OVSR_A::TIMES256
    }
}
#[doc = "Write proxy for field `OVSR`"]
pub struct OVSR_W<'a> {
    w: &'a mut W,
}
impl<'a> OVSR_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: OVSR_A) -> &'a mut W {
        {
            self.bits(variant.into())
        }
    }
    #[doc = "2x"]
    #[inline(always)]
    pub fn times2(self) -> &'a mut W {
        self.variant(OVSR_A::TIMES2)
    }
    #[doc = "4x"]
    #[inline(always)]
    pub fn times4(self) -> &'a mut W {
        self.variant(OVSR_A::TIMES4)
    }
    #[doc = "8x"]
    #[inline(always)]
    pub fn times8(self) -> &'a mut W {
        self.variant(OVSR_A::TIMES8)
    }
    #[doc = "16x"]
    #[inline(always)]
    pub fn times16(self) -> &'a mut W {
        self.variant(OVSR_A::TIMES16)
    }
    #[doc = "32x"]
    #[inline(always)]
    pub fn times32(self) -> &'a mut W {
        self.variant(OVSR_A::TIMES32)
    }
    #[doc = "64x"]
    #[inline(always)]
    pub fn times64(self) -> &'a mut W {
        self.variant(OVSR_A::TIMES64)
    }
    #[doc = "128x"]
    #[inline(always)]
    pub fn times128(self) -> &'a mut W {
        self.variant(OVSR_A::TIMES128)
    }
    #[doc = "256x"]
    #[inline(always)]
    pub fn times256(self) -> &'a mut W {
        self.variant(OVSR_A::TIMES256)
    }
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x07 << 2)) | (((value as u32) & 0x07) << 2);
        self.w
    }
}
#[doc = "Oversampler Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum OVSEN_A {
    #[doc = "0: Oversampling disabled"]
    DISABLED = 0,
    #[doc = "1: Oversampling enabled"]
    ENABLED = 1,
}
impl From<OVSEN_A> for bool {
    #[inline(always)]
    fn from(variant: OVSEN_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `OVSEN`"]
pub type OVSEN_R = crate::R<bool, OVSEN_A>;
impl OVSEN_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> OVSEN_A {
        match self.bits {
            false => OVSEN_A::DISABLED,
            true => OVSEN_A::ENABLED,
        }
    }
    #[doc = "Checks if the value of the field is `DISABLED`"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == OVSEN_A::DISABLED
    }
    #[doc = "Checks if the value of the field is `ENABLED`"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == OVSEN_A::ENABLED
    }
}
#[doc = "Write proxy for field `OVSEN`"]
pub struct OVSEN_W<'a> {
    w: &'a mut W,
}
impl<'a> OVSEN_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: OVSEN_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "Oversampling disabled"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut W {
        self.variant(OVSEN_A::DISABLED)
    }
    #[doc = "Oversampling enabled"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut W {
        self.variant(OVSEN_A::ENABLED)
    }
    #[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) | ((value as u32) & 0x01);
        self.w
    }
}
impl R {
    #[doc = "Bit 9 - Triggered Oversampling"]
    #[inline(always)]
    pub fn tovs(&self) -> TOVS_R {
        TOVS_R::new(((self.bits >> 9) & 0x01) != 0)
    }
    #[doc = "Bits 5:8 - Oversampling shift"]
    #[inline(always)]
    pub fn ovss(&self) -> OVSS_R {
        OVSS_R::new(((self.bits >> 5) & 0x0f) as u8)
    }
    #[doc = "Bits 2:4 - Oversampling ratio"]
    #[inline(always)]
    pub fn ovsr(&self) -> OVSR_R {
        OVSR_R::new(((self.bits >> 2) & 0x07) as u8)
    }
    #[doc = "Bit 0 - Oversampler Enable"]
    #[inline(always)]
    pub fn ovsen(&self) -> OVSEN_R {
        OVSEN_R::new((self.bits & 0x01) != 0)
    }
}
impl W {
    #[doc = "Bit 9 - Triggered Oversampling"]
    #[inline(always)]
    pub fn tovs(&mut self) -> TOVS_W {
        TOVS_W { w: self }
    }
    #[doc = "Bits 5:8 - Oversampling shift"]
    #[inline(always)]
    pub fn ovss(&mut self) -> OVSS_W {
        OVSS_W { w: self }
    }
    #[doc = "Bits 2:4 - Oversampling ratio"]
    #[inline(always)]
    pub fn ovsr(&mut self) -> OVSR_W {
        OVSR_W { w: self }
    }
    #[doc = "Bit 0 - Oversampler Enable"]
    #[inline(always)]
    pub fn ovsen(&mut self) -> OVSEN_W {
        OVSEN_W { w: self }
    }
}