#[doc = r" Value read from the register"]
pub struct R {
    bits: u32,
}
#[doc = r" Value to write to the register"]
pub struct W {
    bits: u32,
}
impl super::ISR {
    #[doc = r" Modifies the contents of the register"]
    #[inline]
    pub fn modify<F>(&self, f: F)
    where
        for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
    {
        let bits = self.register.get();
        let r = R { bits: bits };
        let mut w = W { bits: bits };
        f(&r, &mut w);
        self.register.set(w.bits);
    }
    #[doc = r" Reads the contents of the register"]
    #[inline]
    pub fn read(&self) -> R {
        R {
            bits: self.register.get(),
        }
    }
    #[doc = r" Writes to the register"]
    #[inline]
    pub fn write<F>(&self, f: F)
    where
        F: FnOnce(&mut W) -> &mut W,
    {
        let mut w = W::reset_value();
        f(&mut w);
        self.register.set(w.bits);
    }
    #[doc = r" Writes the reset value to the register"]
    #[inline]
    pub fn reset(&self) {
        self.write(|w| w)
    }
}
#[doc = "Possible values of the field `AWD`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum AWDR {
    #[doc = "No analog watchdog event occurred"]
    NOEVENT,
    #[doc = "Analog watchdog event occurred"]
    EVENT,
}
impl AWDR {
    #[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 as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            AWDR::NOEVENT => false,
            AWDR::EVENT => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> AWDR {
        match value {
            false => AWDR::NOEVENT,
            true => AWDR::EVENT,
        }
    }
    #[doc = "Checks if the value of the field is `NOEVENT`"]
    #[inline]
    pub fn is_no_event(&self) -> bool {
        *self == AWDR::NOEVENT
    }
    #[doc = "Checks if the value of the field is `EVENT`"]
    #[inline]
    pub fn is_event(&self) -> bool {
        *self == AWDR::EVENT
    }
}
#[doc = "Possible values of the field `OVR`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum OVRR {
    #[doc = "No overrun occurred"]
    NOOVERRUN,
    #[doc = "Overrun occurred"]
    OVERRUN,
}
impl OVRR {
    #[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 as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            OVRR::NOOVERRUN => false,
            OVRR::OVERRUN => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> OVRR {
        match value {
            false => OVRR::NOOVERRUN,
            true => OVRR::OVERRUN,
        }
    }
    #[doc = "Checks if the value of the field is `NOOVERRUN`"]
    #[inline]
    pub fn is_no_overrun(&self) -> bool {
        *self == OVRR::NOOVERRUN
    }
    #[doc = "Checks if the value of the field is `OVERRUN`"]
    #[inline]
    pub fn is_overrun(&self) -> bool {
        *self == OVRR::OVERRUN
    }
}
#[doc = "Possible values of the field `EOSEQ`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EOSEQR {
    #[doc = "Conversion sequence is not complete"]
    NOTCOMPLETE,
    #[doc = "Conversion sequence complete"]
    COMPLETE,
}
impl EOSEQR {
    #[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 as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            EOSEQR::NOTCOMPLETE => false,
            EOSEQR::COMPLETE => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> EOSEQR {
        match value {
            false => EOSEQR::NOTCOMPLETE,
            true => EOSEQR::COMPLETE,
        }
    }
    #[doc = "Checks if the value of the field is `NOTCOMPLETE`"]
    #[inline]
    pub fn is_not_complete(&self) -> bool {
        *self == EOSEQR::NOTCOMPLETE
    }
    #[doc = "Checks if the value of the field is `COMPLETE`"]
    #[inline]
    pub fn is_complete(&self) -> bool {
        *self == EOSEQR::COMPLETE
    }
}
#[doc = "Possible values of the field `EOC`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EOCR {
    #[doc = "Channel conversion is not complete"]
    NOTCOMPLETE,
    #[doc = "Channel conversion complete"]
    COMPLETE,
}
impl EOCR {
    #[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 as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            EOCR::NOTCOMPLETE => false,
            EOCR::COMPLETE => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> EOCR {
        match value {
            false => EOCR::NOTCOMPLETE,
            true => EOCR::COMPLETE,
        }
    }
    #[doc = "Checks if the value of the field is `NOTCOMPLETE`"]
    #[inline]
    pub fn is_not_complete(&self) -> bool {
        *self == EOCR::NOTCOMPLETE
    }
    #[doc = "Checks if the value of the field is `COMPLETE`"]
    #[inline]
    pub fn is_complete(&self) -> bool {
        *self == EOCR::COMPLETE
    }
}
#[doc = "Possible values of the field `EOSMP`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EOSMPR {
    #[doc = "Not at the end of the samplings phase"]
    NOTATEND,
    #[doc = "End of sampling phase reached"]
    ATEND,
}
impl EOSMPR {
    #[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 as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            EOSMPR::NOTATEND => false,
            EOSMPR::ATEND => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> EOSMPR {
        match value {
            false => EOSMPR::NOTATEND,
            true => EOSMPR::ATEND,
        }
    }
    #[doc = "Checks if the value of the field is `NOTATEND`"]
    #[inline]
    pub fn is_not_at_end(&self) -> bool {
        *self == EOSMPR::NOTATEND
    }
    #[doc = "Checks if the value of the field is `ATEND`"]
    #[inline]
    pub fn is_at_end(&self) -> bool {
        *self == EOSMPR::ATEND
    }
}
#[doc = "Possible values of the field `ADRDY`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADRDYR {
    #[doc = "ADC not yet ready to start conversion"]
    NOTREADY,
    #[doc = "ADC ready to start conversion"]
    READY,
}
impl ADRDYR {
    #[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 as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADRDYR::NOTREADY => false,
            ADRDYR::READY => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADRDYR {
        match value {
            false => ADRDYR::NOTREADY,
            true => ADRDYR::READY,
        }
    }
    #[doc = "Checks if the value of the field is `NOTREADY`"]
    #[inline]
    pub fn is_not_ready(&self) -> bool {
        *self == ADRDYR::NOTREADY
    }
    #[doc = "Checks if the value of the field is `READY`"]
    #[inline]
    pub fn is_ready(&self) -> bool {
        *self == ADRDYR::READY
    }
}
#[doc = "Values that can be written to the field `AWD`"]
pub enum AWDW {
    #[doc = "Clear the analog watchdog event flag"]
    CLEAR,
}
impl AWDW {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            AWDW::CLEAR => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _AWDW<'a> {
    w: &'a mut W,
}
impl<'a> _AWDW<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: AWDW) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Clear the analog watchdog event flag"]
    #[inline]
    pub fn clear(self) -> &'a mut W {
        self.variant(AWDW::CLEAR)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 7;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `OVR`"]
