#[doc = "Register `IMR` reader"]
pub type R = crate::R<ImrSpec>;
#[doc = "Register `IMR` writer"]
pub type W = crate::W<ImrSpec>;
#[doc = "Field `HOME_ENABLE` reader - HOME_ENABLE"]
pub type HomeEnableR = crate::BitReader;
#[doc = "Field `INDEX_PRESET` reader - INDEX_PRESET"]
pub type IndexPresetR = crate::BitReader;
#[doc = "Field `PHB` reader - PHB"]
pub type PhbR = crate::BitReader;
#[doc = "Field `PHA` reader - PHA"]
pub type PhaR = crate::BitReader;
#[doc = "Field `FHOM_ENA` reader - filter operation on HOME/ENABLE input"]
pub type FhomEnaR = crate::BitReader;
#[doc = "Field `FHOM_ENA` writer - filter operation on HOME/ENABLE input"]
pub type FhomEnaW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `FIND_PRE` reader - filter operation on INDEX/PRESET input"]
pub type FindPreR = crate::BitReader;
#[doc = "Field `FIND_PRE` writer - filter operation on INDEX/PRESET input"]
pub type FindPreW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `FPHB` reader - filter operation on PHASEB input"]
pub type FphbR = crate::BitReader;
#[doc = "Field `FPHB` writer - filter operation on PHASEB input"]
pub type FphbW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `FPHA` reader - filter operation on PHASEA input"]
pub type FphaR = crate::BitReader;
#[doc = "Field `FPHA` writer - filter operation on PHASEA input"]
pub type FphaW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Position Compare 0 Flag Output\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Cmpf0 {
#[doc = "0: When the position counter is less than value of COMP0 register"]
Cmpf00 = 0,
#[doc = "1: When the position counter is greater or equal than value of COMP0 register"]
Cmpf01 = 1,
}
impl From<Cmpf0> for bool {
#[inline(always)]
fn from(variant: Cmpf0) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `CMPF0` reader - Position Compare 0 Flag Output"]
pub type Cmpf0R = crate::BitReader<Cmpf0>;
impl Cmpf0R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Cmpf0 {
match self.bits {
false => Cmpf0::Cmpf00,
true => Cmpf0::Cmpf01,
}
}
#[doc = "When the position counter is less than value of COMP0 register"]
#[inline(always)]
pub fn is_cmpf00(&self) -> bool {
*self == Cmpf0::Cmpf00
}
#[doc = "When the position counter is greater or equal than value of COMP0 register"]
#[inline(always)]
pub fn is_cmpf01(&self) -> bool {
*self == Cmpf0::Cmpf01
}
}
#[doc = "Position Compare1 Flag Output\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Cmp1f {
#[doc = "0: When the position counter is less than value of COMP1 register"]
Cmp1f0 = 0,
#[doc = "1: When the position counter is greater or equal than value of COMP1 register"]
Cmp1f1 = 1,
}
impl From<Cmp1f> for bool {
#[inline(always)]
fn from(variant: Cmp1f) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `CMP1F` reader - Position Compare1 Flag Output"]
pub type Cmp1fR = crate::BitReader<Cmp1f>;
impl Cmp1fR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Cmp1f {
match self.bits {
false => Cmp1f::Cmp1f0,
true => Cmp1f::Cmp1f1,
}
}
#[doc = "When the position counter is less than value of COMP1 register"]
#[inline(always)]
pub fn is_cmp1f0(&self) -> bool {
*self == Cmp1f::Cmp1f0
}
#[doc = "When the position counter is greater or equal than value of COMP1 register"]
#[inline(always)]
pub fn is_cmp1f1(&self) -> bool {
*self == Cmp1f::Cmp1f1
}
}
#[doc = "Position Compare2 Flag Output\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Cmp2f {
#[doc = "0: When the position counter is less than value of COMP2 register"]
Cmp2f0 = 0,
#[doc = "1: When the position counter is greater or equal than value of COMP2 register"]
Cmp2f1 = 1,
}
impl From<Cmp2f> for bool {
#[inline(always)]
fn from(variant: Cmp2f) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `CMP2F` reader - Position Compare2 Flag Output"]
pub type Cmp2fR = crate::BitReader<Cmp2f>;
impl Cmp2fR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Cmp2f {
match self.bits {
false => Cmp2f::Cmp2f0,
true => Cmp2f::Cmp2f1,
}
}
#[doc = "When the position counter is less than value of COMP2 register"]
#[inline(always)]
pub fn is_cmp2f0(&self) -> bool {
*self == Cmp2f::Cmp2f0
}
#[doc = "When the position counter is greater or equal than value of COMP2 register"]
#[inline(always)]
pub fn is_cmp2f1(&self) -> bool {
*self == Cmp2f::Cmp2f1
}
}
#[doc = "Position Compare3 Flag Output\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Cmp3f {
#[doc = "0: When the position counter value is less than value of COMP3 register"]
Cmp3f0 = 0,
#[doc = "1: When the position counter is greater or equal than value of COMP3 register"]
Cmp3f1 = 1,
}
impl From<Cmp3f> for bool {
#[inline(always)]
fn from(variant: Cmp3f) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `CMP3F` reader - Position Compare3 Flag Output"]
pub type Cmp3fR = crate::BitReader<Cmp3f>;
impl Cmp3fR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Cmp3f {
match self.bits {
false => Cmp3f::Cmp3f0,
true => Cmp3f::Cmp3f1,
}
}
#[doc = "When the position counter value is less than value of COMP3 register"]
#[inline(always)]
pub fn is_cmp3f0(&self) -> bool {
*self == Cmp3f::Cmp3f0
}
#[doc = "When the position counter is greater or equal than value of COMP3 register"]
#[inline(always)]
pub fn is_cmp3f1(&self) -> bool {
*self == Cmp3f::Cmp3f1
}
}
#[doc = "Field `DIRH` reader - Count Direction Flag Hold"]
pub type DirhR = crate::BitReader;
#[doc = "Count Direction Flag Output\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Dir {
#[doc = "0: Current count was in the down direction"]
Dir0 = 0,
#[doc = "1: Current count was in the up direction"]
Dir1 = 1,
}
impl From<Dir> for bool {
#[inline(always)]
fn from(variant: Dir) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `DIR` reader - Count Direction Flag Output"]
pub type DirR = crate::BitReader<Dir>;
impl DirR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Dir {
match self.bits {
false => Dir::Dir0,
true => Dir::Dir1,
}
}
#[doc = "Current count was in the down direction"]
#[inline(always)]
pub fn is_dir0(&self) -> bool {
*self == Dir::Dir0
}
#[doc = "Current count was in the up direction"]
#[inline(always)]
pub fn is_dir1(&self) -> bool {
*self == Dir::Dir1
}
}
impl R {
#[doc = "Bit 0 - HOME_ENABLE"]
#[inline(always)]
pub fn home_enable(&self) -> HomeEnableR {
HomeEnableR::new((self.bits & 1) != 0)
}
#[doc = "Bit 1 - INDEX_PRESET"]
#[inline(always)]
pub fn index_preset(&self) -> IndexPresetR {
IndexPresetR::new(((self.bits >> 1) & 1) != 0)
}
#[doc = "Bit 2 - PHB"]
#[inline(always)]
pub fn phb(&self) -> PhbR {
PhbR::new(((self.bits >> 2) & 1) != 0)
}
#[doc = "Bit 3 - PHA"]
#[inline(always)]
pub fn pha(&self) -> PhaR {
PhaR::new(((self.bits >> 3) & 1) != 0)
}
#[doc = "Bit 4 - filter operation on HOME/ENABLE input"]
#[inline(always)]
pub fn fhom_ena(&self) -> FhomEnaR {
FhomEnaR::new(((self.bits >> 4) & 1) != 0)
}
#[doc = "Bit 5 - filter operation on INDEX/PRESET input"]
#[inline(always)]
pub fn find_pre(&self) -> FindPreR {
FindPreR::new(((self.bits >> 5) & 1) != 0)
}
#[doc = "Bit 6 - filter operation on PHASEB input"]
#[inline(always)]
pub fn fphb(&self) -> FphbR {
FphbR::new(((self.bits >> 6) & 1) != 0)
}
#[doc = "Bit 7 - filter operation on PHASEA input"]
#[inline(always)]
pub fn fpha(&self) -> FphaR {
FphaR::new(((self.bits >> 7) & 1) != 0)
}
#[doc = "Bit 8 - Position Compare 0 Flag Output"]
#[inline(always)]
pub fn cmpf0(&self) -> Cmpf0R {
Cmpf0R::new(((self.bits >> 8) & 1) != 0)
}
#[doc = "Bit 9 - Position Compare1 Flag Output"]
#[inline(always)]
pub fn cmp1f(&self) -> Cmp1fR {
Cmp1fR::new(((self.bits >> 9) & 1) != 0)
}
#[doc = "Bit 10 - Position Compare2 Flag Output"]
#[inline(always)]
pub fn cmp2f(&self) -> Cmp2fR {
Cmp2fR::new(((self.bits >> 10) & 1) != 0)
}
#[doc = "Bit 11 - Position Compare3 Flag Output"]
#[inline(always)]
pub fn cmp3f(&self) -> Cmp3fR {
Cmp3fR::new(((self.bits >> 11) & 1) != 0)
}
#[doc = "Bit 14 - Count Direction Flag Hold"]
#[inline(always)]
pub fn dirh(&self) -> DirhR {
DirhR::new(((self.bits >> 14) & 1) != 0)
}
#[doc = "Bit 15 - Count Direction Flag Output"]
#[inline(always)]
pub fn dir(&self) -> DirR {
DirR::new(((self.bits >> 15) & 1) != 0)
}
}
#[cfg(feature = "debug")]
impl core::fmt::Debug for R {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("IMR")
.field("home_enable", &self.home_enable())
.field("index_preset", &self.index_preset())
.field("phb", &self.phb())
.field("pha", &self.pha())
.field("fhom_ena", &self.fhom_ena())
.field("find_pre", &self.find_pre())
.field("fphb", &self.fphb())
.field("fpha", &self.fpha())
.field("cmpf0", &self.cmpf0())
.field("cmp1f", &self.cmp1f())
.field("cmp2f", &self.cmp2f())
.field("cmp3f", &self.cmp3f())
.field("dirh", &self.dirh())
.field("dir", &self.dir())
.finish()
}
}
impl W {
#[doc = "Bit 4 - filter operation on HOME/ENABLE input"]
#[inline(always)]
pub fn fhom_ena(&mut self) -> FhomEnaW<'_, ImrSpec> {
FhomEnaW::new(self, 4)
}
#[doc = "Bit 5 - filter operation on INDEX/PRESET input"]
#[inline(always)]
pub fn find_pre(&mut self) -> FindPreW<'_, ImrSpec> {
FindPreW::new(self, 5)
}
#[doc = "Bit 6 - filter operation on PHASEB input"]
#[inline(always)]
pub fn fphb(&mut self) -> FphbW<'_, ImrSpec> {
FphbW::new(self, 6)
}
#[doc = "Bit 7 - filter operation on PHASEA input"]
#[inline(always)]
pub fn fpha(&mut self) -> FphaW<'_, ImrSpec> {
FphaW::new(self, 7)
}
}
#[doc = "Input Monitor Register\n\nYou can [`read`](crate::Reg::read) this register and get [`imr::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`imr::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct ImrSpec;
impl crate::RegisterSpec for ImrSpec {
type Ux = u16;
}
#[doc = "`read()` method returns [`imr::R`](R) reader structure"]
impl crate::Readable for ImrSpec {}
#[doc = "`write(|w| ..)` method takes [`imr::W`](W) writer structure"]
impl crate::Writable for ImrSpec {
type Safety = crate::Unsafe;
}
#[doc = "`reset()` method sets IMR to value 0"]
impl crate::Resettable for ImrSpec {}