#[doc = "Reader of register SMINTEN"]
pub type R = crate::R<u16, super::SMINTEN>;
#[doc = "Writer for register SMINTEN"]
pub type W = crate::W<u16, super::SMINTEN>;
#[doc = "Register SMINTEN `reset()`'s with value 0"]
impl crate::ResetValue for super::SMINTEN {
type Type = u16;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Compare Interrupt Enables\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum CMPIE_A {
#[doc = "0: The corresponding STS\\[CMPF\\]
bit will not cause an interrupt request."]
CMPIE_0 = 0,
#[doc = "1: The corresponding STS\\[CMPF\\]
bit will cause an interrupt request."]
CMPIE_1 = 1,
}
impl From<CMPIE_A> for u8 {
#[inline(always)]
fn from(variant: CMPIE_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `CMPIE`"]
pub type CMPIE_R = crate::R<u8, CMPIE_A>;
impl CMPIE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<u8, CMPIE_A> {
use crate::Variant::*;
match self.bits {
0 => Val(CMPIE_A::CMPIE_0),
1 => Val(CMPIE_A::CMPIE_1),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `CMPIE_0`"]
#[inline(always)]
pub fn is_cmpie_0(&self) -> bool {
*self == CMPIE_A::CMPIE_0
}
#[doc = "Checks if the value of the field is `CMPIE_1`"]
#[inline(always)]
pub fn is_cmpie_1(&self) -> bool {
*self == CMPIE_A::CMPIE_1
}
}
#[doc = "Write proxy for field `CMPIE`"]
pub struct CMPIE_W<'a> {
w: &'a mut W,
}
impl<'a> CMPIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CMPIE_A) -> &'a mut W {
unsafe { self.bits(variant.into()) }
}
#[doc = "The corresponding STS\\[CMPF\\]
bit will not cause an interrupt request."]
#[inline(always)]
pub fn cmpie_0(self) -> &'a mut W {
self.variant(CMPIE_A::CMPIE_0)
}
#[doc = "The corresponding STS\\[CMPF\\]
bit will cause an interrupt request."]
#[inline(always)]
pub fn cmpie_1(self) -> &'a mut W {
self.variant(CMPIE_A::CMPIE_1)
}
#[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 & !0x3f) | ((value as u16) & 0x3f);
self.w
}
}
#[doc = "Capture X 0 Interrupt Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CX0IE_A {
#[doc = "0: Interrupt request disabled for STS\\[CFX0\\]."]
CX0IE_0 = 0,
#[doc = "1: Interrupt request enabled for STS\\[CFX0\\]."]
CX0IE_1 = 1,
}
impl From<CX0IE_A> for bool {
#[inline(always)]
fn from(variant: CX0IE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `CX0IE`"]
pub type CX0IE_R = crate::R<bool, CX0IE_A>;
impl CX0IE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CX0IE_A {
match self.bits {
false => CX0IE_A::CX0IE_0,
true => CX0IE_A::CX0IE_1,
}
}
#[doc = "Checks if the value of the field is `CX0IE_0`"]
#[inline(always)]
pub fn is_cx0ie_0(&self) -> bool {
*self == CX0IE_A::CX0IE_0
}
#[doc = "Checks if the value of the field is `CX0IE_1`"]
#[inline(always)]
pub fn is_cx0ie_1(&self) -> bool {
*self == CX0IE_A::CX0IE_1
}
}
#[doc = "Write proxy for field `CX0IE`"]
pub struct CX0IE_W<'a> {
w: &'a mut W,
}
impl<'a> CX0IE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CX0IE_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Interrupt request disabled for STS\\[CFX0\\]."]
#[inline(always)]
pub fn cx0ie_0(self) -> &'a mut W {
self.variant(CX0IE_A::CX0IE_0)
}
#[doc = "Interrupt request enabled for STS\\[CFX0\\]."]
#[inline(always)]
pub fn cx0ie_1(self) -> &'a mut W {
self.variant(CX0IE_A::CX0IE_1)
}
#[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 = "Capture X 1 Interrupt Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CX1IE_A {
#[doc = "0: Interrupt request disabled for STS\\[CFX1\\]."]
CX1IE_0 = 0,
#[doc = "1: Interrupt request enabled for STS\\[CFX1\\]."]
CX1IE_1 = 1,
}
impl From<CX1IE_A> for bool {
#[inline(always)]
fn from(variant: CX1IE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `CX1IE`"]
pub type CX1IE_R = crate::R<bool, CX1IE_A>;
impl CX1IE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CX1IE_A {
match self.bits {
false => CX1IE_A::CX1IE_0,
true => CX1IE_A::CX1IE_1,
}
}
#[doc = "Checks if the value of the field is `CX1IE_0`"]
#[inline(always)]
pub fn is_cx1ie_0(&self) -> bool {
*self == CX1IE_A::CX1IE_0
}
#[doc = "Checks if the value of the field is `CX1IE_1`"]
#[inline(always)]
pub fn is_cx1ie_1(&self) -> bool {
*self == CX1IE_A::CX1IE_1
}
}
#[doc = "Write proxy for field `CX1IE`"]
pub struct CX1IE_W<'a> {
w: &'a mut W,
}
impl<'a> CX1IE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CX1IE_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Interrupt request disabled for STS\\[CFX1\\]."]
#[inline(always)]
pub fn cx1ie_0(self) -> &'a mut W {
self.variant(CX1IE_A::CX1IE_0)
}
#[doc = "Interrupt request enabled for STS\\[CFX1\\]."]
#[inline(always)]
pub fn cx1ie_1(self) -> &'a mut W {
self.variant(CX1IE_A::CX1IE_1)
}
#[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 = "Capture B 0 Interrupt Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CB0IE_A {
#[doc = "0: Interrupt request disabled for STS\\[CFB0\\]."]
CB0IE_0 = 0,
#[doc = "1: Interrupt request enabled for STS\\[CFB0\\]."]
CB0IE_1 = 1,
}
impl From<CB0IE_A> for bool {
#[inline(always)]
fn from(variant: CB0IE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `CB0IE`"]
pub type CB0IE_R = crate::R<bool, CB0IE_A>;
impl CB0IE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CB0IE_A {
match self.bits {
false => CB0IE_A::CB0IE_0,
true => CB0IE_A::CB0IE_1,
}
}
#[doc = "Checks if the value of the field is `CB0IE_0`"]
#[inline(always)]
pub fn is_cb0ie_0(&self) -> bool {
*self == CB0IE_A::CB0IE_0
}
#[doc = "Checks if the value of the field is `CB0IE_1`"]
#[inline(always)]
pub fn is_cb0ie_1(&self) -> bool {
*self == CB0IE_A::CB0IE_1
}
}
#[doc = "Write proxy for field `CB0IE`"]
pub struct CB0IE_W<'a> {
w: &'a mut W,
}
impl<'a> CB0IE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CB0IE_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Interrupt request disabled for STS\\[CFB0\\]."]
#[inline(always)]
pub fn cb0ie_0(self) -> &'a mut W {
self.variant(CB0IE_A::CB0IE_0)
}
#[doc = "Interrupt request enabled for STS\\[CFB0\\]."]
#[inline(always)]
pub fn cb0ie_1(self) -> &'a mut W {
self.variant(CB0IE_A::CB0IE_1)
}
#[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 = "Capture B 1 Interrupt Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CB1IE_A {
#[doc = "0: Interrupt request disabled for STS\\[CFB1\\]."]
CB1IE_0 = 0,
#[doc = "1: Interrupt request enabled for STS\\[CFB1\\]."]
CB1IE_1 = 1,
}
impl From<CB1IE_A> for bool {
#[inline(always)]
fn from(variant: CB1IE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `CB1IE`"]
pub type CB1IE_R = crate::R<bool, CB1IE_A>;
impl CB1IE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CB1IE_A {
match self.bits {
false => CB1IE_A::CB1IE_0,
true => CB1IE_A::CB1IE_1,
}
}
#[doc = "Checks if the value of the field is `CB1IE_0`"]
#[inline(always)]
pub fn is_cb1ie_0(&self) -> bool {
*self == CB1IE_A::CB1IE_0
}
#[doc = "Checks if the value of the field is `CB1IE_1`"]
#[inline(always)]
pub fn is_cb1ie_1(&self) -> bool {
*self == CB1IE_A::CB1IE_1
}
}
#[doc = "Write proxy for field `CB1IE`"]
pub struct CB1IE_W<'a> {
w: &'a mut W,
}
impl<'a> CB1IE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CB1IE_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Interrupt request disabled for STS\\[CFB1\\]."]
#[inline(always)]
pub fn cb1ie_0(self) -> &'a mut W {
self.variant(CB1IE_A::CB1IE_0)
}
#[doc = "Interrupt request enabled for STS\\[CFB1\\]."]
#[inline(always)]
pub fn cb1ie_1(self) -> &'a mut W {
self.variant(CB1IE_A::CB1IE_1)
}
#[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 = "Capture A 0 Interrupt Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CA0IE_A {
#[doc = "0: Interrupt request disabled for STS\\[CFA0\\]."]
CA0IE_0 = 0,
#[doc = "1: Interrupt request enabled for STS\\[CFA0\\]."]
CA0IE_1 = 1,
}
impl From<CA0IE_A> for bool {
#[inline(always)]
fn from(variant: CA0IE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `CA0IE`"]
pub type CA0IE_R = crate::R<bool, CA0IE_A>;
impl CA0IE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CA0IE_A {
match self.bits {
false => CA0IE_A::CA0IE_0,
true => CA0IE_A::CA0IE_1,
}
}
#[doc = "Checks if the value of the field is `CA0IE_0`"]
#[inline(always)]
pub fn is_ca0ie_0(&self) -> bool {
*self == CA0IE_A::CA0IE_0
}
#[doc = "Checks if the value of the field is `CA0IE_1`"]
#[inline(always)]
pub fn is_ca0ie_1(&self) -> bool {
*self == CA0IE_A::CA0IE_1
}
}
#[doc = "Write proxy for field `CA0IE`"]
pub struct CA0IE_W<'a> {
w: &'a mut W,
}
impl<'a> CA0IE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CA0IE_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Interrupt request disabled for STS\\[CFA0\\]."]
#[inline(always)]
pub fn ca0ie_0(self) -> &'a mut W {
self.variant(CA0IE_A::CA0IE_0)
}
#[doc = "Interrupt request enabled for STS\\[CFA0\\]."]
#[inline(always)]
pub fn ca0ie_1(self) -> &'a mut W {
self.variant(CA0IE_A::CA0IE_1)
}
#[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 = "Capture A 1 Interrupt Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CA1IE_A {
#[doc = "0: Interrupt request disabled for STS\\[CFA1\\]."]
CA1IE_0 = 0,
#[doc = "1: Interrupt request enabled for STS\\[CFA1\\]."]
CA1IE_1 = 1,
}
impl From<CA1IE_A> for bool {
#[inline(always)]
fn from(variant: CA1IE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `CA1IE`"]
pub type CA1IE_R = crate::R<bool, CA1IE_A>;
impl CA1IE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CA1IE_A {
match self.bits {
false => CA1IE_A::CA1IE_0,
true => CA1IE_A::CA1IE_1,
}
}
#[doc = "Checks if the value of the field is `CA1IE_0`"]
#[inline(always)]
pub fn is_ca1ie_0(&self) -> bool {
*self == CA1IE_A::CA1IE_0
}
#[doc = "Checks if the value of the field is `CA1IE_1`"]
#[inline(always)]
pub fn is_ca1ie_1(&self) -> bool {
*self == CA1IE_A::CA1IE_1
}
}
#[doc = "Write proxy for field `CA1IE`"]
pub struct CA1IE_W<'a> {
w: &'a mut W,
}
impl<'a> CA1IE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CA1IE_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Interrupt request disabled for STS\\[CFA1\\]."]
#[inline(always)]
pub fn ca1ie_0(self) -> &'a mut W {
self.variant(CA1IE_A::CA1IE_0)
}
#[doc = "Interrupt request enabled for STS\\[CFA1\\]."]
#[inline(always)]
pub fn ca1ie_1(self) -> &'a mut W {
self.variant(CA1IE_A::CA1IE_1)
}
#[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 = "Reload Interrupt Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RIE_A {
#[doc = "0: STS\\[RF\\]
CPU interrupt requests disabled"]
RIE_0 = 0,
#[doc = "1: STS\\[RF\\]
CPU interrupt requests enabled"]
RIE_1 = 1,
}
impl From<RIE_A> for bool {
#[inline(always)]
fn from(variant: RIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `RIE`"]
pub type RIE_R = crate::R<bool, RIE_A>;
impl RIE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> RIE_A {
match self.bits {
false => RIE_A::RIE_0,
true => RIE_A::RIE_1,
}
}
#[doc = "Checks if the value of the field is `RIE_0`"]
#[inline(always)]
pub fn is_rie_0(&self) -> bool {
*self == RIE_A::RIE_0
}
#[doc = "Checks if the value of the field is `RIE_1`"]
#[inline(always)]
pub fn is_rie_1(&self) -> bool {
*self == RIE_A::RIE_1
}
}
#[doc = "Write proxy for field `RIE`"]
pub struct RIE_W<'a> {
w: &'a mut W,
}
impl<'a> RIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: RIE_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "STS\\[RF\\]
CPU interrupt requests disabled"]
#[inline(always)]
pub fn rie_0(self) -> &'a mut W {
self.variant(RIE_A::RIE_0)
}
#[doc = "STS\\[RF\\]
CPU interrupt requests enabled"]
#[inline(always)]
pub fn rie_1(self) -> &'a mut W {
self.variant(RIE_A::RIE_1)
}
#[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 = "Reload Error Interrupt Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum REIE_A {
#[doc = "0: STS\\[REF\\]
CPU interrupt requests disabled"]
REIE_0 = 0,
#[doc = "1: STS\\[REF\\]
CPU interrupt requests enabled"]
REIE_1 = 1,
}
impl From<REIE_A> for bool {
#[inline(always)]
fn from(variant: REIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `REIE`"]
pub type REIE_R = crate::R<bool, REIE_A>;
impl REIE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> REIE_A {
match self.bits {
false => REIE_A::REIE_0,
true => REIE_A::REIE_1,
}
}
#[doc = "Checks if the value of the field is `REIE_0`"]
#[inline(always)]
pub fn is_reie_0(&self) -> bool {
*self == REIE_A::REIE_0
}
#[doc = "Checks if the value of the field is `REIE_1`"]
#[inline(always)]
pub fn is_reie_1(&self) -> bool {
*self == REIE_A::REIE_1
}
}
#[doc = "Write proxy for field `REIE`"]
pub struct REIE_W<'a> {
w: &'a mut W,
}
impl<'a> REIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: REIE_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "STS\\[REF\\]
CPU interrupt requests disabled"]
#[inline(always)]
pub fn reie_0(self) -> &'a mut W {
self.variant(REIE_A::REIE_0)
}
#[doc = "STS\\[REF\\]
CPU interrupt requests enabled"]
#[inline(always)]
pub fn reie_1(self) -> &'a mut W {
self.variant(REIE_A::REIE_1)
}
#[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
}
}
impl R {
#[doc = "Bits 0:5 - Compare Interrupt Enables"]
#[inline(always)]
pub fn cmpie(&self) -> CMPIE_R {
CMPIE_R::new((self.bits & 0x3f) as u8)
}
#[doc = "Bit 6 - Capture X 0 Interrupt Enable"]
#[inline(always)]
pub fn cx0ie(&self) -> CX0IE_R {
CX0IE_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 7 - Capture X 1 Interrupt Enable"]
#[inline(always)]
pub fn cx1ie(&self) -> CX1IE_R {
CX1IE_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 8 - Capture B 0 Interrupt Enable"]
#[inline(always)]
pub fn cb0ie(&self) -> CB0IE_R {
CB0IE_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 9 - Capture B 1 Interrupt Enable"]
#[inline(always)]
pub fn cb1ie(&self) -> CB1IE_R {
CB1IE_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 10 - Capture A 0 Interrupt Enable"]
#[inline(always)]
pub fn ca0ie(&self) -> CA0IE_R {
CA0IE_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 11 - Capture A 1 Interrupt Enable"]
#[inline(always)]
pub fn ca1ie(&self) -> CA1IE_R {
CA1IE_R::new(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bit 12 - Reload Interrupt Enable"]
#[inline(always)]
pub fn rie(&self) -> RIE_R {
RIE_R::new(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 13 - Reload Error Interrupt Enable"]
#[inline(always)]
pub fn reie(&self) -> REIE_R {
REIE_R::new(((self.bits >> 13) & 0x01) != 0)
}
}
impl W {
#[doc = "Bits 0:5 - Compare Interrupt Enables"]
#[inline(always)]
pub fn cmpie(&mut self) -> CMPIE_W {
CMPIE_W { w: self }
}
#[doc = "Bit 6 - Capture X 0 Interrupt Enable"]
#[inline(always)]
pub fn cx0ie(&mut self) -> CX0IE_W {
CX0IE_W { w: self }
}
#[doc = "Bit 7 - Capture X 1 Interrupt Enable"]
#[inline(always)]
pub fn cx1ie(&mut self) -> CX1IE_W {
CX1IE_W { w: self }
}
#[doc = "Bit 8 - Capture B 0 Interrupt Enable"]
#[inline(always)]
pub fn cb0ie(&mut self) -> CB0IE_W {
CB0IE_W { w: self }
}
#[doc = "Bit 9 - Capture B 1 Interrupt Enable"]
#[inline(always)]
pub fn cb1ie(&mut self) -> CB1IE_W {
CB1IE_W { w: self }
}
#[doc = "Bit 10 - Capture A 0 Interrupt Enable"]
#[inline(always)]
pub fn ca0ie(&mut self) -> CA0IE_W {
CA0IE_W { w: self }
}
#[doc = "Bit 11 - Capture A 1 Interrupt Enable"]
#[inline(always)]
pub fn ca1ie(&mut self) -> CA1IE_W {
CA1IE_W { w: self }
}
#[doc = "Bit 12 - Reload Interrupt Enable"]
#[inline(always)]
pub fn rie(&mut self) -> RIE_W {
RIE_W { w: self }
}
#[doc = "Bit 13 - Reload Error Interrupt Enable"]
#[inline(always)]
pub fn reie(&mut self) -> REIE_W {
REIE_W { w: self }
}
}