pub enum OVRW {
    #[doc = "Clear the overrun flag"]
    CLEAR,
}
impl OVRW {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            OVRW::CLEAR => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _OVRW<'a> {
    w: &'a mut W,
}
impl<'a> _OVRW<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: OVRW) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Clear the overrun flag"]
    #[inline]
    pub fn clear(self) -> &'a mut W {
        self.variant(OVRW::CLEAR)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 4;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `EOSEQ`"]
pub enum EOSEQW {
    #[doc = "Clear the conversion sequence flag"]
    CLEAR,
}
impl EOSEQW {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            EOSEQW::CLEAR => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _EOSEQW<'a> {
    w: &'a mut W,
}
impl<'a> _EOSEQW<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: EOSEQW) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Clear the conversion sequence flag"]
    #[inline]
    pub fn clear(self) -> &'a mut W {
        self.variant(EOSEQW::CLEAR)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 3;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `EOC`"]
pub enum EOCW {
    #[doc = "Clear the channel conversion flag"]
    CLEAR,
}
impl EOCW {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            EOCW::CLEAR => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _EOCW<'a> {
    w: &'a mut W,
}
impl<'a> _EOCW<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: EOCW) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Clear the channel conversion flag"]
    #[inline]
    pub fn clear(self) -> &'a mut W {
        self.variant(EOCW::CLEAR)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 2;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `EOSMP`"]
pub enum EOSMPW {
    #[doc = "Clear the sampling phase flag"]
    CLEAR,
}
impl EOSMPW {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            EOSMPW::CLEAR => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _EOSMPW<'a> {
    w: &'a mut W,
}
impl<'a> _EOSMPW<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: EOSMPW) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Clear the sampling phase flag"]
    #[inline]
    pub fn clear(self) -> &'a mut W {
        self.variant(EOSMPW::CLEAR)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 1;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADRDY`"]
pub enum ADRDYW {
    #[doc = "Clear the ADC ready flag"]
    CLEAR,
}
impl ADRDYW {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADRDYW::CLEAR => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADRDYW<'a> {
    w: &'a mut W,
}
impl<'a> _ADRDYW<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADRDYW) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Clear the ADC ready flag"]
    #[inline]
    pub fn clear(self) -> &'a mut W {
        self.variant(ADRDYW::CLEAR)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 0;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
impl R {
    #[doc = r" Value of the register as raw bits"]
    #[inline]
    pub fn bits(&self) -> u32 {
        self.bits
    }
    #[doc = "Bit 7 - Analog watchdog flag"]
    #[inline]
    pub fn awd(&self) -> AWDR {
        AWDR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 7;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 4 - ADC overrun"]
    #[inline]
    pub fn ovr(&self) -> OVRR {
        OVRR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 4;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 3 - End of sequence flag"]
    #[inline]
    pub fn eoseq(&self) -> EOSEQR {
        EOSEQR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 3;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 2 - End of conversion flag"]
    #[inline]
    pub fn eoc(&self) -> EOCR {
        EOCR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 2;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 1 - End of sampling flag"]
    #[inline]
    pub fn eosmp(&self) -> EOSMPR {
        EOSMPR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 1;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 0 - ADC ready"]
    #[inline]
    pub fn adrdy(&self) -> ADRDYR {
        ADRDYR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 0;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
}
impl W {
    #[doc = r" Reset value of the register"]
    #[inline]
    pub fn reset_value() -> W {
        W { bits: 0 }
    }
    #[doc = r" Writes raw bits to the register"]
    #[inline]
    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
        self.bits = bits;
        self
    }
    #[doc = "Bit 7 - Analog watchdog flag"]
    #[inline]
    pub fn awd(&mut self) -> _AWDW {
        _AWDW { w: self }
    }
    #[doc = "Bit 4 - ADC overrun"]
    #[inline]
    pub fn ovr(&mut self) -> _OVRW {
        _OVRW { w: self }
    }
    #[doc = "Bit 3 - End of sequence flag"]
    #[inline]
    pub fn eoseq(&mut self) -> _EOSEQW {
        _EOSEQW { w: self }
    }
    #[doc = "Bit 2 - End of conversion flag"]
    #[inline]
    pub fn eoc(&mut self) -> _EOCW {
        _EOCW { w: self }
    }
    #[doc = "Bit 1 - End of sampling flag"]
    #[inline]
    pub fn eosmp(&mut self) -> _EOSMPW {
        _EOSMPW { w: self }
    }
    #[doc = "Bit 0 - ADC ready"]
    #[inline]
    pub fn adrdy(&mut self) -> _ADRDYW {
        _ADRDYW { w: self }
    }
}