#[doc = "Reader of register CTRL2"]
pub type R = crate::R<u16, super::CTRL2>;
#[doc = "Writer for register CTRL2"]
pub type W = crate::W<u16, super::CTRL2>;
#[doc = "Register CTRL2 `reset()`'s with value 0"]
impl crate::ResetValue for super::CTRL2 {
type Type = u16;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Update Hold Registers\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum UPDHLD_A {
#[doc = "0: Disable updates of hold registers on rising edge of TRIGGER"]
UPDHLD_0 = 0,
#[doc = "1: Enable updates of hold registers on rising edge of TRIGGER"]
UPDHLD_1 = 1,
}
impl From<UPDHLD_A> for bool {
#[inline(always)]
fn from(variant: UPDHLD_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `UPDHLD`"]
pub type UPDHLD_R = crate::R<bool, UPDHLD_A>;
impl UPDHLD_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> UPDHLD_A {
match self.bits {
false => UPDHLD_A::UPDHLD_0,
true => UPDHLD_A::UPDHLD_1,
}
}
#[doc = "Checks if the value of the field is `UPDHLD_0`"]
#[inline(always)]
pub fn is_updhld_0(&self) -> bool {
*self == UPDHLD_A::UPDHLD_0
}
#[doc = "Checks if the value of the field is `UPDHLD_1`"]
#[inline(always)]
pub fn is_updhld_1(&self) -> bool {
*self == UPDHLD_A::UPDHLD_1
}
}
#[doc = "Write proxy for field `UPDHLD`"]
pub struct UPDHLD_W<'a> {
w: &'a mut W,
}
impl<'a> UPDHLD_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: UPDHLD_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Disable updates of hold registers on rising edge of TRIGGER"]
#[inline(always)]
pub fn updhld_0(self) -> &'a mut W {
self.variant(UPDHLD_A::UPDHLD_0)
}
#[doc = "Enable updates of hold registers on rising edge of TRIGGER"]
#[inline(always)]
pub fn updhld_1(self) -> &'a mut W {
self.variant(UPDHLD_A::UPDHLD_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) | ((value as u16) & 0x01);
self.w
}
}
#[doc = "Update Position Registers\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum UPDPOS_A {
#[doc = "0: No action for POSD, REV, UPOS and LPOS on rising edge of TRIGGER"]
UPDPOS_0 = 0,
#[doc = "1: Clear POSD, REV, UPOS and LPOS on rising edge of TRIGGER"]
UPDPOS_1 = 1,
}
impl From<UPDPOS_A> for bool {
#[inline(always)]
fn from(variant: UPDPOS_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `UPDPOS`"]
pub type UPDPOS_R = crate::R<bool, UPDPOS_A>;
impl UPDPOS_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> UPDPOS_A {
match self.bits {
false => UPDPOS_A::UPDPOS_0,
true => UPDPOS_A::UPDPOS_1,
}
}
#[doc = "Checks if the value of the field is `UPDPOS_0`"]
#[inline(always)]
pub fn is_updpos_0(&self) -> bool {
*self == UPDPOS_A::UPDPOS_0
}
#[doc = "Checks if the value of the field is `UPDPOS_1`"]
#[inline(always)]
pub fn is_updpos_1(&self) -> bool {
*self == UPDPOS_A::UPDPOS_1
}
}
#[doc = "Write proxy for field `UPDPOS`"]
pub struct UPDPOS_W<'a> {
w: &'a mut W,
}
impl<'a> UPDPOS_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: UPDPOS_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "No action for POSD, REV, UPOS and LPOS on rising edge of TRIGGER"]
#[inline(always)]
pub fn updpos_0(self) -> &'a mut W {
self.variant(UPDPOS_A::UPDPOS_0)
}
#[doc = "Clear POSD, REV, UPOS and LPOS on rising edge of TRIGGER"]
#[inline(always)]
pub fn updpos_1(self) -> &'a mut W {
self.variant(UPDPOS_A::UPDPOS_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 << 1)) | (((value as u16) & 0x01) << 1);
self.w
}
}
#[doc = "Enable Modulo Counting\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MOD_A {
#[doc = "0: Disable modulo counting"]
MOD_0 = 0,
#[doc = "1: Enable modulo counting"]
MOD_1 = 1,
}
impl From<MOD_A> for bool {
#[inline(always)]
fn from(variant: MOD_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `MOD`"]
pub type MOD_R = crate::R<bool, MOD_A>;
impl MOD_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> MOD_A {
match self.bits {
false => MOD_A::MOD_0,
true => MOD_A::MOD_1,
}
}
#[doc = "Checks if the value of the field is `MOD_0`"]
#[inline(always)]
pub fn is_mod_0(&self) -> bool {
*self == MOD_A::MOD_0
}
#[doc = "Checks if the value of the field is `MOD_1`"]
#[inline(always)]
pub fn is_mod_1(&self) -> bool {
*self == MOD_A::MOD_1
}
}
#[doc = "Write proxy for field `MOD`"]
pub struct MOD_W<'a> {
w: &'a mut W,
}
impl<'a> MOD_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MOD_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Disable modulo counting"]
#[inline(always)]
pub fn mod_0(self) -> &'a mut W {
self.variant(MOD_A::MOD_0)
}
#[doc = "Enable modulo counting"]
#[inline(always)]
pub fn mod_1(self) -> &'a mut W {
self.variant(MOD_A::MOD_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 << 2)) | (((value as u16) & 0x01) << 2);
self.w
}
}
#[doc = "Count Direction Flag\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum DIR_A {
#[doc = "0: Last count was in the down direction"]
DIR_0 = 0,
#[doc = "1: Last count was in the up direction"]
DIR_1 = 1,
}
impl From<DIR_A> for bool {
#[inline(always)]
fn from(variant: DIR_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `DIR`"]
pub type DIR_R = crate::R<bool, DIR_A>;
impl DIR_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> DIR_A {
match self.bits {
false => DIR_A::DIR_0,
true => DIR_A::DIR_1,
}
}
#[doc = "Checks if the value of the field is `DIR_0`"]
#[inline(always)]
pub fn is_dir_0(&self) -> bool {
*self == DIR_A::DIR_0
}
#[doc = "Checks if the value of the field is `DIR_1`"]
#[inline(always)]
pub fn is_dir_1(&self) -> bool {
*self == DIR_A::DIR_1
}
}
#[doc = "Roll-under Interrupt Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RUIE_A {
#[doc = "0: Roll-under interrupt is disabled"]
RUIE_0 = 0,
#[doc = "1: Roll-under interrupt is enabled"]
RUIE_1 = 1,
}
impl From<RUIE_A> for bool {
#[inline(always)]
fn from(variant: RUIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `RUIE`"]
pub type RUIE_R = crate::R<bool, RUIE_A>;
impl RUIE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> RUIE_A {
match self.bits {
false => RUIE_A::RUIE_0,
true => RUIE_A::RUIE_1,
}
}
#[doc = "Checks if the value of the field is `RUIE_0`"]
#[inline(always)]
pub fn is_ruie_0(&self) -> bool {
*self == RUIE_A::RUIE_0
}
#[doc = "Checks if the value of the field is `RUIE_1`"]
#[inline(always)]
pub fn is_ruie_1(&self) -> bool {
*self == RUIE_A::RUIE_1
}
}
#[doc = "Write proxy for field `RUIE`"]
pub struct RUIE_W<'a> {
w: &'a mut W,
}
impl<'a> RUIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: RUIE_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Roll-under interrupt is disabled"]
#[inline(always)]
pub fn ruie_0(self) -> &'a mut W {
self.variant(RUIE_A::RUIE_0)
}
#[doc = "Roll-under interrupt is enabled"]
#[inline(always)]
pub fn ruie_1(self) -> &'a mut W {
self.variant(RUIE_A::RUIE_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 << 4)) | (((value as u16) & 0x01) << 4);
self.w
}
}
#[doc = "Roll-under Interrupt Request\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RUIRQ_A {
#[doc = "0: No roll-under has occurred"]
RUIRQ_0 = 0,
#[doc = "1: Roll-under has occurred"]
RUIRQ_1 = 1,
}
impl From<RUIRQ_A> for bool {
#[inline(always)]
fn from(variant: RUIRQ_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `RUIRQ`"]
pub type RUIRQ_R = crate::R<bool, RUIRQ_A>;
impl RUIRQ_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> RUIRQ_A {
match self.bits {
false => RUIRQ_A::RUIRQ_0,
true => RUIRQ_A::RUIRQ_1,
}
}
#[doc = "Checks if the value of the field is `RUIRQ_0`"]
#[inline(always)]
pub fn is_ruirq_0(&self) -> bool {
*self == RUIRQ_A::RUIRQ_0
}
#[doc = "Checks if the value of the field is `RUIRQ_1`"]
#[inline(always)]
pub fn is_ruirq_1(&self) -> bool {
*self == RUIRQ_A::RUIRQ_1
}
}
#[doc = "Write proxy for field `RUIRQ`"]
pub struct RUIRQ_W<'a> {
w: &'a mut W,
}
impl<'a> RUIRQ_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: RUIRQ_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "No roll-under has occurred"]
#[inline(always)]
pub fn ruirq_0(self) -> &'a mut W {
self.variant(RUIRQ_A::RUIRQ_0)
}
#[doc = "Roll-under has occurred"]
#[inline(always)]
pub fn ruirq_1(self) -> &'a mut W {
self.variant(RUIRQ_A::RUIRQ_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 << 5)) | (((value as u16) & 0x01) << 5);
self.w
}
}
#[doc = "Roll-over Interrupt Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ROIE_A {
#[doc = "0: Roll-over interrupt is disabled"]
ROIE_0 = 0,
#[doc = "1: Roll-over interrupt is enabled"]
ROIE_1 = 1,
}
impl From<ROIE_A> for bool {
#[inline(always)]
fn from(variant: ROIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `ROIE`"]
pub type ROIE_R = crate::R<bool, ROIE_A>;
impl ROIE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> ROIE_A {
match self.bits {
false => ROIE_A::ROIE_0,
true => ROIE_A::ROIE_1,
}
}
#[doc = "Checks if the value of the field is `ROIE_0`"]
#[inline(always)]
pub fn is_roie_0(&self) -> bool {
*self == ROIE_A::ROIE_0
}
#[doc = "Checks if the value of the field is `ROIE_1`"]
#[inline(always)]
pub fn is_roie_1(&self) -> bool {
*self == ROIE_A::ROIE_1
}
}
#[doc = "Write proxy for field `ROIE`"]
pub struct ROIE_W<'a> {
w: &'a mut W,
}
impl<'a> ROIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: ROIE_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Roll-over interrupt is disabled"]
#[inline(always)]
pub fn roie_0(self) -> &'a mut W {
self.variant(ROIE_A::ROIE_0)
}
#[doc = "Roll-over interrupt is enabled"]
#[inline(always)]
pub fn roie_1(self) -> &'a mut W {
self.variant(ROIE_A::ROIE_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 = "Roll-over Interrupt Request\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ROIRQ_A {
#[doc = "0: No roll-over has occurred"]
ROIRQ_0 = 0,
#[doc = "1: Roll-over has occurred"]
ROIRQ_1 = 1,
}
impl From<ROIRQ_A> for bool {
#[inline(always)]
fn from(variant: ROIRQ_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `ROIRQ`"]
pub type ROIRQ_R = crate::R<bool, ROIRQ_A>;
impl ROIRQ_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> ROIRQ_A {
match self.bits {
false => ROIRQ_A::ROIRQ_0,
true => ROIRQ_A::ROIRQ_1,
}
}
#[doc = "Checks if the value of the field is `ROIRQ_0`"]
#[inline(always)]
pub fn is_roirq_0(&self) -> bool {
*self == ROIRQ_A::ROIRQ_0
}
#[doc = "Checks if the value of the field is `ROIRQ_1`"]
#[inline(always)]
pub fn is_roirq_1(&self) -> bool {
*self == ROIRQ_A::ROIRQ_1
}
}
#[doc = "Write proxy for field `ROIRQ`"]
pub struct ROIRQ_W<'a> {
w: &'a mut W,
}
impl<'a> ROIRQ_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: ROIRQ_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "No roll-over has occurred"]
#[inline(always)]
pub fn roirq_0(self) -> &'a mut W {
self.variant(ROIRQ_A::ROIRQ_0)
}
#[doc = "Roll-over has occurred"]
#[inline(always)]
pub fn roirq_1(self) -> &'a mut W {
self.variant(ROIRQ_A::ROIRQ_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 = "Revolution Counter Modulus Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum REVMOD_A {
#[doc = "0: Use INDEX pulse to increment/decrement revolution counter (REV)."]
REVMOD_0 = 0,
#[doc = "1: Use modulus counting roll-over/under to increment/decrement revolution counter (REV)."]
REVMOD_1 = 1,
}
impl From<REVMOD_A> for bool {
#[inline(always)]
fn from(variant: REVMOD_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `REVMOD`"]
pub type REVMOD_R = crate::R<bool, REVMOD_A>;
impl REVMOD_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> REVMOD_A {
match self.bits {
false => REVMOD_A::REVMOD_0,
true => REVMOD_A::REVMOD_1,
}
}
#[doc = "Checks if the value of the field is `REVMOD_0`"]
#[inline(always)]
pub fn is_revmod_0(&self) -> bool {
*self == REVMOD_A::REVMOD_0
}
#[doc = "Checks if the value of the field is `REVMOD_1`"]
#[inline(always)]
pub fn is_revmod_1(&self) -> bool {
*self == REVMOD_A::REVMOD_1
}
}
#[doc = "Write proxy for field `REVMOD`"]
pub struct REVMOD_W<'a> {
w: &'a mut W,
}
impl<'a> REVMOD_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: REVMOD_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Use INDEX pulse to increment/decrement revolution counter (REV)."]
#[inline(always)]
pub fn revmod_0(self) -> &'a mut W {
self.variant(REVMOD_A::REVMOD_0)
}
#[doc = "Use modulus counting roll-over/under to increment/decrement revolution counter (REV)."]
#[inline(always)]
pub fn revmod_1(self) -> &'a mut W {
self.variant(REVMOD_A::REVMOD_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 = "Output Control\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum OUTCTL_A {
#[doc = "0: POSMATCH pulses when a match occurs between the position counters (POS) and the compare value (COMP)."]
OUTCTL_0 = 0,
#[doc = "1: POSMATCH pulses when the UPOS, LPOS, REV, or POSD registers are read."]
OUTCTL_1 = 1,
}
impl From<OUTCTL_A> for bool {
#[inline(always)]
fn from(variant: OUTCTL_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `OUTCTL`"]
pub type OUTCTL_R = crate::R<bool, OUTCTL_A>;
impl OUTCTL_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> OUTCTL_A {
match self.bits {
false => OUTCTL_A::OUTCTL_0,
true => OUTCTL_A::OUTCTL_1,
}
}
#[doc = "Checks if the value of the field is `OUTCTL_0`"]
#[inline(always)]
pub fn is_outctl_0(&self) -> bool {
*self == OUTCTL_A::OUTCTL_0
}
#[doc = "Checks if the value of the field is `OUTCTL_1`"]
#[inline(always)]
pub fn is_outctl_1(&self) -> bool {
*self == OUTCTL_A::OUTCTL_1
}
}
#[doc = "Write proxy for field `OUTCTL`"]
pub struct OUTCTL_W<'a> {
w: &'a mut W,
}
impl<'a> OUTCTL_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: OUTCTL_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "POSMATCH pulses when a match occurs between the position counters (POS) and the compare value (COMP)."]
#[inline(always)]
pub fn outctl_0(self) -> &'a mut W {
self.variant(OUTCTL_A::OUTCTL_0)
}
#[doc = "POSMATCH pulses when the UPOS, LPOS, REV, or POSD registers are read."]
#[inline(always)]
pub fn outctl_1(self) -> &'a mut W {
self.variant(OUTCTL_A::OUTCTL_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 = "Simultaneous PHASEA and PHASEB Change Interrupt Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SABIE_A {
#[doc = "0: Simultaneous PHASEA and PHASEB change interrupt disabled."]
SABIE_0 = 0,
#[doc = "1: Simultaneous PHASEA and PHASEB change interrupt enabled."]
SABIE_1 = 1,
}
impl From<SABIE_A> for bool {
#[inline(always)]
fn from(variant: SABIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `SABIE`"]
pub type SABIE_R = crate::R<bool, SABIE_A>;
impl SABIE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> SABIE_A {
match self.bits {
false => SABIE_A::SABIE_0,
true => SABIE_A::SABIE_1,
}
}
#[doc = "Checks if the value of the field is `SABIE_0`"]
#[inline(always)]
pub fn is_sabie_0(&self) -> bool {
*self == SABIE_A::SABIE_0
}
#[doc = "Checks if the value of the field is `SABIE_1`"]
#[inline(always)]
pub fn is_sabie_1(&self) -> bool {
*self == SABIE_A::SABIE_1
}
}
#[doc = "Write proxy for field `SABIE`"]
pub struct SABIE_W<'a> {
w: &'a mut W,
}
impl<'a> SABIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: SABIE_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Simultaneous PHASEA and PHASEB change interrupt disabled."]
#[inline(always)]
pub fn sabie_0(self) -> &'a mut W {
self.variant(SABIE_A::SABIE_0)
}
#[doc = "Simultaneous PHASEA and PHASEB change interrupt enabled."]
#[inline(always)]
pub fn sabie_1(self) -> &'a mut W {
self.variant(SABIE_A::SABIE_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 = "Simultaneous PHASEA and PHASEB Change Interrupt Request\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SABIRQ_A {
#[doc = "0: No simultaneous change of PHASEA and PHASEB has occurred."]
SABIRQ_0 = 0,
#[doc = "1: A simultaneous change of PHASEA and PHASEB has occurred."]
SABIRQ_1 = 1,
}
impl From<SABIRQ_A> for bool {
#[inline(always)]
fn from(variant: SABIRQ_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `SABIRQ`"]
pub type SABIRQ_R = crate::R<bool, SABIRQ_A>;
impl SABIRQ_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> SABIRQ_A {
match self.bits {
false => SABIRQ_A::SABIRQ_0,
true => SABIRQ_A::SABIRQ_1,
}
}
#[doc = "Checks if the value of the field is `SABIRQ_0`"]
#[inline(always)]
pub fn is_sabirq_0(&self) -> bool {
*self == SABIRQ_A::SABIRQ_0
}
#[doc = "Checks if the value of the field is `SABIRQ_1`"]
#[inline(always)]
pub fn is_sabirq_1(&self) -> bool {
*self == SABIRQ_A::SABIRQ_1
}
}
#[doc = "Write proxy for field `SABIRQ`"]
pub struct SABIRQ_W<'a> {
w: &'a mut W,
}
impl<'a> SABIRQ_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: SABIRQ_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "No simultaneous change of PHASEA and PHASEB has occurred."]
#[inline(always)]
pub fn sabirq_0(self) -> &'a mut W {
self.variant(SABIRQ_A::SABIRQ_0)
}
#[doc = "A simultaneous change of PHASEA and PHASEB has occurred."]
#[inline(always)]
pub fn sabirq_1(self) -> &'a mut W {
self.variant(SABIRQ_A::SABIRQ_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
}
}
impl R {
#[doc = "Bit 0 - Update Hold Registers"]
#[inline(always)]
pub fn updhld(&self) -> UPDHLD_R {
UPDHLD_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - Update Position Registers"]
#[inline(always)]
pub fn updpos(&self) -> UPDPOS_R {
UPDPOS_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - Enable Modulo Counting"]
#[inline(always)]
pub fn mod_(&self) -> MOD_R {
MOD_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 3 - Count Direction Flag"]
#[inline(always)]
pub fn dir(&self) -> DIR_R {
DIR_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 4 - Roll-under Interrupt Enable"]
#[inline(always)]
pub fn ruie(&self) -> RUIE_R {
RUIE_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 5 - Roll-under Interrupt Request"]
#[inline(always)]
pub fn ruirq(&self) -> RUIRQ_R {
RUIRQ_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 6 - Roll-over Interrupt Enable"]
#[inline(always)]
pub fn roie(&self) -> ROIE_R {
ROIE_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 7 - Roll-over Interrupt Request"]
#[inline(always)]
pub fn roirq(&self) -> ROIRQ_R {
ROIRQ_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 8 - Revolution Counter Modulus Enable"]
#[inline(always)]
pub fn revmod(&self) -> REVMOD_R {
REVMOD_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 9 - Output Control"]
#[inline(always)]
pub fn outctl(&self) -> OUTCTL_R {
OUTCTL_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 10 - Simultaneous PHASEA and PHASEB Change Interrupt Enable"]
#[inline(always)]
pub fn sabie(&self) -> SABIE_R {
SABIE_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 11 - Simultaneous PHASEA and PHASEB Change Interrupt Request"]
#[inline(always)]
pub fn sabirq(&self) -> SABIRQ_R {
SABIRQ_R::new(((self.bits >> 11) & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 0 - Update Hold Registers"]
#[inline(always)]
pub fn updhld(&mut self) -> UPDHLD_W {
UPDHLD_W { w: self }
}
#[doc = "Bit 1 - Update Position Registers"]
#[inline(always)]
pub fn updpos(&mut self) -> UPDPOS_W {
UPDPOS_W { w: self }
}
#[doc = "Bit 2 - Enable Modulo Counting"]
#[inline(always)]
pub fn mod_(&mut self) -> MOD_W {
MOD_W { w: self }
}
#[doc = "Bit 4 - Roll-under Interrupt Enable"]
#[inline(always)]
pub fn ruie(&mut self) -> RUIE_W {
RUIE_W { w: self }
}
#[doc = "Bit 5 - Roll-under Interrupt Request"]
#[inline(always)]
pub fn ruirq(&mut self) -> RUIRQ_W {
RUIRQ_W { w: self }
}
#[doc = "Bit 6 - Roll-over Interrupt Enable"]
#[inline(always)]
pub fn roie(&mut self) -> ROIE_W {
ROIE_W { w: self }
}
#[doc = "Bit 7 - Roll-over Interrupt Request"]
#[inline(always)]
pub fn roirq(&mut self) -> ROIRQ_W {
ROIRQ_W { w: self }
}
#[doc = "Bit 8 - Revolution Counter Modulus Enable"]
#[inline(always)]
pub fn revmod(&mut self) -> REVMOD_W {
REVMOD_W { w: self }
}
#[doc = "Bit 9 - Output Control"]
#[inline(always)]
pub fn outctl(&mut self) -> OUTCTL_W {
OUTCTL_W { w: self }
}
#[doc = "Bit 10 - Simultaneous PHASEA and PHASEB Change Interrupt Enable"]
#[inline(always)]
pub fn sabie(&mut self) -> SABIE_W {
SABIE_W { w: self }
}
#[doc = "Bit 11 - Simultaneous PHASEA and PHASEB Change Interrupt Request"]
#[inline(always)]
pub fn sabirq(&mut self) -> SABIRQ_W {
SABIRQ_W { w: self }
}
}