#[doc = "Register `IER` reader"]
pub struct R(crate::R<IER_SPEC>);
impl core::ops::Deref for R {
type Target = crate::R<IER_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<IER_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<IER_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `IER` writer"]
pub struct W(crate::W<IER_SPEC>);
impl core::ops::Deref for W {
type Target = crate::W<IER_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<IER_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<IER_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Injected context queue overflow interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum JQOVFIE_A {
#[doc = "0: Injected context queue overflow interrupt disabled"]
DISABLED = 0,
#[doc = "1: Injected context queue overflow interrupt enabled"]
ENABLED = 1,
}
impl From<JQOVFIE_A> for bool {
#[inline(always)]
fn from(variant: JQOVFIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `JQOVFIE` reader - Injected context queue overflow interrupt enable"]
pub struct JQOVFIE_R(crate::FieldReader<bool, JQOVFIE_A>);
impl JQOVFIE_R {
pub(crate) fn new(bits: bool) -> Self {
JQOVFIE_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> JQOVFIE_A {
match self.bits {
false => JQOVFIE_A::DISABLED,
true => JQOVFIE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == JQOVFIE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == JQOVFIE_A::ENABLED
}
}
impl core::ops::Deref for JQOVFIE_R {
type Target = crate::FieldReader<bool, JQOVFIE_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `JQOVFIE` writer - Injected context queue overflow interrupt enable"]
pub struct JQOVFIE_W<'a> {
w: &'a mut W,
}
impl<'a> JQOVFIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: JQOVFIE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Injected context queue overflow interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(JQOVFIE_A::DISABLED)
}
#[doc = "Injected context queue overflow interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(JQOVFIE_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 << 10)) | ((value as u32 & 0x01) << 10);
self.w
}
}
#[doc = "Analog watchdog 3 interrupt enable"]
pub type AWD3IE_A = AWD1IE_A;
#[doc = "Field `AWD3IE` reader - Analog watchdog 3 interrupt enable"]
pub type AWD3IE_R = AWD1IE_R;
#[doc = "Field `AWD3IE` writer - Analog watchdog 3 interrupt enable"]
pub struct AWD3IE_W<'a> {
w: &'a mut W,
}
impl<'a> AWD3IE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: AWD3IE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Analog watchdog interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(AWD3IE_A::DISABLED)
}
#[doc = "Analog watchdog interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(AWD3IE_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 << 9)) | ((value as u32 & 0x01) << 9);
self.w
}
}
#[doc = "Analog watchdog 2 interrupt enable"]
pub type AWD2IE_A = AWD1IE_A;
#[doc = "Field `AWD2IE` reader - Analog watchdog 2 interrupt enable"]
pub type AWD2IE_R = AWD1IE_R;
#[doc = "Field `AWD2IE` writer - Analog watchdog 2 interrupt enable"]
pub struct AWD2IE_W<'a> {
w: &'a mut W,
}
impl<'a> AWD2IE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: AWD2IE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Analog watchdog interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(AWD2IE_A::DISABLED)
}
#[doc = "Analog watchdog interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(AWD2IE_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 << 8)) | ((value as u32 & 0x01) << 8);
self.w
}
}
#[doc = "Analog watchdog 1 interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum AWD1IE_A {
#[doc = "0: Analog watchdog interrupt disabled"]
DISABLED = 0,
#[doc = "1: Analog watchdog interrupt enabled"]
ENABLED = 1,
}
impl From<AWD1IE_A> for bool {
#[inline(always)]
fn from(variant: AWD1IE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `AWD1IE` reader - Analog watchdog 1 interrupt enable"]
pub struct AWD1IE_R(crate::FieldReader<bool, AWD1IE_A>);
impl AWD1IE_R {
pub(crate) fn new(bits: bool) -> Self {
AWD1IE_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> AWD1IE_A {
match self.bits {
false => AWD1IE_A::DISABLED,
true => AWD1IE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == AWD1IE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == AWD1IE_A::ENABLED
}
}
impl core::ops::Deref for AWD1IE_R {
type Target = crate::FieldReader<bool, AWD1IE_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `AWD1IE` writer - Analog watchdog 1 interrupt enable"]
pub struct AWD1IE_W<'a> {
w: &'a mut W,
}
impl<'a> AWD1IE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: AWD1IE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Analog watchdog interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(AWD1IE_A::DISABLED)
}
#[doc = "Analog watchdog interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(AWD1IE_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 << 7)) | ((value as u32 & 0x01) << 7);
self.w
}
}
#[doc = "End of injected sequence of conversions interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum JEOSIE_A {
#[doc = "0: End of injected sequence interrupt disabled"]
DISABLED = 0,
#[doc = "1: End of injected sequence interrupt enabled"]
ENABLED = 1,
}
impl From<JEOSIE_A> for bool {
#[inline(always)]
fn from(variant: JEOSIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `JEOSIE` reader - End of injected sequence of conversions interrupt enable"]
pub struct JEOSIE_R(crate::FieldReader<bool, JEOSIE_A>);
impl JEOSIE_R {
pub(crate) fn new(bits: bool) -> Self {
JEOSIE_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> JEOSIE_A {
match self.bits {
false => JEOSIE_A::DISABLED,
true => JEOSIE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == JEOSIE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == JEOSIE_A::ENABLED
}
}
impl core::ops::Deref for JEOSIE_R {
type Target = crate::FieldReader<bool, JEOSIE_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `JEOSIE` writer - End of injected sequence of conversions interrupt enable"]
pub struct JEOSIE_W<'a> {
w: &'a mut W,
}
impl<'a> JEOSIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: JEOSIE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "End of injected sequence interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(JEOSIE_A::DISABLED)
}
#[doc = "End of injected sequence interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(JEOSIE_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 << 6)) | ((value as u32 & 0x01) << 6);
self.w
}
}
#[doc = "End of injected conversion interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum JEOCIE_A {
#[doc = "0: End of injected conversion interrupt disabled"]
DISABLED = 0,
#[doc = "1: End of injected conversion interrupt enabled"]
ENABLED = 1,
}
impl From<JEOCIE_A> for bool {
#[inline(always)]
fn from(variant: JEOCIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `JEOCIE` reader - End of injected conversion interrupt enable"]
pub struct JEOCIE_R(crate::FieldReader<bool, JEOCIE_A>);
impl JEOCIE_R {
pub(crate) fn new(bits: bool) -> Self {
JEOCIE_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> JEOCIE_A {
match self.bits {
false => JEOCIE_A::DISABLED,
true => JEOCIE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == JEOCIE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == JEOCIE_A::ENABLED
}
}
impl core::ops::Deref for JEOCIE_R {
type Target = crate::FieldReader<bool, JEOCIE_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `JEOCIE` writer - End of injected conversion interrupt enable"]
pub struct JEOCIE_W<'a> {
w: &'a mut W,
}
impl<'a> JEOCIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: JEOCIE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "End of injected conversion interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(JEOCIE_A::DISABLED)
}
#[doc = "End of injected conversion interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(JEOCIE_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 << 5)) | ((value as u32 & 0x01) << 5);
self.w
}
}
#[doc = "Overrun interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum OVRIE_A {
#[doc = "0: Overrun interrupt disabled"]
DISABLED = 0,
#[doc = "1: Overrun interrupt enabled"]
ENABLED = 1,
}
impl From<OVRIE_A> for bool {
#[inline(always)]
fn from(variant: OVRIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `OVRIE` reader - Overrun interrupt enable"]
pub struct OVRIE_R(crate::FieldReader<bool, OVRIE_A>);
impl OVRIE_R {
pub(crate) fn new(bits: bool) -> Self {
OVRIE_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> OVRIE_A {
match self.bits {
false => OVRIE_A::DISABLED,
true => OVRIE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == OVRIE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == OVRIE_A::ENABLED
}
}
impl core::ops::Deref for OVRIE_R {
type Target = crate::FieldReader<bool, OVRIE_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `OVRIE` writer - Overrun interrupt enable"]
pub struct OVRIE_W<'a> {
w: &'a mut W,
}
impl<'a> OVRIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: OVRIE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Overrun interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(OVRIE_A::DISABLED)
}
#[doc = "Overrun interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(OVRIE_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 << 4)) | ((value as u32 & 0x01) << 4);
self.w
}
}
#[doc = "End of regular sequence of conversions interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EOSIE_A {
#[doc = "0: End of regular sequence interrupt disabled"]
DISABLED = 0,
#[doc = "1: End of regular sequence interrupt enabled"]
ENABLED = 1,
}
impl From<EOSIE_A> for bool {
#[inline(always)]
fn from(variant: EOSIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `EOSIE` reader - End of regular sequence of conversions interrupt enable"]
pub struct EOSIE_R(crate::FieldReader<bool, EOSIE_A>);
impl EOSIE_R {
pub(crate) fn new(bits: bool) -> Self {
EOSIE_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> EOSIE_A {
match self.bits {
false => EOSIE_A::DISABLED,
true => EOSIE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == EOSIE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == EOSIE_A::ENABLED
}
}
impl core::ops::Deref for EOSIE_R {
type Target = crate::FieldReader<bool, EOSIE_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `EOSIE` writer - End of regular sequence of conversions interrupt enable"]
pub struct EOSIE_W<'a> {
w: &'a mut W,
}
impl<'a> EOSIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: EOSIE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "End of regular sequence interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(EOSIE_A::DISABLED)
}
#[doc = "End of regular sequence interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(EOSIE_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 << 3)) | ((value as u32 & 0x01) << 3);
self.w
}
}
#[doc = "End of regular conversion interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EOCIE_A {
#[doc = "0: End of regular conversion interrupt disabled"]
DISABLED = 0,
#[doc = "1: End of regular conversion interrupt enabled"]
ENABLED = 1,
}
impl From<EOCIE_A> for bool {
#[inline(always)]
fn from(variant: EOCIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `EOCIE` reader - End of regular conversion interrupt enable"]
pub struct EOCIE_R(crate::FieldReader<bool, EOCIE_A>);
impl EOCIE_R {
pub(crate) fn new(bits: bool) -> Self {
EOCIE_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> EOCIE_A {
match self.bits {
false => EOCIE_A::DISABLED,
true => EOCIE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == EOCIE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == EOCIE_A::ENABLED
}
}
impl core::ops::Deref for EOCIE_R {
type Target = crate::FieldReader<bool, EOCIE_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `EOCIE` writer - End of regular conversion interrupt enable"]
pub struct EOCIE_W<'a> {
w: &'a mut W,
}
impl<'a> EOCIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: EOCIE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "End of regular conversion interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(EOCIE_A::DISABLED)
}
#[doc = "End of regular conversion interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(EOCIE_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 << 2)) | ((value as u32 & 0x01) << 2);
self.w
}
}
#[doc = "End of sampling flag interrupt enable for regular conversions\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EOSMPIE_A {
#[doc = "0: End of regular conversion sampling phase interrupt disabled"]
DISABLED = 0,
#[doc = "1: End of regular conversion sampling phase interrupt enabled"]
ENABLED = 1,
}
impl From<EOSMPIE_A> for bool {
#[inline(always)]
fn from(variant: EOSMPIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `EOSMPIE` reader - End of sampling flag interrupt enable for regular conversions"]
pub struct EOSMPIE_R(crate::FieldReader<bool, EOSMPIE_A>);
impl EOSMPIE_R {
pub(crate) fn new(bits: bool) -> Self {
EOSMPIE_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> EOSMPIE_A {
match self.bits {
false => EOSMPIE_A::DISABLED,
true => EOSMPIE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == EOSMPIE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == EOSMPIE_A::ENABLED
}
}
impl core::ops::Deref for EOSMPIE_R {
type Target = crate::FieldReader<bool, EOSMPIE_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `EOSMPIE` writer - End of sampling flag interrupt enable for regular conversions"]
pub struct EOSMPIE_W<'a> {
w: &'a mut W,
}
impl<'a> EOSMPIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: EOSMPIE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "End of regular conversion sampling phase interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(EOSMPIE_A::DISABLED)
}
#[doc = "End of regular conversion sampling phase interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(EOSMPIE_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 << 1)) | ((value as u32 & 0x01) << 1);
self.w
}
}
#[doc = "ADC ready interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADRDYIE_A {
#[doc = "0: ADC ready interrupt disabled"]
DISABLED = 0,
#[doc = "1: ADC ready interrupt enabled"]
ENABLED = 1,
}
impl From<ADRDYIE_A> for bool {
#[inline(always)]
fn from(variant: ADRDYIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `ADRDYIE` reader - ADC ready interrupt enable"]
pub struct ADRDYIE_R(crate::FieldReader<bool, ADRDYIE_A>);
impl ADRDYIE_R {
pub(crate) fn new(bits: bool) -> Self {
ADRDYIE_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> ADRDYIE_A {
match self.bits {
false => ADRDYIE_A::DISABLED,
true => ADRDYIE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == ADRDYIE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == ADRDYIE_A::ENABLED
}
}
impl core::ops::Deref for ADRDYIE_R {
type Target = crate::FieldReader<bool, ADRDYIE_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ADRDYIE` writer - ADC ready interrupt enable"]
pub struct ADRDYIE_W<'a> {
w: &'a mut W,
}
impl<'a> ADRDYIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: ADRDYIE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "ADC ready interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(ADRDYIE_A::DISABLED)
}
#[doc = "ADC ready interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(ADRDYIE_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 10 - Injected context queue overflow interrupt enable"]
#[inline(always)]
pub fn jqovfie(&self) -> JQOVFIE_R {
JQOVFIE_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 9 - Analog watchdog 3 interrupt enable"]
#[inline(always)]
pub fn awd3ie(&self) -> AWD3IE_R {
AWD3IE_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 8 - Analog watchdog 2 interrupt enable"]
#[inline(always)]
pub fn awd2ie(&self) -> AWD2IE_R {
AWD2IE_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 7 - Analog watchdog 1 interrupt enable"]
#[inline(always)]
pub fn awd1ie(&self) -> AWD1IE_R {
AWD1IE_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 6 - End of injected sequence of conversions interrupt enable"]
#[inline(always)]
pub fn jeosie(&self) -> JEOSIE_R {
JEOSIE_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 5 - End of injected conversion interrupt enable"]
#[inline(always)]
pub fn jeocie(&self) -> JEOCIE_R {
JEOCIE_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 4 - Overrun interrupt enable"]
#[inline(always)]
pub fn ovrie(&self) -> OVRIE_R {
OVRIE_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 3 - End of regular sequence of conversions interrupt enable"]
#[inline(always)]
pub fn eosie(&self) -> EOSIE_R {
EOSIE_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 2 - End of regular conversion interrupt enable"]
#[inline(always)]
pub fn eocie(&self) -> EOCIE_R {
EOCIE_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 1 - End of sampling flag interrupt enable for regular conversions"]
#[inline(always)]
pub fn eosmpie(&self) -> EOSMPIE_R {
EOSMPIE_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 0 - ADC ready interrupt enable"]
#[inline(always)]
pub fn adrdyie(&self) -> ADRDYIE_R {
ADRDYIE_R::new((self.bits & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 10 - Injected context queue overflow interrupt enable"]
#[inline(always)]
pub fn jqovfie(&mut self) -> JQOVFIE_W {
JQOVFIE_W { w: self }
}
#[doc = "Bit 9 - Analog watchdog 3 interrupt enable"]
#[inline(always)]
pub fn awd3ie(&mut self) -> AWD3IE_W {
AWD3IE_W { w: self }
}
#[doc = "Bit 8 - Analog watchdog 2 interrupt enable"]
#[inline(always)]
pub fn awd2ie(&mut self) -> AWD2IE_W {
AWD2IE_W { w: self }
}
#[doc = "Bit 7 - Analog watchdog 1 interrupt enable"]
#[inline(always)]
pub fn awd1ie(&mut self) -> AWD1IE_W {
AWD1IE_W { w: self }
}
#[doc = "Bit 6 - End of injected sequence of conversions interrupt enable"]
#[inline(always)]
pub fn jeosie(&mut self) -> JEOSIE_W {
JEOSIE_W { w: self }
}
#[doc = "Bit 5 - End of injected conversion interrupt enable"]
#[inline(always)]
pub fn jeocie(&mut self) -> JEOCIE_W {
JEOCIE_W { w: self }
}
#[doc = "Bit 4 - Overrun interrupt enable"]
#[inline(always)]
pub fn ovrie(&mut self) -> OVRIE_W {
OVRIE_W { w: self }
}
#[doc = "Bit 3 - End of regular sequence of conversions interrupt enable"]
#[inline(always)]
pub fn eosie(&mut self) -> EOSIE_W {
EOSIE_W { w: self }
}
#[doc = "Bit 2 - End of regular conversion interrupt enable"]
#[inline(always)]
pub fn eocie(&mut self) -> EOCIE_W {
EOCIE_W { w: self }
}
#[doc = "Bit 1 - End of sampling flag interrupt enable for regular conversions"]
#[inline(always)]
pub fn eosmpie(&mut self) -> EOSMPIE_W {
EOSMPIE_W { w: self }
}
#[doc = "Bit 0 - ADC ready interrupt enable"]
#[inline(always)]
pub fn adrdyie(&mut self) -> ADRDYIE_W {
ADRDYIE_W { w: self }
}
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
}
}
#[doc = "interrupt enable register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ier](index.html) module"]
pub struct IER_SPEC;
impl crate::RegisterSpec for IER_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [ier::R](R) reader structure"]
impl crate::Readable for IER_SPEC {
type Reader = R;
}
#[doc = "`write(|w| ..)` method takes [ier::W](W) writer structure"]
impl crate::Writable for IER_SPEC {
type Writer = W;
}
#[doc = "`reset()` method sets IER to value 0"]
impl crate::Resettable for IER_SPEC {
#[inline(always)]
fn reset_value() -> Self::Ux {
0
}
}