#[doc = "Register `DMAINTEN` reader"]
pub struct R(crate::R<DMAINTEN_SPEC>);
impl core::ops::Deref for R {
type Target = crate::R<DMAINTEN_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::convert::From<crate::R<DMAINTEN_SPEC>> for R {
fn from(reader: crate::R<DMAINTEN_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `DMAINTEN` writer"]
pub struct W(crate::W<DMAINTEN_SPEC>);
impl core::ops::Deref for W {
type Target = crate::W<DMAINTEN_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 core::convert::From<crate::W<DMAINTEN_SPEC>> for W {
fn from(writer: crate::W<DMAINTEN_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Trigger DMA request enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TRGDEN_A {
#[doc = "0: Trigger DMA request disabled"]
DISABLED = 0,
#[doc = "1: Trigger DMA request enabled"]
ENABLED = 1,
}
impl From<TRGDEN_A> for bool {
#[inline(always)]
fn from(variant: TRGDEN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `TRGDEN` reader - Trigger DMA request enable"]
pub struct TRGDEN_R(crate::FieldReader<bool, TRGDEN_A>);
impl TRGDEN_R {
pub(crate) fn new(bits: bool) -> Self {
TRGDEN_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> TRGDEN_A {
match self.bits {
false => TRGDEN_A::DISABLED,
true => TRGDEN_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == TRGDEN_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == TRGDEN_A::ENABLED
}
}
impl core::ops::Deref for TRGDEN_R {
type Target = crate::FieldReader<bool, TRGDEN_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `TRGDEN` writer - Trigger DMA request enable"]
pub struct TRGDEN_W<'a> {
w: &'a mut W,
}
impl<'a> TRGDEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: TRGDEN_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Trigger DMA request disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(TRGDEN_A::DISABLED)
}
#[doc = "Trigger DMA request enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(TRGDEN_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 << 14)) | ((value as u16 & 0x01) << 14);
self.w
}
}
#[doc = "CMT DMA request enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CMTDEN_A {
#[doc = "0: Commutation DMA request disabled"]
DISABLED = 0,
#[doc = "1: Commutation DMA request enabled"]
ENABLED = 1,
}
impl From<CMTDEN_A> for bool {
#[inline(always)]
fn from(variant: CMTDEN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `CMTDEN` reader - CMT DMA request enable"]
pub struct CMTDEN_R(crate::FieldReader<bool, CMTDEN_A>);
impl CMTDEN_R {
pub(crate) fn new(bits: bool) -> Self {
CMTDEN_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CMTDEN_A {
match self.bits {
false => CMTDEN_A::DISABLED,
true => CMTDEN_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == CMTDEN_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == CMTDEN_A::ENABLED
}
}
impl core::ops::Deref for CMTDEN_R {
type Target = crate::FieldReader<bool, CMTDEN_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `CMTDEN` writer - CMT DMA request enable"]
pub struct CMTDEN_W<'a> {
w: &'a mut W,
}
impl<'a> CMTDEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CMTDEN_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Commutation DMA request disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(CMTDEN_A::DISABLED)
}
#[doc = "Commutation DMA request enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(CMTDEN_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 << 13)) | ((value as u16 & 0x01) << 13);
self.w
}
}
#[doc = "Channel 3 Capture/Compare DMA request enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CH3DEN_A {
#[doc = "0: Capture/compare DMA request disabled"]
DISABLED = 0,
#[doc = "1: Capture/compare DMA request enabled"]
ENABLED = 1,
}
impl From<CH3DEN_A> for bool {
#[inline(always)]
fn from(variant: CH3DEN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `CH3DEN` reader - Channel 3 Capture/Compare DMA request enable"]
pub struct CH3DEN_R(crate::FieldReader<bool, CH3DEN_A>);
impl CH3DEN_R {
pub(crate) fn new(bits: bool) -> Self {
CH3DEN_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CH3DEN_A {
match self.bits {
false => CH3DEN_A::DISABLED,
true => CH3DEN_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == CH3DEN_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == CH3DEN_A::ENABLED
}
}
impl core::ops::Deref for CH3DEN_R {
type Target = crate::FieldReader<bool, CH3DEN_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `CH3DEN` writer - Channel 3 Capture/Compare DMA request enable"]
pub struct CH3DEN_W<'a> {
w: &'a mut W,
}
impl<'a> CH3DEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CH3DEN_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Capture/compare DMA request disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(CH3DEN_A::DISABLED)
}
#[doc = "Capture/compare DMA request enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(CH3DEN_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 << 12)) | ((value as u16 & 0x01) << 12);
self.w
}
}
#[doc = "Channel 2 Capture/Compare DMA request enable"]
pub type CH2DEN_A = CH3DEN_A;
#[doc = "Field `CH2DEN` reader - Channel 2 Capture/Compare DMA request enable"]
pub type CH2DEN_R = CH3DEN_R;
#[doc = "Field `CH2DEN` writer - Channel 2 Capture/Compare DMA request enable"]
pub struct CH2DEN_W<'a> {
w: &'a mut W,
}
impl<'a> CH2DEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CH2DEN_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Capture/compare DMA request disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(CH2DEN_A::DISABLED)
}
#[doc = "Capture/compare DMA request enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(CH2DEN_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 << 11)) | ((value as u16 & 0x01) << 11);
self.w
}
}
#[doc = "Channel 1 Capture/Compare DMA request enable"]
pub type CH1DEN_A = CH3DEN_A;
#[doc = "Field `CH1DEN` reader - Channel 1 Capture/Compare DMA request enable"]
pub type CH1DEN_R = CH3DEN_R;
#[doc = "Field `CH1DEN` writer - Channel 1 Capture/Compare DMA request enable"]
pub struct CH1DEN_W<'a> {
w: &'a mut W,
}
impl<'a> CH1DEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CH1DEN_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Capture/compare DMA request disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(CH1DEN_A::DISABLED)
}
#[doc = "Capture/compare DMA request enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(CH1DEN_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 u16 & 0x01) << 10);
self.w
}
}
#[doc = "Channel 0 Capture/Compare DMA request enable"]
pub type CH0DEN_A = CH3DEN_A;
#[doc = "Field `CH0DEN` reader - Channel 0 Capture/Compare DMA request enable"]
pub type CH0DEN_R = CH3DEN_R;
#[doc = "Field `CH0DEN` writer - Channel 0 Capture/Compare DMA request enable"]
pub struct CH0DEN_W<'a> {
w: &'a mut W,
}
impl<'a> CH0DEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CH0DEN_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Capture/compare DMA request disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(CH0DEN_A::DISABLED)
}
#[doc = "Capture/compare DMA request enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(CH0DEN_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 u16 & 0x01) << 9);
self.w
}
}
#[doc = "Update DMA request enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum UPDEN_A {
#[doc = "0: Update DMA request disabled"]
DISABLED = 0,
#[doc = "1: Update DMA request enabled"]
ENABLED = 1,
}
impl From<UPDEN_A> for bool {
#[inline(always)]
fn from(variant: UPDEN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `UPDEN` reader - Update DMA request enable"]
pub struct UPDEN_R(crate::FieldReader<bool, UPDEN_A>);
impl UPDEN_R {
pub(crate) fn new(bits: bool) -> Self {
UPDEN_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> UPDEN_A {
match self.bits {
false => UPDEN_A::DISABLED,
true => UPDEN_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == UPDEN_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == UPDEN_A::ENABLED
}
}
impl core::ops::Deref for UPDEN_R {
type Target = crate::FieldReader<bool, UPDEN_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `UPDEN` writer - Update DMA request enable"]
pub struct UPDEN_W<'a> {
w: &'a mut W,
}
impl<'a> UPDEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: UPDEN_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Update DMA request disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(UPDEN_A::DISABLED)
}
#[doc = "Update DMA request enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(UPDEN_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 u16 & 0x01) << 8);
self.w
}
}
#[doc = "Break interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum BRKIE_A {
#[doc = "0: Break interrupt disabled"]
DISABLED = 0,
#[doc = "1: Break interrupt enabled"]
ENABLED = 1,
}
impl From<BRKIE_A> for bool {
#[inline(always)]
fn from(variant: BRKIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `BRKIE` reader - Break interrupt enable"]
pub struct BRKIE_R(crate::FieldReader<bool, BRKIE_A>);
impl BRKIE_R {
pub(crate) fn new(bits: bool) -> Self {
BRKIE_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> BRKIE_A {
match self.bits {
false => BRKIE_A::DISABLED,
true => BRKIE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == BRKIE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == BRKIE_A::ENABLED
}
}
impl core::ops::Deref for BRKIE_R {
type Target = crate::FieldReader<bool, BRKIE_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `BRKIE` writer - Break interrupt enable"]
pub struct BRKIE_W<'a> {
w: &'a mut W,
}
impl<'a> BRKIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: BRKIE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Break interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(BRKIE_A::DISABLED)
}
#[doc = "Break interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(BRKIE_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 u16 & 0x01) << 7);
self.w
}
}
#[doc = "Trigger interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TRGIE_A {
#[doc = "0: Trigger interrupt disabled"]
DISABLED = 0,
#[doc = "1: Trigger interrupt enabled"]
ENABLED = 1,
}
impl From<TRGIE_A> for bool {
#[inline(always)]
fn from(variant: TRGIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `TRGIE` reader - Trigger interrupt enable"]
pub struct TRGIE_R(crate::FieldReader<bool, TRGIE_A>);
impl TRGIE_R {
pub(crate) fn new(bits: bool) -> Self {
TRGIE_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> TRGIE_A {
match self.bits {
false => TRGIE_A::DISABLED,
true => TRGIE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == TRGIE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == TRGIE_A::ENABLED
}
}
impl core::ops::Deref for TRGIE_R {
type Target = crate::FieldReader<bool, TRGIE_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `TRGIE` writer - Trigger interrupt enable"]
pub struct TRGIE_W<'a> {
w: &'a mut W,
}
impl<'a> TRGIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: TRGIE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Trigger interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(TRGIE_A::DISABLED)
}
#[doc = "Trigger interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(TRGIE_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 u16 & 0x01) << 6);
self.w
}
}
#[doc = "CMT interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CMTIE_A {
#[doc = "0: Commutation interrupt disabled"]
DISABLED = 0,
#[doc = "1: Commutation interrupt enabled"]
ENABLED = 1,
}
impl From<CMTIE_A> for bool {
#[inline(always)]
fn from(variant: CMTIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `CMTIE` reader - CMT interrupt enable"]
pub struct CMTIE_R(crate::FieldReader<bool, CMTIE_A>);
impl CMTIE_R {
pub(crate) fn new(bits: bool) -> Self {
CMTIE_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CMTIE_A {
match self.bits {
false => CMTIE_A::DISABLED,
true => CMTIE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == CMTIE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == CMTIE_A::ENABLED
}
}
impl core::ops::Deref for CMTIE_R {
type Target = crate::FieldReader<bool, CMTIE_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `CMTIE` writer - CMT interrupt enable"]
pub struct CMTIE_W<'a> {
w: &'a mut W,
}
impl<'a> CMTIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CMTIE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Commutation interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(CMTIE_A::DISABLED)
}
#[doc = "Commutation interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(CMTIE_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 u16 & 0x01) << 5);
self.w
}
}
#[doc = "Channel 3 Capture/Compare interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CH3IE_A {
#[doc = "0: Capture/compare interrupt disabled"]
DISABLED = 0,
#[doc = "1: Capture/compare interrupt enabled"]
ENABLED = 1,
}
impl From<CH3IE_A> for bool {
#[inline(always)]
fn from(variant: CH3IE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `CH3IE` reader - Channel 3 Capture/Compare interrupt enable"]
pub struct CH3IE_R(crate::FieldReader<bool, CH3IE_A>);
impl CH3IE_R {
pub(crate) fn new(bits: bool) -> Self {
CH3IE_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CH3IE_A {
match self.bits {
false => CH3IE_A::DISABLED,
true => CH3IE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == CH3IE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == CH3IE_A::ENABLED
}
}
impl core::ops::Deref for CH3IE_R {
type Target = crate::FieldReader<bool, CH3IE_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `CH3IE` writer - Channel 3 Capture/Compare interrupt enable"]
pub struct CH3IE_W<'a> {
w: &'a mut W,
}
impl<'a> CH3IE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CH3IE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Capture/compare interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(CH3IE_A::DISABLED)
}
#[doc = "Capture/compare interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(CH3IE_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 u16 & 0x01) << 4);
self.w
}
}
#[doc = "Channel 2 Capture/Compare interrupt enable"]
pub type CH2IE_A = CH3IE_A;
#[doc = "Field `CH2IE` reader - Channel 2 Capture/Compare interrupt enable"]
pub type CH2IE_R = CH3IE_R;
#[doc = "Field `CH2IE` writer - Channel 2 Capture/Compare interrupt enable"]
pub struct CH2IE_W<'a> {
w: &'a mut W,
}
impl<'a> CH2IE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CH2IE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Capture/compare interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(CH2IE_A::DISABLED)
}
#[doc = "Capture/compare interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(CH2IE_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 u16 & 0x01) << 3);
self.w
}
}
#[doc = "Channel 1 Capture/Compare interrupt enable"]
pub type CH1IE_A = CH3IE_A;
#[doc = "Field `CH1IE` reader - Channel 1 Capture/Compare interrupt enable"]
pub type CH1IE_R = CH3IE_R;
#[doc = "Field `CH1IE` writer - Channel 1 Capture/Compare interrupt enable"]
pub struct CH1IE_W<'a> {
w: &'a mut W,
}
impl<'a> CH1IE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CH1IE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Capture/compare interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(CH1IE_A::DISABLED)
}
#[doc = "Capture/compare interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(CH1IE_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 u16 & 0x01) << 2);
self.w
}
}
#[doc = "Channel 0 Capture/Compare interrupt enable"]
pub type CH0IE_A = CH3IE_A;
#[doc = "Field `CH0IE` reader - Channel 0 Capture/Compare interrupt enable"]
pub type CH0IE_R = CH3IE_R;
#[doc = "Field `CH0IE` writer - Channel 0 Capture/Compare interrupt enable"]
pub struct CH0IE_W<'a> {
w: &'a mut W,
}
impl<'a> CH0IE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CH0IE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Capture/compare interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(CH0IE_A::DISABLED)
}
#[doc = "Capture/compare interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(CH0IE_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 u16 & 0x01) << 1);
self.w
}
}
#[doc = "Update interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum UPIE_A {
#[doc = "0: Update interrupt disabled"]
DISABLED = 0,
#[doc = "1: Update interrupt enabled"]
ENABLED = 1,
}
impl From<UPIE_A> for bool {
#[inline(always)]
fn from(variant: UPIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `UPIE` reader - Update interrupt enable"]
pub struct UPIE_R(crate::FieldReader<bool, UPIE_A>);
impl UPIE_R {
pub(crate) fn new(bits: bool) -> Self {
UPIE_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> UPIE_A {
match self.bits {
false => UPIE_A::DISABLED,
true => UPIE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == UPIE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == UPIE_A::ENABLED
}
}
impl core::ops::Deref for UPIE_R {
type Target = crate::FieldReader<bool, UPIE_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `UPIE` writer - Update interrupt enable"]
pub struct UPIE_W<'a> {
w: &'a mut W,
}
impl<'a> UPIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: UPIE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Update interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(UPIE_A::DISABLED)
}
#[doc = "Update interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(UPIE_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 u16 & 0x01);
self.w
}
}
impl R {
#[doc = "Bit 14 - Trigger DMA request enable"]
#[inline(always)]
pub fn trgden(&self) -> TRGDEN_R {
TRGDEN_R::new(((self.bits >> 14) & 0x01) != 0)
}
#[doc = "Bit 13 - CMT DMA request enable"]
#[inline(always)]
pub fn cmtden(&self) -> CMTDEN_R {
CMTDEN_R::new(((self.bits >> 13) & 0x01) != 0)
}
#[doc = "Bit 12 - Channel 3 Capture/Compare DMA request enable"]
#[inline(always)]
pub fn ch3den(&self) -> CH3DEN_R {
CH3DEN_R::new(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 11 - Channel 2 Capture/Compare DMA request enable"]
#[inline(always)]
pub fn ch2den(&self) -> CH2DEN_R {
CH2DEN_R::new(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bit 10 - Channel 1 Capture/Compare DMA request enable"]
#[inline(always)]
pub fn ch1den(&self) -> CH1DEN_R {
CH1DEN_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 9 - Channel 0 Capture/Compare DMA request enable"]
#[inline(always)]
pub fn ch0den(&self) -> CH0DEN_R {
CH0DEN_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 8 - Update DMA request enable"]
#[inline(always)]
pub fn upden(&self) -> UPDEN_R {
UPDEN_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 7 - Break interrupt enable"]
#[inline(always)]
pub fn brkie(&self) -> BRKIE_R {
BRKIE_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 6 - Trigger interrupt enable"]
#[inline(always)]
pub fn trgie(&self) -> TRGIE_R {
TRGIE_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 5 - CMT interrupt enable"]
#[inline(always)]
pub fn cmtie(&self) -> CMTIE_R {
CMTIE_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 4 - Channel 3 Capture/Compare interrupt enable"]
#[inline(always)]
pub fn ch3ie(&self) -> CH3IE_R {
CH3IE_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 3 - Channel 2 Capture/Compare interrupt enable"]
#[inline(always)]
pub fn ch2ie(&self) -> CH2IE_R {
CH2IE_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 2 - Channel 1 Capture/Compare interrupt enable"]
#[inline(always)]
pub fn ch1ie(&self) -> CH1IE_R {
CH1IE_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 1 - Channel 0 Capture/Compare interrupt enable"]
#[inline(always)]
pub fn ch0ie(&self) -> CH0IE_R {
CH0IE_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 0 - Update interrupt enable"]
#[inline(always)]
pub fn upie(&self) -> UPIE_R {
UPIE_R::new((self.bits & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 14 - Trigger DMA request enable"]
#[inline(always)]
pub fn trgden(&mut self) -> TRGDEN_W {
TRGDEN_W { w: self }
}
#[doc = "Bit 13 - CMT DMA request enable"]
#[inline(always)]
pub fn cmtden(&mut self) -> CMTDEN_W {
CMTDEN_W { w: self }
}
#[doc = "Bit 12 - Channel 3 Capture/Compare DMA request enable"]
#[inline(always)]
pub fn ch3den(&mut self) -> CH3DEN_W {
CH3DEN_W { w: self }
}
#[doc = "Bit 11 - Channel 2 Capture/Compare DMA request enable"]
#[inline(always)]
pub fn ch2den(&mut self) -> CH2DEN_W {
CH2DEN_W { w: self }
}
#[doc = "Bit 10 - Channel 1 Capture/Compare DMA request enable"]
#[inline(always)]
pub fn ch1den(&mut self) -> CH1DEN_W {
CH1DEN_W { w: self }
}
#[doc = "Bit 9 - Channel 0 Capture/Compare DMA request enable"]
#[inline(always)]
pub fn ch0den(&mut self) -> CH0DEN_W {
CH0DEN_W { w: self }
}
#[doc = "Bit 8 - Update DMA request enable"]
#[inline(always)]
pub fn upden(&mut self) -> UPDEN_W {
UPDEN_W { w: self }
}
#[doc = "Bit 7 - Break interrupt enable"]
#[inline(always)]
pub fn brkie(&mut self) -> BRKIE_W {
BRKIE_W { w: self }
}
#[doc = "Bit 6 - Trigger interrupt enable"]
#[inline(always)]
pub fn trgie(&mut self) -> TRGIE_W {
TRGIE_W { w: self }
}
#[doc = "Bit 5 - CMT interrupt enable"]
#[inline(always)]
pub fn cmtie(&mut self) -> CMTIE_W {
CMTIE_W { w: self }
}
#[doc = "Bit 4 - Channel 3 Capture/Compare interrupt enable"]
#[inline(always)]
pub fn ch3ie(&mut self) -> CH3IE_W {
CH3IE_W { w: self }
}
#[doc = "Bit 3 - Channel 2 Capture/Compare interrupt enable"]
#[inline(always)]
pub fn ch2ie(&mut self) -> CH2IE_W {
CH2IE_W { w: self }
}
#[doc = "Bit 2 - Channel 1 Capture/Compare interrupt enable"]
#[inline(always)]
pub fn ch1ie(&mut self) -> CH1IE_W {
CH1IE_W { w: self }
}
#[doc = "Bit 1 - Channel 0 Capture/Compare interrupt enable"]
#[inline(always)]
pub fn ch0ie(&mut self) -> CH0IE_W {
CH0IE_W { w: self }
}
#[doc = "Bit 0 - Update interrupt enable"]
#[inline(always)]
pub fn upie(&mut self) -> UPIE_W {
UPIE_W { w: self }
}
#[doc = "Writes raw bits to the register."]
pub unsafe fn bits(&mut self, bits: u16) -> &mut Self {
self.0.bits(bits);
self
}
}
#[doc = "DMA/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 [dmainten](index.html) module"]
pub struct DMAINTEN_SPEC;
impl crate::RegisterSpec for DMAINTEN_SPEC {
type Ux = u16;
}
#[doc = "`read()` method returns [dmainten::R](R) reader structure"]
impl crate::Readable for DMAINTEN_SPEC {
type Reader = R;
}
#[doc = "`write(|w| ..)` method takes [dmainten::W](W) writer structure"]
impl crate::Writable for DMAINTEN_SPEC {
type Writer = W;
}
#[doc = "`reset()` method sets DMAINTEN to value 0"]
impl crate::Resettable for DMAINTEN_SPEC {
#[inline(always)]
fn reset_value() -> Self::Ux {
0
}
}