#[doc = "Block Control Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Bcr(pub u32);
impl Bcr {
#[doc = "Synchro Command"]
#[must_use]
#[inline(always)]
pub const fn sync(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Synchro Command"]
#[inline(always)]
pub const fn set_sync(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
}
impl Default for Bcr {
#[inline(always)]
fn default() -> Bcr {
Bcr(0)
}
}
impl core::fmt::Debug for Bcr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Bcr").field("sync", &self.sync()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Bcr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Bcr {{ sync: {=bool:?} }}", self.sync())
}
}
#[doc = "Block Mode Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Bmr(pub u32);
impl Bmr {
#[doc = "External Clock Signal 0 Selection"]
#[must_use]
#[inline(always)]
pub const fn tc0xc0s(&self) -> super::vals::Tc0xc0s {
let val = (self.0 >> 0usize) & 0x03;
super::vals::Tc0xc0s::from_bits(val as u8)
}
#[doc = "External Clock Signal 0 Selection"]
#[inline(always)]
pub const fn set_tc0xc0s(&mut self, val: super::vals::Tc0xc0s) {
self.0 = (self.0 & !(0x03 << 0usize)) | (((val.to_bits() as u32) & 0x03) << 0usize);
}
#[doc = "External Clock Signal 1 Selection"]
#[must_use]
#[inline(always)]
pub const fn tc1xc1s(&self) -> super::vals::Tc1xc1s {
let val = (self.0 >> 2usize) & 0x03;
super::vals::Tc1xc1s::from_bits(val as u8)
}
#[doc = "External Clock Signal 1 Selection"]
#[inline(always)]
pub const fn set_tc1xc1s(&mut self, val: super::vals::Tc1xc1s) {
self.0 = (self.0 & !(0x03 << 2usize)) | (((val.to_bits() as u32) & 0x03) << 2usize);
}
#[doc = "External Clock Signal 2 Selection"]
#[must_use]
#[inline(always)]
pub const fn tc2xc2s(&self) -> super::vals::Tc2xc2s {
let val = (self.0 >> 4usize) & 0x03;
super::vals::Tc2xc2s::from_bits(val as u8)
}
#[doc = "External Clock Signal 2 Selection"]
#[inline(always)]
pub const fn set_tc2xc2s(&mut self, val: super::vals::Tc2xc2s) {
self.0 = (self.0 & !(0x03 << 4usize)) | (((val.to_bits() as u32) & 0x03) << 4usize);
}
#[doc = "Quadrature Decoder ENabled"]
#[must_use]
#[inline(always)]
pub const fn qden(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Quadrature Decoder ENabled"]
#[inline(always)]
pub const fn set_qden(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "POSition ENabled"]
#[must_use]
#[inline(always)]
pub const fn posen(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "POSition ENabled"]
#[inline(always)]
pub const fn set_posen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "SPEED ENabled"]
#[must_use]
#[inline(always)]
pub const fn speeden(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "SPEED ENabled"]
#[inline(always)]
pub const fn set_speeden(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Quadrature Decoding TRANSparent"]
#[must_use]
#[inline(always)]
pub const fn qdtrans(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Quadrature Decoding TRANSparent"]
#[inline(always)]
pub const fn set_qdtrans(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "EDGe on PHA count mode"]
#[must_use]
#[inline(always)]
pub const fn edgpha(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "EDGe on PHA count mode"]
#[inline(always)]
pub const fn set_edgpha(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "INVerted phA"]
#[must_use]
#[inline(always)]
pub const fn inva(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "INVerted phA"]
#[inline(always)]
pub const fn set_inva(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
#[doc = "INVerted phB"]
#[must_use]
#[inline(always)]
pub const fn invb(&self) -> bool {
let val = (self.0 >> 14usize) & 0x01;
val != 0
}
#[doc = "INVerted phB"]
#[inline(always)]
pub const fn set_invb(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
}
#[doc = "INVerted InDeX"]
#[must_use]
#[inline(always)]
pub const fn invidx(&self) -> bool {
let val = (self.0 >> 15usize) & 0x01;
val != 0
}
#[doc = "INVerted InDeX"]
#[inline(always)]
pub const fn set_invidx(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
}
#[doc = "SWAP PHA and PHB"]
#[must_use]
#[inline(always)]
pub const fn swap(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "SWAP PHA and PHB"]
#[inline(always)]
pub const fn set_swap(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "InDeX pin is PHB pin"]
#[must_use]
#[inline(always)]
pub const fn idxphb(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "InDeX pin is PHB pin"]
#[inline(always)]
pub const fn set_idxphb(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[must_use]
#[inline(always)]
pub const fn filter(&self) -> bool {
let val = (self.0 >> 19usize) & 0x01;
val != 0
}
#[inline(always)]
pub const fn set_filter(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
}
#[doc = "MAXimum FILTer"]
#[must_use]
#[inline(always)]
pub const fn maxfilt(&self) -> u8 {
let val = (self.0 >> 20usize) & 0x3f;
val as u8
}
#[doc = "MAXimum FILTer"]
#[inline(always)]
pub const fn set_maxfilt(&mut self, val: u8) {
self.0 = (self.0 & !(0x3f << 20usize)) | (((val as u32) & 0x3f) << 20usize);
}
}
impl Default for Bmr {
#[inline(always)]
fn default() -> Bmr {
Bmr(0)
}
}
impl core::fmt::Debug for Bmr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Bmr")
.field("tc0xc0s", &self.tc0xc0s())
.field("tc1xc1s", &self.tc1xc1s())
.field("tc2xc2s", &self.tc2xc2s())
.field("qden", &self.qden())
.field("posen", &self.posen())
.field("speeden", &self.speeden())
.field("qdtrans", &self.qdtrans())
.field("edgpha", &self.edgpha())
.field("inva", &self.inva())
.field("invb", &self.invb())
.field("invidx", &self.invidx())
.field("swap", &self.swap())
.field("idxphb", &self.idxphb())
.field("filter", &self.filter())
.field("maxfilt", &self.maxfilt())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Bmr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Bmr {{ tc0xc0s: {:?}, tc1xc1s: {:?}, tc2xc2s: {:?}, qden: {=bool:?}, posen: {=bool:?}, speeden: {=bool:?}, qdtrans: {=bool:?}, edgpha: {=bool:?}, inva: {=bool:?}, invb: {=bool:?}, invidx: {=bool:?}, swap: {=bool:?}, idxphb: {=bool:?}, filter: {=bool:?}, maxfilt: {=u8:?} }}",
self.tc0xc0s(),
self.tc1xc1s(),
self.tc2xc2s(),
self.qden(),
self.posen(),
self.speeden(),
self.qdtrans(),
self.edgpha(),
self.inva(),
self.invb(),
self.invidx(),
self.swap(),
self.idxphb(),
self.filter(),
self.maxfilt()
)
}
}
#[doc = "Channel Control Register (channel = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ccr(pub u32);
impl Ccr {
#[doc = "Counter Clock Enable Command"]
#[must_use]
#[inline(always)]
pub const fn clken(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Counter Clock Enable Command"]
#[inline(always)]
pub const fn set_clken(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Counter Clock Disable Command"]
#[must_use]
#[inline(always)]
pub const fn clkdis(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Counter Clock Disable Command"]
#[inline(always)]
pub const fn set_clkdis(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Software Trigger Command"]
#[must_use]
#[inline(always)]
pub const fn swtrg(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Software Trigger Command"]
#[inline(always)]
pub const fn set_swtrg(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
}
impl Default for Ccr {
#[inline(always)]
fn default() -> Ccr {
Ccr(0)
}
}
impl core::fmt::Debug for Ccr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ccr")
.field("clken", &self.clken())
.field("clkdis", &self.clkdis())
.field("swtrg", &self.swtrg())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ccr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ccr {{ clken: {=bool:?}, clkdis: {=bool:?}, swtrg: {=bool:?} }}",
self.clken(),
self.clkdis(),
self.swtrg()
)
}
}
#[doc = "Channel Control Register (channel = 1)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ccr1(pub u32);
impl Ccr1 {
#[doc = "Counter Clock Enable Command"]
#[must_use]
#[inline(always)]
pub const fn clken(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Counter Clock Enable Command"]
#[inline(always)]
pub const fn set_clken(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Counter Clock Disable Command"]
#[must_use]
#[inline(always)]
pub const fn clkdis(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Counter Clock Disable Command"]
#[inline(always)]
pub const fn set_clkdis(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Software Trigger Command"]
#[must_use]
#[inline(always)]
pub const fn swtrg(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Software Trigger Command"]
#[inline(always)]
pub const fn set_swtrg(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
}
impl Default for Ccr1 {
#[inline(always)]
fn default() -> Ccr1 {
Ccr1(0)
}
}
impl core::fmt::Debug for Ccr1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ccr1")
.field("clken", &self.clken())
.field("clkdis", &self.clkdis())
.field("swtrg", &self.swtrg())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ccr1 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ccr1 {{ clken: {=bool:?}, clkdis: {=bool:?}, swtrg: {=bool:?} }}",
self.clken(),
self.clkdis(),
self.swtrg()
)
}
}
#[doc = "Channel Control Register (channel = 2)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ccr2(pub u32);
impl Ccr2 {
#[doc = "Counter Clock Enable Command"]
#[must_use]
#[inline(always)]
pub const fn clken(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Counter Clock Enable Command"]
#[inline(always)]
pub const fn set_clken(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Counter Clock Disable Command"]
#[must_use]
#[inline(always)]
pub const fn clkdis(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Counter Clock Disable Command"]
#[inline(always)]
pub const fn set_clkdis(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Software Trigger Command"]
#[must_use]
#[inline(always)]
pub const fn swtrg(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Software Trigger Command"]
#[inline(always)]
pub const fn set_swtrg(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
}
impl Default for Ccr2 {
#[inline(always)]
fn default() -> Ccr2 {
Ccr2(0)
}
}
impl core::fmt::Debug for Ccr2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ccr2")
.field("clken", &self.clken())
.field("clkdis", &self.clkdis())
.field("swtrg", &self.swtrg())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ccr2 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ccr2 {{ clken: {=bool:?}, clkdis: {=bool:?}, swtrg: {=bool:?} }}",
self.clken(),
self.clkdis(),
self.swtrg()
)
}
}
#[doc = "Channel Mode Register (channel = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cmr(pub u32);
impl Cmr {
#[doc = "Clock Selection"]
#[must_use]
#[inline(always)]
pub const fn tcclks(&self) -> super::vals::CmrTcclks {
let val = (self.0 >> 0usize) & 0x07;
super::vals::CmrTcclks::from_bits(val as u8)
}
#[doc = "Clock Selection"]
#[inline(always)]
pub const fn set_tcclks(&mut self, val: super::vals::CmrTcclks) {
self.0 = (self.0 & !(0x07 << 0usize)) | (((val.to_bits() as u32) & 0x07) << 0usize);
}
#[doc = "Clock Invert"]
#[must_use]
#[inline(always)]
pub const fn clki(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Clock Invert"]
#[inline(always)]
pub const fn set_clki(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Burst Signal Selection"]
#[must_use]
#[inline(always)]
pub const fn burst(&self) -> super::vals::CmrBurst {
let val = (self.0 >> 4usize) & 0x03;
super::vals::CmrBurst::from_bits(val as u8)
}
#[doc = "Burst Signal Selection"]
#[inline(always)]
pub const fn set_burst(&mut self, val: super::vals::CmrBurst) {
self.0 = (self.0 & !(0x03 << 4usize)) | (((val.to_bits() as u32) & 0x03) << 4usize);
}
#[doc = "Counter Clock Stopped with RB Loading"]
#[must_use]
#[inline(always)]
pub const fn ldbstop(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Counter Clock Stopped with RB Loading"]
#[inline(always)]
pub const fn set_ldbstop(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Counter Clock Disable with RB Loading"]
#[must_use]
#[inline(always)]
pub const fn ldbdis(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Counter Clock Disable with RB Loading"]
#[inline(always)]
pub const fn set_ldbdis(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "External Trigger Edge Selection"]
#[must_use]
#[inline(always)]
pub const fn etrgedg(&self) -> super::vals::CmrEtrgedg {
let val = (self.0 >> 8usize) & 0x03;
super::vals::CmrEtrgedg::from_bits(val as u8)
}
#[doc = "External Trigger Edge Selection"]
#[inline(always)]
pub const fn set_etrgedg(&mut self, val: super::vals::CmrEtrgedg) {
self.0 = (self.0 & !(0x03 << 8usize)) | (((val.to_bits() as u32) & 0x03) << 8usize);
}
#[doc = "TIOA or TIOB External Trigger Selection"]
#[must_use]
#[inline(always)]
pub const fn abetrg(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "TIOA or TIOB External Trigger Selection"]
#[inline(always)]
pub const fn set_abetrg(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "RC Compare Trigger Enable"]
#[must_use]
#[inline(always)]
pub const fn cpctrg(&self) -> bool {
let val = (self.0 >> 14usize) & 0x01;
val != 0
}
#[doc = "RC Compare Trigger Enable"]
#[inline(always)]
pub const fn set_cpctrg(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
}
#[doc = "Waveform Mode"]
#[must_use]
#[inline(always)]
pub const fn wave(&self) -> bool {
let val = (self.0 >> 15usize) & 0x01;
val != 0
}
#[doc = "Waveform Mode"]
#[inline(always)]
pub const fn set_wave(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
}
#[doc = "RA Loading Edge Selection"]
#[must_use]
#[inline(always)]
pub const fn ldra(&self) -> super::vals::CmrLdra {
let val = (self.0 >> 16usize) & 0x03;
super::vals::CmrLdra::from_bits(val as u8)
}
#[doc = "RA Loading Edge Selection"]
#[inline(always)]
pub const fn set_ldra(&mut self, val: super::vals::CmrLdra) {
self.0 = (self.0 & !(0x03 << 16usize)) | (((val.to_bits() as u32) & 0x03) << 16usize);
}
#[doc = "RB Loading Edge Selection"]
#[must_use]
#[inline(always)]
pub const fn ldrb(&self) -> super::vals::CmrLdrb {
let val = (self.0 >> 18usize) & 0x03;
super::vals::CmrLdrb::from_bits(val as u8)
}
#[doc = "RB Loading Edge Selection"]
#[inline(always)]
pub const fn set_ldrb(&mut self, val: super::vals::CmrLdrb) {
self.0 = (self.0 & !(0x03 << 18usize)) | (((val.to_bits() as u32) & 0x03) << 18usize);
}
}
impl Default for Cmr {
#[inline(always)]
fn default() -> Cmr {
Cmr(0)
}
}
impl core::fmt::Debug for Cmr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cmr")
.field("tcclks", &self.tcclks())
.field("clki", &self.clki())
.field("burst", &self.burst())
.field("ldbstop", &self.ldbstop())
.field("ldbdis", &self.ldbdis())
.field("etrgedg", &self.etrgedg())
.field("abetrg", &self.abetrg())
.field("cpctrg", &self.cpctrg())
.field("wave", &self.wave())
.field("ldra", &self.ldra())
.field("ldrb", &self.ldrb())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cmr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Cmr {{ tcclks: {:?}, clki: {=bool:?}, burst: {:?}, ldbstop: {=bool:?}, ldbdis: {=bool:?}, etrgedg: {:?}, abetrg: {=bool:?}, cpctrg: {=bool:?}, wave: {=bool:?}, ldra: {:?}, ldrb: {:?} }}",
self.tcclks(),
self.clki(),
self.burst(),
self.ldbstop(),
self.ldbdis(),
self.etrgedg(),
self.abetrg(),
self.cpctrg(),
self.wave(),
self.ldra(),
self.ldrb()
)
}
}
#[doc = "Channel Mode Register (channel = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct CmrWaveEq1(pub u32);
impl CmrWaveEq1 {
#[doc = "Clock Selection"]
#[must_use]
#[inline(always)]
pub const fn tcclks(&self) -> super::vals::CmrWaveEq1Tcclks {
let val = (self.0 >> 0usize) & 0x07;
super::vals::CmrWaveEq1Tcclks::from_bits(val as u8)
}
#[doc = "Clock Selection"]
#[inline(always)]
pub const fn set_tcclks(&mut self, val: super::vals::CmrWaveEq1Tcclks) {
self.0 = (self.0 & !(0x07 << 0usize)) | (((val.to_bits() as u32) & 0x07) << 0usize);
}
#[doc = "Clock Invert"]
#[must_use]
#[inline(always)]
pub const fn clki(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Clock Invert"]
#[inline(always)]
pub const fn set_clki(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Burst Signal Selection"]
#[must_use]
#[inline(always)]
pub const fn burst(&self) -> super::vals::CmrWaveEq1Burst {
let val = (self.0 >> 4usize) & 0x03;
super::vals::CmrWaveEq1Burst::from_bits(val as u8)
}
#[doc = "Burst Signal Selection"]
#[inline(always)]
pub const fn set_burst(&mut self, val: super::vals::CmrWaveEq1Burst) {
self.0 = (self.0 & !(0x03 << 4usize)) | (((val.to_bits() as u32) & 0x03) << 4usize);
}
#[doc = "Counter Clock Stopped with RC Compare"]
#[must_use]
#[inline(always)]
pub const fn cpcstop(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Counter Clock Stopped with RC Compare"]
#[inline(always)]
pub const fn set_cpcstop(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Counter Clock Disable with RC Compare"]
#[must_use]
#[inline(always)]
pub const fn cpcdis(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Counter Clock Disable with RC Compare"]
#[inline(always)]
pub const fn set_cpcdis(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "External Event Edge Selection"]
#[must_use]
#[inline(always)]
pub const fn eevtedg(&self) -> super::vals::CmrWaveEq1Eevtedg {
let val = (self.0 >> 8usize) & 0x03;
super::vals::CmrWaveEq1Eevtedg::from_bits(val as u8)
}
#[doc = "External Event Edge Selection"]
#[inline(always)]
pub const fn set_eevtedg(&mut self, val: super::vals::CmrWaveEq1Eevtedg) {
self.0 = (self.0 & !(0x03 << 8usize)) | (((val.to_bits() as u32) & 0x03) << 8usize);
}
#[doc = "External Event Selection"]
#[must_use]
#[inline(always)]
pub const fn eevt(&self) -> super::vals::CmrWaveEq1Eevt {
let val = (self.0 >> 10usize) & 0x03;
super::vals::CmrWaveEq1Eevt::from_bits(val as u8)
}
#[doc = "External Event Selection"]
#[inline(always)]
pub const fn set_eevt(&mut self, val: super::vals::CmrWaveEq1Eevt) {
self.0 = (self.0 & !(0x03 << 10usize)) | (((val.to_bits() as u32) & 0x03) << 10usize);
}
#[doc = "External Event Trigger Enable"]
#[must_use]
#[inline(always)]
pub const fn enetrg(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "External Event Trigger Enable"]
#[inline(always)]
pub const fn set_enetrg(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Waveform Selection"]
#[must_use]
#[inline(always)]
pub const fn wavsel(&self) -> super::vals::CmrWaveEq1Wavsel {
let val = (self.0 >> 13usize) & 0x03;
super::vals::CmrWaveEq1Wavsel::from_bits(val as u8)
}
#[doc = "Waveform Selection"]
#[inline(always)]
pub const fn set_wavsel(&mut self, val: super::vals::CmrWaveEq1Wavsel) {
self.0 = (self.0 & !(0x03 << 13usize)) | (((val.to_bits() as u32) & 0x03) << 13usize);
}
#[doc = "Waveform Mode"]
#[must_use]
#[inline(always)]
pub const fn wave(&self) -> bool {
let val = (self.0 >> 15usize) & 0x01;
val != 0
}
#[doc = "Waveform Mode"]
#[inline(always)]
pub const fn set_wave(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
}
#[doc = "RA Compare Effect on TIOA"]
#[must_use]
#[inline(always)]
pub const fn acpa(&self) -> super::vals::CmrWaveEq1Acpa {
let val = (self.0 >> 16usize) & 0x03;
super::vals::CmrWaveEq1Acpa::from_bits(val as u8)
}
#[doc = "RA Compare Effect on TIOA"]
#[inline(always)]
pub const fn set_acpa(&mut self, val: super::vals::CmrWaveEq1Acpa) {
self.0 = (self.0 & !(0x03 << 16usize)) | (((val.to_bits() as u32) & 0x03) << 16usize);
}
#[doc = "RC Compare Effect on TIOA"]
#[must_use]
#[inline(always)]
pub const fn acpc(&self) -> super::vals::CmrWaveEq1Acpc {
let val = (self.0 >> 18usize) & 0x03;
super::vals::CmrWaveEq1Acpc::from_bits(val as u8)
}
#[doc = "RC Compare Effect on TIOA"]
#[inline(always)]
pub const fn set_acpc(&mut self, val: super::vals::CmrWaveEq1Acpc) {
self.0 = (self.0 & !(0x03 << 18usize)) | (((val.to_bits() as u32) & 0x03) << 18usize);
}
#[doc = "External Event Effect on TIOA"]
#[must_use]
#[inline(always)]
pub const fn aeevt(&self) -> super::vals::CmrWaveEq1Aeevt {
let val = (self.0 >> 20usize) & 0x03;
super::vals::CmrWaveEq1Aeevt::from_bits(val as u8)
}
#[doc = "External Event Effect on TIOA"]
#[inline(always)]
pub const fn set_aeevt(&mut self, val: super::vals::CmrWaveEq1Aeevt) {
self.0 = (self.0 & !(0x03 << 20usize)) | (((val.to_bits() as u32) & 0x03) << 20usize);
}
#[doc = "Software Trigger Effect on TIOA"]
#[must_use]
#[inline(always)]
pub const fn aswtrg(&self) -> super::vals::CmrWaveEq1Aswtrg {
let val = (self.0 >> 22usize) & 0x03;
super::vals::CmrWaveEq1Aswtrg::from_bits(val as u8)
}
#[doc = "Software Trigger Effect on TIOA"]
#[inline(always)]
pub const fn set_aswtrg(&mut self, val: super::vals::CmrWaveEq1Aswtrg) {
self.0 = (self.0 & !(0x03 << 22usize)) | (((val.to_bits() as u32) & 0x03) << 22usize);
}
#[doc = "RB Compare Effect on TIOB"]
#[must_use]
#[inline(always)]
pub const fn bcpb(&self) -> super::vals::CmrWaveEq1Bcpb {
let val = (self.0 >> 24usize) & 0x03;
super::vals::CmrWaveEq1Bcpb::from_bits(val as u8)
}
#[doc = "RB Compare Effect on TIOB"]
#[inline(always)]
pub const fn set_bcpb(&mut self, val: super::vals::CmrWaveEq1Bcpb) {
self.0 = (self.0 & !(0x03 << 24usize)) | (((val.to_bits() as u32) & 0x03) << 24usize);
}
#[doc = "RC Compare Effect on TIOB"]
#[must_use]
#[inline(always)]
pub const fn bcpc(&self) -> super::vals::CmrWaveEq1Bcpc {
let val = (self.0 >> 26usize) & 0x03;
super::vals::CmrWaveEq1Bcpc::from_bits(val as u8)
}
#[doc = "RC Compare Effect on TIOB"]
#[inline(always)]
pub const fn set_bcpc(&mut self, val: super::vals::CmrWaveEq1Bcpc) {
self.0 = (self.0 & !(0x03 << 26usize)) | (((val.to_bits() as u32) & 0x03) << 26usize);
}
#[doc = "External Event Effect on TIOB"]
#[must_use]
#[inline(always)]
pub const fn beevt(&self) -> super::vals::CmrWaveEq1Beevt {
let val = (self.0 >> 28usize) & 0x03;
super::vals::CmrWaveEq1Beevt::from_bits(val as u8)
}
#[doc = "External Event Effect on TIOB"]
#[inline(always)]
pub const fn set_beevt(&mut self, val: super::vals::CmrWaveEq1Beevt) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
#[doc = "Software Trigger Effect on TIOB"]
#[must_use]
#[inline(always)]
pub const fn bswtrg(&self) -> super::vals::CmrWaveEq1Bswtrg {
let val = (self.0 >> 30usize) & 0x03;
super::vals::CmrWaveEq1Bswtrg::from_bits(val as u8)
}
#[doc = "Software Trigger Effect on TIOB"]
#[inline(always)]
pub const fn set_bswtrg(&mut self, val: super::vals::CmrWaveEq1Bswtrg) {
self.0 = (self.0 & !(0x03 << 30usize)) | (((val.to_bits() as u32) & 0x03) << 30usize);
}
}
impl Default for CmrWaveEq1 {
#[inline(always)]
fn default() -> CmrWaveEq1 {
CmrWaveEq1(0)
}
}
impl core::fmt::Debug for CmrWaveEq1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("CmrWaveEq1")
.field("tcclks", &self.tcclks())
.field("clki", &self.clki())
.field("burst", &self.burst())
.field("cpcstop", &self.cpcstop())
.field("cpcdis", &self.cpcdis())
.field("eevtedg", &self.eevtedg())
.field("eevt", &self.eevt())
.field("enetrg", &self.enetrg())
.field("wavsel", &self.wavsel())
.field("wave", &self.wave())
.field("acpa", &self.acpa())
.field("acpc", &self.acpc())
.field("aeevt", &self.aeevt())
.field("aswtrg", &self.aswtrg())
.field("bcpb", &self.bcpb())
.field("bcpc", &self.bcpc())
.field("beevt", &self.beevt())
.field("bswtrg", &self.bswtrg())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for CmrWaveEq1 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"CmrWaveEq1 {{ tcclks: {:?}, clki: {=bool:?}, burst: {:?}, cpcstop: {=bool:?}, cpcdis: {=bool:?}, eevtedg: {:?}, eevt: {:?}, enetrg: {=bool:?}, wavsel: {:?}, wave: {=bool:?}, acpa: {:?}, acpc: {:?}, aeevt: {:?}, aswtrg: {:?}, bcpb: {:?}, bcpc: {:?}, beevt: {:?}, bswtrg: {:?} }}",
self.tcclks(),
self.clki(),
self.burst(),
self.cpcstop(),
self.cpcdis(),
self.eevtedg(),
self.eevt(),
self.enetrg(),
self.wavsel(),
self.wave(),
self.acpa(),
self.acpc(),
self.aeevt(),
self.aswtrg(),
self.bcpb(),
self.bcpc(),
self.beevt(),
self.bswtrg()
)
}
}
#[doc = "Counter Value (channel = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cv(pub u32);
impl Cv {
#[doc = "Counter Value"]
#[must_use]
#[inline(always)]
pub const fn cv(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Counter Value"]
#[inline(always)]
pub const fn set_cv(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Cv {
#[inline(always)]
fn default() -> Cv {
Cv(0)
}
}
impl core::fmt::Debug for Cv {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cv").field("cv", &self.cv()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cv {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Cv {{ cv: {=u32:?} }}", self.cv())
}
}
#[doc = "Counter Value (channel = 1)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cv1(pub u32);
impl Cv1 {
#[doc = "Counter Value"]
#[must_use]
#[inline(always)]
pub const fn cv(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Counter Value"]
#[inline(always)]
pub const fn set_cv(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Cv1 {
#[inline(always)]
fn default() -> Cv1 {
Cv1(0)
}
}
impl core::fmt::Debug for Cv1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cv1").field("cv", &self.cv()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cv1 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Cv1 {{ cv: {=u32:?} }}", self.cv())
}
}
#[doc = "Counter Value (channel = 2)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cv2(pub u32);
impl Cv2 {
#[doc = "Counter Value"]
#[must_use]
#[inline(always)]
pub const fn cv(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Counter Value"]
#[inline(always)]
pub const fn set_cv(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Cv2 {
#[inline(always)]
fn default() -> Cv2 {
Cv2(0)
}
}
impl core::fmt::Debug for Cv2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cv2").field("cv", &self.cv()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cv2 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Cv2 {{ cv: {=u32:?} }}", self.cv())
}
}
#[doc = "Fault Mode Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Fmr(pub u32);
impl Fmr {
#[doc = "ENable Compare Fault Channel 0"]
#[must_use]
#[inline(always)]
pub const fn encf0(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "ENable Compare Fault Channel 0"]
#[inline(always)]
pub const fn set_encf0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "ENable Compare Fault Channel 1"]
#[must_use]
#[inline(always)]
pub const fn encf1(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "ENable Compare Fault Channel 1"]
#[inline(always)]
pub const fn set_encf1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
}
impl Default for Fmr {
#[inline(always)]
fn default() -> Fmr {
Fmr(0)
}
}
impl core::fmt::Debug for Fmr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Fmr")
.field("encf0", &self.encf0())
.field("encf1", &self.encf1())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Fmr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Fmr {{ encf0: {=bool:?}, encf1: {=bool:?} }}",
self.encf0(),
self.encf1()
)
}
}
#[doc = "Interrupt Disable Register (channel = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Idr(pub u32);
impl Idr {
#[doc = "Counter Overflow"]
#[must_use]
#[inline(always)]
pub const fn covfs(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Counter Overflow"]
#[inline(always)]
pub const fn set_covfs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Load Overrun"]
#[must_use]
#[inline(always)]
pub const fn lovrs(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Load Overrun"]
#[inline(always)]
pub const fn set_lovrs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "RA Compare"]
#[must_use]
#[inline(always)]
pub const fn cpas(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "RA Compare"]
#[inline(always)]
pub const fn set_cpas(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "RB Compare"]
#[must_use]
#[inline(always)]
pub const fn cpbs(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "RB Compare"]
#[inline(always)]
pub const fn set_cpbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "RC Compare"]
#[must_use]
#[inline(always)]
pub const fn cpcs(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "RC Compare"]
#[inline(always)]
pub const fn set_cpcs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "RA Loading"]
#[must_use]
#[inline(always)]
pub const fn ldras(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "RA Loading"]
#[inline(always)]
pub const fn set_ldras(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "RB Loading"]
#[must_use]
#[inline(always)]
pub const fn ldrbs(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "RB Loading"]
#[inline(always)]
pub const fn set_ldrbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "External Trigger"]
#[must_use]
#[inline(always)]
pub const fn etrgs(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "External Trigger"]
#[inline(always)]
pub const fn set_etrgs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
}
impl Default for Idr {
#[inline(always)]
fn default() -> Idr {
Idr(0)
}
}
impl core::fmt::Debug for Idr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Idr")
.field("covfs", &self.covfs())
.field("lovrs", &self.lovrs())
.field("cpas", &self.cpas())
.field("cpbs", &self.cpbs())
.field("cpcs", &self.cpcs())
.field("ldras", &self.ldras())
.field("ldrbs", &self.ldrbs())
.field("etrgs", &self.etrgs())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Idr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Idr {{ covfs: {=bool:?}, lovrs: {=bool:?}, cpas: {=bool:?}, cpbs: {=bool:?}, cpcs: {=bool:?}, ldras: {=bool:?}, ldrbs: {=bool:?}, etrgs: {=bool:?} }}",
self.covfs(),
self.lovrs(),
self.cpas(),
self.cpbs(),
self.cpcs(),
self.ldras(),
self.ldrbs(),
self.etrgs()
)
}
}
#[doc = "Interrupt Disable Register (channel = 1)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Idr1(pub u32);
impl Idr1 {
#[doc = "Counter Overflow"]
#[must_use]
#[inline(always)]
pub const fn covfs(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Counter Overflow"]
#[inline(always)]
pub const fn set_covfs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Load Overrun"]
#[must_use]
#[inline(always)]
pub const fn lovrs(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Load Overrun"]
#[inline(always)]
pub const fn set_lovrs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "RA Compare"]
#[must_use]
#[inline(always)]
pub const fn cpas(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "RA Compare"]
#[inline(always)]
pub const fn set_cpas(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "RB Compare"]
#[must_use]
#[inline(always)]
pub const fn cpbs(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "RB Compare"]
#[inline(always)]
pub const fn set_cpbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "RC Compare"]
#[must_use]
#[inline(always)]
pub const fn cpcs(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "RC Compare"]
#[inline(always)]
pub const fn set_cpcs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "RA Loading"]
#[must_use]
#[inline(always)]
pub const fn ldras(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "RA Loading"]
#[inline(always)]
pub const fn set_ldras(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "RB Loading"]
#[must_use]
#[inline(always)]
pub const fn ldrbs(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "RB Loading"]
#[inline(always)]
pub const fn set_ldrbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "External Trigger"]
#[must_use]
#[inline(always)]
pub const fn etrgs(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "External Trigger"]
#[inline(always)]
pub const fn set_etrgs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
}
impl Default for Idr1 {
#[inline(always)]
fn default() -> Idr1 {
Idr1(0)
}
}
impl core::fmt::Debug for Idr1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Idr1")
.field("covfs", &self.covfs())
.field("lovrs", &self.lovrs())
.field("cpas", &self.cpas())
.field("cpbs", &self.cpbs())
.field("cpcs", &self.cpcs())
.field("ldras", &self.ldras())
.field("ldrbs", &self.ldrbs())
.field("etrgs", &self.etrgs())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Idr1 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Idr1 {{ covfs: {=bool:?}, lovrs: {=bool:?}, cpas: {=bool:?}, cpbs: {=bool:?}, cpcs: {=bool:?}, ldras: {=bool:?}, ldrbs: {=bool:?}, etrgs: {=bool:?} }}",
self.covfs(),
self.lovrs(),
self.cpas(),
self.cpbs(),
self.cpcs(),
self.ldras(),
self.ldrbs(),
self.etrgs()
)
}
}
#[doc = "Interrupt Disable Register (channel = 2)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Idr2(pub u32);
impl Idr2 {
#[doc = "Counter Overflow"]
#[must_use]
#[inline(always)]
pub const fn covfs(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Counter Overflow"]
#[inline(always)]
pub const fn set_covfs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Load Overrun"]
#[must_use]
#[inline(always)]
pub const fn lovrs(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Load Overrun"]
#[inline(always)]
pub const fn set_lovrs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "RA Compare"]
#[must_use]
#[inline(always)]
pub const fn cpas(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "RA Compare"]
#[inline(always)]
pub const fn set_cpas(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "RB Compare"]
#[must_use]
#[inline(always)]
pub const fn cpbs(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "RB Compare"]
#[inline(always)]
pub const fn set_cpbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "RC Compare"]
#[must_use]
#[inline(always)]
pub const fn cpcs(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "RC Compare"]
#[inline(always)]
pub const fn set_cpcs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "RA Loading"]
#[must_use]
#[inline(always)]
pub const fn ldras(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "RA Loading"]
#[inline(always)]
pub const fn set_ldras(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "RB Loading"]
#[must_use]
#[inline(always)]
pub const fn ldrbs(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "RB Loading"]
#[inline(always)]
pub const fn set_ldrbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "External Trigger"]
#[must_use]
#[inline(always)]
pub const fn etrgs(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "External Trigger"]
#[inline(always)]
pub const fn set_etrgs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
}
impl Default for Idr2 {
#[inline(always)]
fn default() -> Idr2 {
Idr2(0)
}
}
impl core::fmt::Debug for Idr2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Idr2")
.field("covfs", &self.covfs())
.field("lovrs", &self.lovrs())
.field("cpas", &self.cpas())
.field("cpbs", &self.cpbs())
.field("cpcs", &self.cpcs())
.field("ldras", &self.ldras())
.field("ldrbs", &self.ldrbs())
.field("etrgs", &self.etrgs())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Idr2 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Idr2 {{ covfs: {=bool:?}, lovrs: {=bool:?}, cpas: {=bool:?}, cpbs: {=bool:?}, cpcs: {=bool:?}, ldras: {=bool:?}, ldrbs: {=bool:?}, etrgs: {=bool:?} }}",
self.covfs(),
self.lovrs(),
self.cpas(),
self.cpbs(),
self.cpcs(),
self.ldras(),
self.ldrbs(),
self.etrgs()
)
}
}
#[doc = "Interrupt Enable Register (channel = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ier(pub u32);
impl Ier {
#[doc = "Counter Overflow"]
#[must_use]
#[inline(always)]
pub const fn covfs(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Counter Overflow"]
#[inline(always)]
pub const fn set_covfs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Load Overrun"]
#[must_use]
#[inline(always)]
pub const fn lovrs(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Load Overrun"]
#[inline(always)]
pub const fn set_lovrs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "RA Compare"]
#[must_use]
#[inline(always)]
pub const fn cpas(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "RA Compare"]
#[inline(always)]
pub const fn set_cpas(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "RB Compare"]
#[must_use]
#[inline(always)]
pub const fn cpbs(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "RB Compare"]
#[inline(always)]
pub const fn set_cpbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "RC Compare"]
#[must_use]
#[inline(always)]
pub const fn cpcs(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "RC Compare"]
#[inline(always)]
pub const fn set_cpcs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "RA Loading"]
#[must_use]
#[inline(always)]
pub const fn ldras(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "RA Loading"]
#[inline(always)]
pub const fn set_ldras(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "RB Loading"]
#[must_use]
#[inline(always)]
pub const fn ldrbs(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "RB Loading"]
#[inline(always)]
pub const fn set_ldrbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "External Trigger"]
#[must_use]
#[inline(always)]
pub const fn etrgs(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "External Trigger"]
#[inline(always)]
pub const fn set_etrgs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
}
impl Default for Ier {
#[inline(always)]
fn default() -> Ier {
Ier(0)
}
}
impl core::fmt::Debug for Ier {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ier")
.field("covfs", &self.covfs())
.field("lovrs", &self.lovrs())
.field("cpas", &self.cpas())
.field("cpbs", &self.cpbs())
.field("cpcs", &self.cpcs())
.field("ldras", &self.ldras())
.field("ldrbs", &self.ldrbs())
.field("etrgs", &self.etrgs())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ier {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ier {{ covfs: {=bool:?}, lovrs: {=bool:?}, cpas: {=bool:?}, cpbs: {=bool:?}, cpcs: {=bool:?}, ldras: {=bool:?}, ldrbs: {=bool:?}, etrgs: {=bool:?} }}",
self.covfs(),
self.lovrs(),
self.cpas(),
self.cpbs(),
self.cpcs(),
self.ldras(),
self.ldrbs(),
self.etrgs()
)
}
}
#[doc = "Interrupt Enable Register (channel = 1)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ier1(pub u32);
impl Ier1 {
#[doc = "Counter Overflow"]
#[must_use]
#[inline(always)]
pub const fn covfs(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Counter Overflow"]
#[inline(always)]
pub const fn set_covfs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Load Overrun"]
#[must_use]
#[inline(always)]
pub const fn lovrs(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Load Overrun"]
#[inline(always)]
pub const fn set_lovrs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "RA Compare"]
#[must_use]
#[inline(always)]
pub const fn cpas(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "RA Compare"]
#[inline(always)]
pub const fn set_cpas(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "RB Compare"]
#[must_use]
#[inline(always)]
pub const fn cpbs(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "RB Compare"]
#[inline(always)]
pub const fn set_cpbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "RC Compare"]
#[must_use]
#[inline(always)]
pub const fn cpcs(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "RC Compare"]
#[inline(always)]
pub const fn set_cpcs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "RA Loading"]
#[must_use]
#[inline(always)]
pub const fn ldras(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "RA Loading"]
#[inline(always)]
pub const fn set_ldras(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "RB Loading"]
#[must_use]
#[inline(always)]
pub const fn ldrbs(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "RB Loading"]
#[inline(always)]
pub const fn set_ldrbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "External Trigger"]
#[must_use]
#[inline(always)]
pub const fn etrgs(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "External Trigger"]
#[inline(always)]
pub const fn set_etrgs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
}
impl Default for Ier1 {
#[inline(always)]
fn default() -> Ier1 {
Ier1(0)
}
}
impl core::fmt::Debug for Ier1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ier1")
.field("covfs", &self.covfs())
.field("lovrs", &self.lovrs())
.field("cpas", &self.cpas())
.field("cpbs", &self.cpbs())
.field("cpcs", &self.cpcs())
.field("ldras", &self.ldras())
.field("ldrbs", &self.ldrbs())
.field("etrgs", &self.etrgs())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ier1 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ier1 {{ covfs: {=bool:?}, lovrs: {=bool:?}, cpas: {=bool:?}, cpbs: {=bool:?}, cpcs: {=bool:?}, ldras: {=bool:?}, ldrbs: {=bool:?}, etrgs: {=bool:?} }}",
self.covfs(),
self.lovrs(),
self.cpas(),
self.cpbs(),
self.cpcs(),
self.ldras(),
self.ldrbs(),
self.etrgs()
)
}
}
#[doc = "Interrupt Enable Register (channel = 2)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ier2(pub u32);
impl Ier2 {
#[doc = "Counter Overflow"]
#[must_use]
#[inline(always)]
pub const fn covfs(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Counter Overflow"]
#[inline(always)]
pub const fn set_covfs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Load Overrun"]
#[must_use]
#[inline(always)]
pub const fn lovrs(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Load Overrun"]
#[inline(always)]
pub const fn set_lovrs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "RA Compare"]
#[must_use]
#[inline(always)]
pub const fn cpas(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "RA Compare"]
#[inline(always)]
pub const fn set_cpas(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "RB Compare"]
#[must_use]
#[inline(always)]
pub const fn cpbs(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "RB Compare"]
#[inline(always)]
pub const fn set_cpbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "RC Compare"]
#[must_use]
#[inline(always)]
pub const fn cpcs(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "RC Compare"]
#[inline(always)]
pub const fn set_cpcs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "RA Loading"]
#[must_use]
#[inline(always)]
pub const fn ldras(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "RA Loading"]
#[inline(always)]
pub const fn set_ldras(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "RB Loading"]
#[must_use]
#[inline(always)]
pub const fn ldrbs(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "RB Loading"]
#[inline(always)]
pub const fn set_ldrbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "External Trigger"]
#[must_use]
#[inline(always)]
pub const fn etrgs(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "External Trigger"]
#[inline(always)]
pub const fn set_etrgs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
}
impl Default for Ier2 {
#[inline(always)]
fn default() -> Ier2 {
Ier2(0)
}
}
impl core::fmt::Debug for Ier2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ier2")
.field("covfs", &self.covfs())
.field("lovrs", &self.lovrs())
.field("cpas", &self.cpas())
.field("cpbs", &self.cpbs())
.field("cpcs", &self.cpcs())
.field("ldras", &self.ldras())
.field("ldrbs", &self.ldrbs())
.field("etrgs", &self.etrgs())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ier2 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ier2 {{ covfs: {=bool:?}, lovrs: {=bool:?}, cpas: {=bool:?}, cpbs: {=bool:?}, cpcs: {=bool:?}, ldras: {=bool:?}, ldrbs: {=bool:?}, etrgs: {=bool:?} }}",
self.covfs(),
self.lovrs(),
self.cpas(),
self.cpbs(),
self.cpcs(),
self.ldras(),
self.ldrbs(),
self.etrgs()
)
}
}
#[doc = "Interrupt Mask Register (channel = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Imr(pub u32);
impl Imr {
#[doc = "Counter Overflow"]
#[must_use]
#[inline(always)]
pub const fn covfs(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Counter Overflow"]
#[inline(always)]
pub const fn set_covfs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Load Overrun"]
#[must_use]
#[inline(always)]
pub const fn lovrs(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Load Overrun"]
#[inline(always)]
pub const fn set_lovrs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "RA Compare"]
#[must_use]
#[inline(always)]
pub const fn cpas(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "RA Compare"]
#[inline(always)]
pub const fn set_cpas(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "RB Compare"]
#[must_use]
#[inline(always)]
pub const fn cpbs(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "RB Compare"]
#[inline(always)]
pub const fn set_cpbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "RC Compare"]
#[must_use]
#[inline(always)]
pub const fn cpcs(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "RC Compare"]
#[inline(always)]
pub const fn set_cpcs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "RA Loading"]
#[must_use]
#[inline(always)]
pub const fn ldras(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "RA Loading"]
#[inline(always)]
pub const fn set_ldras(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "RB Loading"]
#[must_use]
#[inline(always)]
pub const fn ldrbs(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "RB Loading"]
#[inline(always)]
pub const fn set_ldrbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "External Trigger"]
#[must_use]
#[inline(always)]
pub const fn etrgs(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "External Trigger"]
#[inline(always)]
pub const fn set_etrgs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
}
impl Default for Imr {
#[inline(always)]
fn default() -> Imr {
Imr(0)
}
}
impl core::fmt::Debug for Imr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Imr")
.field("covfs", &self.covfs())
.field("lovrs", &self.lovrs())
.field("cpas", &self.cpas())
.field("cpbs", &self.cpbs())
.field("cpcs", &self.cpcs())
.field("ldras", &self.ldras())
.field("ldrbs", &self.ldrbs())
.field("etrgs", &self.etrgs())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Imr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Imr {{ covfs: {=bool:?}, lovrs: {=bool:?}, cpas: {=bool:?}, cpbs: {=bool:?}, cpcs: {=bool:?}, ldras: {=bool:?}, ldrbs: {=bool:?}, etrgs: {=bool:?} }}",
self.covfs(),
self.lovrs(),
self.cpas(),
self.cpbs(),
self.cpcs(),
self.ldras(),
self.ldrbs(),
self.etrgs()
)
}
}
#[doc = "Interrupt Mask Register (channel = 1)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Imr1(pub u32);
impl Imr1 {
#[doc = "Counter Overflow"]
#[must_use]
#[inline(always)]
pub const fn covfs(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Counter Overflow"]
#[inline(always)]
pub const fn set_covfs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Load Overrun"]
#[must_use]
#[inline(always)]
pub const fn lovrs(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Load Overrun"]
#[inline(always)]
pub const fn set_lovrs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "RA Compare"]
#[must_use]
#[inline(always)]
pub const fn cpas(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "RA Compare"]
#[inline(always)]
pub const fn set_cpas(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "RB Compare"]
#[must_use]
#[inline(always)]
pub const fn cpbs(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "RB Compare"]
#[inline(always)]
pub const fn set_cpbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "RC Compare"]
#[must_use]
#[inline(always)]
pub const fn cpcs(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "RC Compare"]
#[inline(always)]
pub const fn set_cpcs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "RA Loading"]
#[must_use]
#[inline(always)]
pub const fn ldras(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "RA Loading"]
#[inline(always)]
pub const fn set_ldras(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "RB Loading"]
#[must_use]
#[inline(always)]
pub const fn ldrbs(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "RB Loading"]
#[inline(always)]
pub const fn set_ldrbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "External Trigger"]
#[must_use]
#[inline(always)]
pub const fn etrgs(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "External Trigger"]
#[inline(always)]
pub const fn set_etrgs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
}
impl Default for Imr1 {
#[inline(always)]
fn default() -> Imr1 {
Imr1(0)
}
}
impl core::fmt::Debug for Imr1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Imr1")
.field("covfs", &self.covfs())
.field("lovrs", &self.lovrs())
.field("cpas", &self.cpas())
.field("cpbs", &self.cpbs())
.field("cpcs", &self.cpcs())
.field("ldras", &self.ldras())
.field("ldrbs", &self.ldrbs())
.field("etrgs", &self.etrgs())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Imr1 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Imr1 {{ covfs: {=bool:?}, lovrs: {=bool:?}, cpas: {=bool:?}, cpbs: {=bool:?}, cpcs: {=bool:?}, ldras: {=bool:?}, ldrbs: {=bool:?}, etrgs: {=bool:?} }}",
self.covfs(),
self.lovrs(),
self.cpas(),
self.cpbs(),
self.cpcs(),
self.ldras(),
self.ldrbs(),
self.etrgs()
)
}
}
#[doc = "Interrupt Mask Register (channel = 2)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Imr2(pub u32);
impl Imr2 {
#[doc = "Counter Overflow"]
#[must_use]
#[inline(always)]
pub const fn covfs(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Counter Overflow"]
#[inline(always)]
pub const fn set_covfs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Load Overrun"]
#[must_use]
#[inline(always)]
pub const fn lovrs(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Load Overrun"]
#[inline(always)]
pub const fn set_lovrs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "RA Compare"]
#[must_use]
#[inline(always)]
pub const fn cpas(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "RA Compare"]
#[inline(always)]
pub const fn set_cpas(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "RB Compare"]
#[must_use]
#[inline(always)]
pub const fn cpbs(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "RB Compare"]
#[inline(always)]
pub const fn set_cpbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "RC Compare"]
#[must_use]
#[inline(always)]
pub const fn cpcs(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "RC Compare"]
#[inline(always)]
pub const fn set_cpcs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "RA Loading"]
#[must_use]
#[inline(always)]
pub const fn ldras(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "RA Loading"]
#[inline(always)]
pub const fn set_ldras(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "RB Loading"]
#[must_use]
#[inline(always)]
pub const fn ldrbs(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "RB Loading"]
#[inline(always)]
pub const fn set_ldrbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "External Trigger"]
#[must_use]
#[inline(always)]
pub const fn etrgs(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "External Trigger"]
#[inline(always)]
pub const fn set_etrgs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
}
impl Default for Imr2 {
#[inline(always)]
fn default() -> Imr2 {
Imr2(0)
}
}
impl core::fmt::Debug for Imr2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Imr2")
.field("covfs", &self.covfs())
.field("lovrs", &self.lovrs())
.field("cpas", &self.cpas())
.field("cpbs", &self.cpbs())
.field("cpcs", &self.cpcs())
.field("ldras", &self.ldras())
.field("ldrbs", &self.ldrbs())
.field("etrgs", &self.etrgs())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Imr2 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Imr2 {{ covfs: {=bool:?}, lovrs: {=bool:?}, cpas: {=bool:?}, cpbs: {=bool:?}, cpcs: {=bool:?}, ldras: {=bool:?}, ldrbs: {=bool:?}, etrgs: {=bool:?} }}",
self.covfs(),
self.lovrs(),
self.cpas(),
self.cpbs(),
self.cpcs(),
self.ldras(),
self.ldrbs(),
self.etrgs()
)
}
}
#[doc = "QDEC Interrupt Disable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Qidr(pub u32);
impl Qidr {
#[doc = "InDeX"]
#[must_use]
#[inline(always)]
pub const fn idx(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "InDeX"]
#[inline(always)]
pub const fn set_idx(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "DIRection CHanGe"]
#[must_use]
#[inline(always)]
pub const fn dirchg(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "DIRection CHanGe"]
#[inline(always)]
pub const fn set_dirchg(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Quadrature ERRor"]
#[must_use]
#[inline(always)]
pub const fn qerr(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Quadrature ERRor"]
#[inline(always)]
pub const fn set_qerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
}
impl Default for Qidr {
#[inline(always)]
fn default() -> Qidr {
Qidr(0)
}
}
impl core::fmt::Debug for Qidr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Qidr")
.field("idx", &self.idx())
.field("dirchg", &self.dirchg())
.field("qerr", &self.qerr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Qidr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Qidr {{ idx: {=bool:?}, dirchg: {=bool:?}, qerr: {=bool:?} }}",
self.idx(),
self.dirchg(),
self.qerr()
)
}
}
#[doc = "QDEC Interrupt Enable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Qier(pub u32);
impl Qier {
#[doc = "InDeX"]
#[must_use]
#[inline(always)]
pub const fn idx(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "InDeX"]
#[inline(always)]
pub const fn set_idx(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "DIRection CHanGe"]
#[must_use]
#[inline(always)]
pub const fn dirchg(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "DIRection CHanGe"]
#[inline(always)]
pub const fn set_dirchg(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Quadrature ERRor"]
#[must_use]
#[inline(always)]
pub const fn qerr(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Quadrature ERRor"]
#[inline(always)]
pub const fn set_qerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
}
impl Default for Qier {
#[inline(always)]
fn default() -> Qier {
Qier(0)
}
}
impl core::fmt::Debug for Qier {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Qier")
.field("idx", &self.idx())
.field("dirchg", &self.dirchg())
.field("qerr", &self.qerr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Qier {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Qier {{ idx: {=bool:?}, dirchg: {=bool:?}, qerr: {=bool:?} }}",
self.idx(),
self.dirchg(),
self.qerr()
)
}
}
#[doc = "QDEC Interrupt Mask Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Qimr(pub u32);
impl Qimr {
#[doc = "InDeX"]
#[must_use]
#[inline(always)]
pub const fn idx(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "InDeX"]
#[inline(always)]
pub const fn set_idx(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "DIRection CHanGe"]
#[must_use]
#[inline(always)]
pub const fn dirchg(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "DIRection CHanGe"]
#[inline(always)]
pub const fn set_dirchg(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Quadrature ERRor"]
#[must_use]
#[inline(always)]
pub const fn qerr(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Quadrature ERRor"]
#[inline(always)]
pub const fn set_qerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
}
impl Default for Qimr {
#[inline(always)]
fn default() -> Qimr {
Qimr(0)
}
}
impl core::fmt::Debug for Qimr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Qimr")
.field("idx", &self.idx())
.field("dirchg", &self.dirchg())
.field("qerr", &self.qerr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Qimr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Qimr {{ idx: {=bool:?}, dirchg: {=bool:?}, qerr: {=bool:?} }}",
self.idx(),
self.dirchg(),
self.qerr()
)
}
}
#[doc = "QDEC Interrupt Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Qisr(pub u32);
impl Qisr {
#[doc = "InDeX"]
#[must_use]
#[inline(always)]
pub const fn idx(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "InDeX"]
#[inline(always)]
pub const fn set_idx(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "DIRection CHanGe"]
#[must_use]
#[inline(always)]
pub const fn dirchg(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "DIRection CHanGe"]
#[inline(always)]
pub const fn set_dirchg(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Quadrature ERRor"]
#[must_use]
#[inline(always)]
pub const fn qerr(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Quadrature ERRor"]
#[inline(always)]
pub const fn set_qerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "DIRection"]
#[must_use]
#[inline(always)]
pub const fn dir(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "DIRection"]
#[inline(always)]
pub const fn set_dir(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
}
impl Default for Qisr {
#[inline(always)]
fn default() -> Qisr {
Qisr(0)
}
}
impl core::fmt::Debug for Qisr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Qisr")
.field("idx", &self.idx())
.field("dirchg", &self.dirchg())
.field("qerr", &self.qerr())
.field("dir", &self.dir())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Qisr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Qisr {{ idx: {=bool:?}, dirchg: {=bool:?}, qerr: {=bool:?}, dir: {=bool:?} }}",
self.idx(),
self.dirchg(),
self.qerr(),
self.dir()
)
}
}
#[doc = "Register A (channel = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ra(pub u32);
impl Ra {
#[doc = "Register A"]
#[must_use]
#[inline(always)]
pub const fn ra(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Register A"]
#[inline(always)]
pub const fn set_ra(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Ra {
#[inline(always)]
fn default() -> Ra {
Ra(0)
}
}
impl core::fmt::Debug for Ra {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ra").field("ra", &self.ra()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ra {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Ra {{ ra: {=u32:?} }}", self.ra())
}
}
#[doc = "Register A (channel = 1)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ra1(pub u32);
impl Ra1 {
#[doc = "Register A"]
#[must_use]
#[inline(always)]
pub const fn ra(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Register A"]
#[inline(always)]
pub const fn set_ra(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Ra1 {
#[inline(always)]
fn default() -> Ra1 {
Ra1(0)
}
}
impl core::fmt::Debug for Ra1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ra1").field("ra", &self.ra()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ra1 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Ra1 {{ ra: {=u32:?} }}", self.ra())
}
}
#[doc = "Register A (channel = 2)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ra2(pub u32);
impl Ra2 {
#[doc = "Register A"]
#[must_use]
#[inline(always)]
pub const fn ra(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Register A"]
#[inline(always)]
pub const fn set_ra(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Ra2 {
#[inline(always)]
fn default() -> Ra2 {
Ra2(0)
}
}
impl core::fmt::Debug for Ra2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ra2").field("ra", &self.ra()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ra2 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Ra2 {{ ra: {=u32:?} }}", self.ra())
}
}
#[doc = "Register B (channel = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rb(pub u32);
impl Rb {
#[doc = "Register B"]
#[must_use]
#[inline(always)]
pub const fn rb(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Register B"]
#[inline(always)]
pub const fn set_rb(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Rb {
#[inline(always)]
fn default() -> Rb {
Rb(0)
}
}
impl core::fmt::Debug for Rb {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rb").field("rb", &self.rb()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rb {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Rb {{ rb: {=u32:?} }}", self.rb())
}
}
#[doc = "Register B (channel = 1)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rb1(pub u32);
impl Rb1 {
#[doc = "Register B"]
#[must_use]
#[inline(always)]
pub const fn rb(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Register B"]
#[inline(always)]
pub const fn set_rb(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Rb1 {
#[inline(always)]
fn default() -> Rb1 {
Rb1(0)
}
}
impl core::fmt::Debug for Rb1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rb1").field("rb", &self.rb()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rb1 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Rb1 {{ rb: {=u32:?} }}", self.rb())
}
}
#[doc = "Register B (channel = 2)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rb2(pub u32);
impl Rb2 {
#[doc = "Register B"]
#[must_use]
#[inline(always)]
pub const fn rb(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Register B"]
#[inline(always)]
pub const fn set_rb(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Rb2 {
#[inline(always)]
fn default() -> Rb2 {
Rb2(0)
}
}
impl core::fmt::Debug for Rb2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rb2").field("rb", &self.rb()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rb2 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Rb2 {{ rb: {=u32:?} }}", self.rb())
}
}
#[doc = "Register C (channel = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rc(pub u32);
impl Rc {
#[doc = "Register C"]
#[must_use]
#[inline(always)]
pub const fn rc(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Register C"]
#[inline(always)]
pub const fn set_rc(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Rc {
#[inline(always)]
fn default() -> Rc {
Rc(0)
}
}
impl core::fmt::Debug for Rc {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rc").field("rc", &self.rc()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rc {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Rc {{ rc: {=u32:?} }}", self.rc())
}
}
#[doc = "Register C (channel = 1)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rc1(pub u32);
impl Rc1 {
#[doc = "Register C"]
#[must_use]
#[inline(always)]
pub const fn rc(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Register C"]
#[inline(always)]
pub const fn set_rc(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Rc1 {
#[inline(always)]
fn default() -> Rc1 {
Rc1(0)
}
}
impl core::fmt::Debug for Rc1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rc1").field("rc", &self.rc()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rc1 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Rc1 {{ rc: {=u32:?} }}", self.rc())
}
}
#[doc = "Register C (channel = 2)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rc2(pub u32);
impl Rc2 {
#[doc = "Register C"]
#[must_use]
#[inline(always)]
pub const fn rc(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Register C"]
#[inline(always)]
pub const fn set_rc(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Rc2 {
#[inline(always)]
fn default() -> Rc2 {
Rc2(0)
}
}
impl core::fmt::Debug for Rc2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rc2").field("rc", &self.rc()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rc2 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Rc2 {{ rc: {=u32:?} }}", self.rc())
}
}
#[doc = "Stepper Motor Mode Register (channel = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Smmr(pub u32);
impl Smmr {
#[doc = "Gray Count Enable"]
#[must_use]
#[inline(always)]
pub const fn gcen(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Gray Count Enable"]
#[inline(always)]
pub const fn set_gcen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "DOWN Count"]
#[must_use]
#[inline(always)]
pub const fn down(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "DOWN Count"]
#[inline(always)]
pub const fn set_down(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
}
impl Default for Smmr {
#[inline(always)]
fn default() -> Smmr {
Smmr(0)
}
}
impl core::fmt::Debug for Smmr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Smmr")
.field("gcen", &self.gcen())
.field("down", &self.down())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Smmr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Smmr {{ gcen: {=bool:?}, down: {=bool:?} }}",
self.gcen(),
self.down()
)
}
}
#[doc = "Stepper Motor Mode Register (channel = 1)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Smmr1(pub u32);
impl Smmr1 {
#[doc = "Gray Count Enable"]
#[must_use]
#[inline(always)]
pub const fn gcen(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Gray Count Enable"]
#[inline(always)]
pub const fn set_gcen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "DOWN Count"]
#[must_use]
#[inline(always)]
pub const fn down(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "DOWN Count"]
#[inline(always)]
pub const fn set_down(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
}
impl Default for Smmr1 {
#[inline(always)]
fn default() -> Smmr1 {
Smmr1(0)
}
}
impl core::fmt::Debug for Smmr1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Smmr1")
.field("gcen", &self.gcen())
.field("down", &self.down())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Smmr1 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Smmr1 {{ gcen: {=bool:?}, down: {=bool:?} }}",
self.gcen(),
self.down()
)
}
}
#[doc = "Stepper Motor Mode Register (channel = 2)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Smmr2(pub u32);
impl Smmr2 {
#[doc = "Gray Count Enable"]
#[must_use]
#[inline(always)]
pub const fn gcen(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Gray Count Enable"]
#[inline(always)]
pub const fn set_gcen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "DOWN Count"]
#[must_use]
#[inline(always)]
pub const fn down(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "DOWN Count"]
#[inline(always)]
pub const fn set_down(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
}
impl Default for Smmr2 {
#[inline(always)]
fn default() -> Smmr2 {
Smmr2(0)
}
}
impl core::fmt::Debug for Smmr2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Smmr2")
.field("gcen", &self.gcen())
.field("down", &self.down())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Smmr2 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Smmr2 {{ gcen: {=bool:?}, down: {=bool:?} }}",
self.gcen(),
self.down()
)
}
}
#[doc = "Status Register (channel = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sr(pub u32);
impl Sr {
#[doc = "Counter Overflow Status"]
#[must_use]
#[inline(always)]
pub const fn covfs(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Counter Overflow Status"]
#[inline(always)]
pub const fn set_covfs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Load Overrun Status"]
#[must_use]
#[inline(always)]
pub const fn lovrs(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Load Overrun Status"]
#[inline(always)]
pub const fn set_lovrs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "RA Compare Status"]
#[must_use]
#[inline(always)]
pub const fn cpas(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "RA Compare Status"]
#[inline(always)]
pub const fn set_cpas(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "RB Compare Status"]
#[must_use]
#[inline(always)]
pub const fn cpbs(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "RB Compare Status"]
#[inline(always)]
pub const fn set_cpbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "RC Compare Status"]
#[must_use]
#[inline(always)]
pub const fn cpcs(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "RC Compare Status"]
#[inline(always)]
pub const fn set_cpcs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "RA Loading Status"]
#[must_use]
#[inline(always)]
pub const fn ldras(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "RA Loading Status"]
#[inline(always)]
pub const fn set_ldras(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "RB Loading Status"]
#[must_use]
#[inline(always)]
pub const fn ldrbs(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "RB Loading Status"]
#[inline(always)]
pub const fn set_ldrbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "External Trigger Status"]
#[must_use]
#[inline(always)]
pub const fn etrgs(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "External Trigger Status"]
#[inline(always)]
pub const fn set_etrgs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Clock Enabling Status"]
#[must_use]
#[inline(always)]
pub const fn clksta(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Clock Enabling Status"]
#[inline(always)]
pub const fn set_clksta(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "TIOA Mirror"]
#[must_use]
#[inline(always)]
pub const fn mtioa(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "TIOA Mirror"]
#[inline(always)]
pub const fn set_mtioa(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "TIOB Mirror"]
#[must_use]
#[inline(always)]
pub const fn mtiob(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "TIOB Mirror"]
#[inline(always)]
pub const fn set_mtiob(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
}
impl Default for Sr {
#[inline(always)]
fn default() -> Sr {
Sr(0)
}
}
impl core::fmt::Debug for Sr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Sr")
.field("covfs", &self.covfs())
.field("lovrs", &self.lovrs())
.field("cpas", &self.cpas())
.field("cpbs", &self.cpbs())
.field("cpcs", &self.cpcs())
.field("ldras", &self.ldras())
.field("ldrbs", &self.ldrbs())
.field("etrgs", &self.etrgs())
.field("clksta", &self.clksta())
.field("mtioa", &self.mtioa())
.field("mtiob", &self.mtiob())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Sr {{ covfs: {=bool:?}, lovrs: {=bool:?}, cpas: {=bool:?}, cpbs: {=bool:?}, cpcs: {=bool:?}, ldras: {=bool:?}, ldrbs: {=bool:?}, etrgs: {=bool:?}, clksta: {=bool:?}, mtioa: {=bool:?}, mtiob: {=bool:?} }}",
self.covfs(),
self.lovrs(),
self.cpas(),
self.cpbs(),
self.cpcs(),
self.ldras(),
self.ldrbs(),
self.etrgs(),
self.clksta(),
self.mtioa(),
self.mtiob()
)
}
}
#[doc = "Status Register (channel = 1)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sr1(pub u32);
impl Sr1 {
#[doc = "Counter Overflow Status"]
#[must_use]
#[inline(always)]
pub const fn covfs(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Counter Overflow Status"]
#[inline(always)]
pub const fn set_covfs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Load Overrun Status"]
#[must_use]
#[inline(always)]
pub const fn lovrs(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Load Overrun Status"]
#[inline(always)]
pub const fn set_lovrs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "RA Compare Status"]
#[must_use]
#[inline(always)]
pub const fn cpas(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "RA Compare Status"]
#[inline(always)]
pub const fn set_cpas(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "RB Compare Status"]
#[must_use]
#[inline(always)]
pub const fn cpbs(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "RB Compare Status"]
#[inline(always)]
pub const fn set_cpbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "RC Compare Status"]
#[must_use]
#[inline(always)]
pub const fn cpcs(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "RC Compare Status"]
#[inline(always)]
pub const fn set_cpcs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "RA Loading Status"]
#[must_use]
#[inline(always)]
pub const fn ldras(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "RA Loading Status"]
#[inline(always)]
pub const fn set_ldras(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "RB Loading Status"]
#[must_use]
#[inline(always)]
pub const fn ldrbs(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "RB Loading Status"]
#[inline(always)]
pub const fn set_ldrbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "External Trigger Status"]
#[must_use]
#[inline(always)]
pub const fn etrgs(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "External Trigger Status"]
#[inline(always)]
pub const fn set_etrgs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Clock Enabling Status"]
#[must_use]
#[inline(always)]
pub const fn clksta(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Clock Enabling Status"]
#[inline(always)]
pub const fn set_clksta(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "TIOA Mirror"]
#[must_use]
#[inline(always)]
pub const fn mtioa(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "TIOA Mirror"]
#[inline(always)]
pub const fn set_mtioa(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "TIOB Mirror"]
#[must_use]
#[inline(always)]
pub const fn mtiob(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "TIOB Mirror"]
#[inline(always)]
pub const fn set_mtiob(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
}
impl Default for Sr1 {
#[inline(always)]
fn default() -> Sr1 {
Sr1(0)
}
}
impl core::fmt::Debug for Sr1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Sr1")
.field("covfs", &self.covfs())
.field("lovrs", &self.lovrs())
.field("cpas", &self.cpas())
.field("cpbs", &self.cpbs())
.field("cpcs", &self.cpcs())
.field("ldras", &self.ldras())
.field("ldrbs", &self.ldrbs())
.field("etrgs", &self.etrgs())
.field("clksta", &self.clksta())
.field("mtioa", &self.mtioa())
.field("mtiob", &self.mtiob())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sr1 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Sr1 {{ covfs: {=bool:?}, lovrs: {=bool:?}, cpas: {=bool:?}, cpbs: {=bool:?}, cpcs: {=bool:?}, ldras: {=bool:?}, ldrbs: {=bool:?}, etrgs: {=bool:?}, clksta: {=bool:?}, mtioa: {=bool:?}, mtiob: {=bool:?} }}",
self.covfs(),
self.lovrs(),
self.cpas(),
self.cpbs(),
self.cpcs(),
self.ldras(),
self.ldrbs(),
self.etrgs(),
self.clksta(),
self.mtioa(),
self.mtiob()
)
}
}
#[doc = "Status Register (channel = 2)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sr2(pub u32);
impl Sr2 {
#[doc = "Counter Overflow Status"]
#[must_use]
#[inline(always)]
pub const fn covfs(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Counter Overflow Status"]
#[inline(always)]
pub const fn set_covfs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Load Overrun Status"]
#[must_use]
#[inline(always)]
pub const fn lovrs(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Load Overrun Status"]
#[inline(always)]
pub const fn set_lovrs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "RA Compare Status"]
#[must_use]
#[inline(always)]
pub const fn cpas(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "RA Compare Status"]
#[inline(always)]
pub const fn set_cpas(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "RB Compare Status"]
#[must_use]
#[inline(always)]
pub const fn cpbs(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "RB Compare Status"]
#[inline(always)]
pub const fn set_cpbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "RC Compare Status"]
#[must_use]
#[inline(always)]
pub const fn cpcs(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "RC Compare Status"]
#[inline(always)]
pub const fn set_cpcs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "RA Loading Status"]
#[must_use]
#[inline(always)]
pub const fn ldras(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "RA Loading Status"]
#[inline(always)]
pub const fn set_ldras(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "RB Loading Status"]
#[must_use]
#[inline(always)]
pub const fn ldrbs(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "RB Loading Status"]
#[inline(always)]
pub const fn set_ldrbs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "External Trigger Status"]
#[must_use]
#[inline(always)]
pub const fn etrgs(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "External Trigger Status"]
#[inline(always)]
pub const fn set_etrgs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Clock Enabling Status"]
#[must_use]
#[inline(always)]
pub const fn clksta(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Clock Enabling Status"]
#[inline(always)]
pub const fn set_clksta(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "TIOA Mirror"]
#[must_use]
#[inline(always)]
pub const fn mtioa(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "TIOA Mirror"]
#[inline(always)]
pub const fn set_mtioa(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "TIOB Mirror"]
#[must_use]
#[inline(always)]
pub const fn mtiob(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "TIOB Mirror"]
#[inline(always)]
pub const fn set_mtiob(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
}
impl Default for Sr2 {
#[inline(always)]
fn default() -> Sr2 {
Sr2(0)
}
}
impl core::fmt::Debug for Sr2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Sr2")
.field("covfs", &self.covfs())
.field("lovrs", &self.lovrs())
.field("cpas", &self.cpas())
.field("cpbs", &self.cpbs())
.field("cpcs", &self.cpcs())
.field("ldras", &self.ldras())
.field("ldrbs", &self.ldrbs())
.field("etrgs", &self.etrgs())
.field("clksta", &self.clksta())
.field("mtioa", &self.mtioa())
.field("mtiob", &self.mtiob())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sr2 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Sr2 {{ covfs: {=bool:?}, lovrs: {=bool:?}, cpas: {=bool:?}, cpbs: {=bool:?}, cpcs: {=bool:?}, ldras: {=bool:?}, ldrbs: {=bool:?}, etrgs: {=bool:?}, clksta: {=bool:?}, mtioa: {=bool:?}, mtiob: {=bool:?} }}",
self.covfs(),
self.lovrs(),
self.cpas(),
self.cpbs(),
self.cpcs(),
self.ldras(),
self.ldrbs(),
self.etrgs(),
self.clksta(),
self.mtioa(),
self.mtiob()
)
}
}
#[doc = "Write Protect Mode Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Wpmr(pub u32);
impl Wpmr {
#[doc = "Write Protect Enable"]
#[must_use]
#[inline(always)]
pub const fn wpen(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Write Protect Enable"]
#[inline(always)]
pub const fn set_wpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Write Protect KEY"]
#[must_use]
#[inline(always)]
pub const fn wpkey(&self) -> super::vals::WpKey {
let val = (self.0 >> 8usize) & 0x00ff_ffff;
super::vals::WpKey::from_bits(val as u32)
}
#[doc = "Write Protect KEY"]
#[inline(always)]
pub const fn set_wpkey(&mut self, val: super::vals::WpKey) {
self.0 = (self.0 & !(0x00ff_ffff << 8usize))
| (((val.to_bits() as u32) & 0x00ff_ffff) << 8usize);
}
}
impl Default for Wpmr {
#[inline(always)]
fn default() -> Wpmr {
Wpmr(0)
}
}
impl core::fmt::Debug for Wpmr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Wpmr")
.field("wpen", &self.wpen())
.field("wpkey", &self.wpkey())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Wpmr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Wpmr {{ wpen: {=bool:?}, wpkey: {:?} }}",
self.wpen(),
self.wpkey()
)
}
}