#[doc = "Analog Current Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Acr(pub u32);
impl Acr {
#[doc = "Analog Output Current Control"]
#[must_use]
#[inline(always)]
pub const fn ibctlch0(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x03;
val as u8
}
#[doc = "Analog Output Current Control"]
#[inline(always)]
pub const fn set_ibctlch0(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 0usize)) | (((val as u32) & 0x03) << 0usize);
}
#[doc = "Analog Output Current Control"]
#[must_use]
#[inline(always)]
pub const fn ibctlch1(&self) -> u8 {
let val = (self.0 >> 2usize) & 0x03;
val as u8
}
#[doc = "Analog Output Current Control"]
#[inline(always)]
pub const fn set_ibctlch1(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 2usize)) | (((val as u32) & 0x03) << 2usize);
}
#[doc = "Bias Current Control for DAC Core"]
#[must_use]
#[inline(always)]
pub const fn ibctldaccore(&self) -> u8 {
let val = (self.0 >> 8usize) & 0x03;
val as u8
}
#[doc = "Bias Current Control for DAC Core"]
#[inline(always)]
pub const fn set_ibctldaccore(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 8usize)) | (((val as u32) & 0x03) << 8usize);
}
}
impl Default for Acr {
#[inline(always)]
fn default() -> Acr {
Acr(0)
}
}
impl core::fmt::Debug for Acr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Acr")
.field("ibctlch0", &self.ibctlch0())
.field("ibctlch1", &self.ibctlch1())
.field("ibctldaccore", &self.ibctldaccore())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Acr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Acr {{ ibctlch0: {=u8:?}, ibctlch1: {=u8:?}, ibctldaccore: {=u8:?} }}",
self.ibctlch0(),
self.ibctlch1(),
self.ibctldaccore()
)
}
}
#[doc = "Conversion Data Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cdr(pub u32);
impl Cdr {
#[doc = "Data to Convert"]
#[must_use]
#[inline(always)]
pub const fn data(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Data to Convert"]
#[inline(always)]
pub const fn set_data(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Cdr {
#[inline(always)]
fn default() -> Cdr {
Cdr(0)
}
}
impl core::fmt::Debug for Cdr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cdr").field("data", &self.data()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cdr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Cdr {{ data: {=u32:?} }}", self.data())
}
}
#[doc = "Channel Disable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Chdr(pub u32);
impl Chdr {
#[doc = "Channel 0 Disable"]
#[must_use]
#[inline(always)]
pub const fn ch0(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Channel 0 Disable"]
#[inline(always)]
pub const fn set_ch0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Channel 1 Disable"]
#[must_use]
#[inline(always)]
pub const fn ch1(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Channel 1 Disable"]
#[inline(always)]
pub const fn set_ch1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
}
impl Default for Chdr {
#[inline(always)]
fn default() -> Chdr {
Chdr(0)
}
}
impl core::fmt::Debug for Chdr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Chdr")
.field("ch0", &self.ch0())
.field("ch1", &self.ch1())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Chdr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Chdr {{ ch0: {=bool:?}, ch1: {=bool:?} }}",
self.ch0(),
self.ch1()
)
}
}
#[doc = "Channel Enable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cher(pub u32);
impl Cher {
#[doc = "Channel 0 Enable"]
#[must_use]
#[inline(always)]
pub const fn ch0(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Channel 0 Enable"]
#[inline(always)]
pub const fn set_ch0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Channel 1 Enable"]
#[must_use]
#[inline(always)]
pub const fn ch1(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Channel 1 Enable"]
#[inline(always)]
pub const fn set_ch1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
}
impl Default for Cher {
#[inline(always)]
fn default() -> Cher {
Cher(0)
}
}
impl core::fmt::Debug for Cher {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cher")
.field("ch0", &self.ch0())
.field("ch1", &self.ch1())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cher {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Cher {{ ch0: {=bool:?}, ch1: {=bool:?} }}",
self.ch0(),
self.ch1()
)
}
}
#[doc = "Channel Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Chsr(pub u32);
impl Chsr {
#[doc = "Channel 0 Status"]
#[must_use]
#[inline(always)]
pub const fn ch0(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Channel 0 Status"]
#[inline(always)]
pub const fn set_ch0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Channel 1 Status"]
#[must_use]
#[inline(always)]
pub const fn ch1(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Channel 1 Status"]
#[inline(always)]
pub const fn set_ch1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
}
impl Default for Chsr {
#[inline(always)]
fn default() -> Chsr {
Chsr(0)
}
}
impl core::fmt::Debug for Chsr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Chsr")
.field("ch0", &self.ch0())
.field("ch1", &self.ch1())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Chsr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Chsr {{ ch0: {=bool:?}, ch1: {=bool:?} }}",
self.ch0(),
self.ch1()
)
}
}
#[doc = "Control Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cr(pub u32);
impl Cr {
#[doc = "Software Reset"]
#[must_use]
#[inline(always)]
pub const fn swrst(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Software Reset"]
#[inline(always)]
pub const fn set_swrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
}
impl Default for Cr {
#[inline(always)]
fn default() -> Cr {
Cr(0)
}
}
impl core::fmt::Debug for Cr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cr").field("swrst", &self.swrst()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Cr {{ swrst: {=bool:?} }}", self.swrst())
}
}
#[doc = "Interrupt Disable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Idr(pub u32);
impl Idr {
#[doc = "Transmit Ready Interrupt Disable."]
#[must_use]
#[inline(always)]
pub const fn txrdy(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Transmit Ready Interrupt Disable."]
#[inline(always)]
pub const fn set_txrdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "End of Conversion Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn eoc(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "End of Conversion Interrupt Disable"]
#[inline(always)]
pub const fn set_eoc(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "End of Transmit Buffer Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn endtx(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "End of Transmit Buffer Interrupt Disable"]
#[inline(always)]
pub const fn set_endtx(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Transmit Buffer Empty Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn txbufe(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Transmit Buffer Empty Interrupt Disable"]
#[inline(always)]
pub const fn set_txbufe(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
}
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("txrdy", &self.txrdy())
.field("eoc", &self.eoc())
.field("endtx", &self.endtx())
.field("txbufe", &self.txbufe())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Idr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Idr {{ txrdy: {=bool:?}, eoc: {=bool:?}, endtx: {=bool:?}, txbufe: {=bool:?} }}",
self.txrdy(),
self.eoc(),
self.endtx(),
self.txbufe()
)
}
}
#[doc = "Interrupt Enable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ier(pub u32);
impl Ier {
#[doc = "Transmit Ready Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn txrdy(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Transmit Ready Interrupt Enable"]
#[inline(always)]
pub const fn set_txrdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "End of Conversion Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn eoc(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "End of Conversion Interrupt Enable"]
#[inline(always)]
pub const fn set_eoc(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "End of Transmit Buffer Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn endtx(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "End of Transmit Buffer Interrupt Enable"]
#[inline(always)]
pub const fn set_endtx(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Transmit Buffer Empty Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn txbufe(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Transmit Buffer Empty Interrupt Enable"]
#[inline(always)]
pub const fn set_txbufe(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
}
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("txrdy", &self.txrdy())
.field("eoc", &self.eoc())
.field("endtx", &self.endtx())
.field("txbufe", &self.txbufe())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ier {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ier {{ txrdy: {=bool:?}, eoc: {=bool:?}, endtx: {=bool:?}, txbufe: {=bool:?} }}",
self.txrdy(),
self.eoc(),
self.endtx(),
self.txbufe()
)
}
}
#[doc = "Interrupt Mask Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Imr(pub u32);
impl Imr {
#[doc = "Transmit Ready Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn txrdy(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Transmit Ready Interrupt Mask"]
#[inline(always)]
pub const fn set_txrdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "End of Conversion Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn eoc(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "End of Conversion Interrupt Mask"]
#[inline(always)]
pub const fn set_eoc(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "End of Transmit Buffer Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn endtx(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "End of Transmit Buffer Interrupt Mask"]
#[inline(always)]
pub const fn set_endtx(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Transmit Buffer Empty Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn txbufe(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Transmit Buffer Empty Interrupt Mask"]
#[inline(always)]
pub const fn set_txbufe(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
}
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("txrdy", &self.txrdy())
.field("eoc", &self.eoc())
.field("endtx", &self.endtx())
.field("txbufe", &self.txbufe())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Imr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Imr {{ txrdy: {=bool:?}, eoc: {=bool:?}, endtx: {=bool:?}, txbufe: {=bool:?} }}",
self.txrdy(),
self.eoc(),
self.endtx(),
self.txbufe()
)
}
}
#[doc = "Interrupt Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Isr(pub u32);
impl Isr {
#[doc = "Transmit Ready Interrupt Flag"]
#[must_use]
#[inline(always)]
pub const fn txrdy(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Transmit Ready Interrupt Flag"]
#[inline(always)]
pub const fn set_txrdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "End of Conversion Interrupt Flag"]
#[must_use]
#[inline(always)]
pub const fn eoc(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "End of Conversion Interrupt Flag"]
#[inline(always)]
pub const fn set_eoc(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "End of DMA Interrupt Flag"]
#[must_use]
#[inline(always)]
pub const fn endtx(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "End of DMA Interrupt Flag"]
#[inline(always)]
pub const fn set_endtx(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Transmit Buffer Empty"]
#[must_use]
#[inline(always)]
pub const fn txbufe(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Transmit Buffer Empty"]
#[inline(always)]
pub const fn set_txbufe(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
}
impl Default for Isr {
#[inline(always)]
fn default() -> Isr {
Isr(0)
}
}
impl core::fmt::Debug for Isr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Isr")
.field("txrdy", &self.txrdy())
.field("eoc", &self.eoc())
.field("endtx", &self.endtx())
.field("txbufe", &self.txbufe())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Isr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Isr {{ txrdy: {=bool:?}, eoc: {=bool:?}, endtx: {=bool:?}, txbufe: {=bool:?} }}",
self.txrdy(),
self.eoc(),
self.endtx(),
self.txbufe()
)
}
}
#[doc = "Mode Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Mr(pub u32);
impl Mr {
#[doc = "Trigger Enable"]
#[must_use]
#[inline(always)]
pub const fn trgen(&self) -> super::vals::Trgen {
let val = (self.0 >> 0usize) & 0x01;
super::vals::Trgen::from_bits(val as u8)
}
#[doc = "Trigger Enable"]
#[inline(always)]
pub const fn set_trgen(&mut self, val: super::vals::Trgen) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val.to_bits() as u32) & 0x01) << 0usize);
}
#[doc = "Trigger Selection"]
#[must_use]
#[inline(always)]
pub const fn trgsel(&self) -> u8 {
let val = (self.0 >> 1usize) & 0x07;
val as u8
}
#[doc = "Trigger Selection"]
#[inline(always)]
pub const fn set_trgsel(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 1usize)) | (((val as u32) & 0x07) << 1usize);
}
#[doc = "Word Transfer"]
#[must_use]
#[inline(always)]
pub const fn word(&self) -> super::vals::Word {
let val = (self.0 >> 4usize) & 0x01;
super::vals::Word::from_bits(val as u8)
}
#[doc = "Word Transfer"]
#[inline(always)]
pub const fn set_word(&mut self, val: super::vals::Word) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val.to_bits() as u32) & 0x01) << 4usize);
}
#[doc = "Sleep Mode"]
#[must_use]
#[inline(always)]
pub const fn sleep(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Sleep Mode"]
#[inline(always)]
pub const fn set_sleep(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Fast Wake up Mode"]
#[must_use]
#[inline(always)]
pub const fn fastwkup(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Fast Wake up Mode"]
#[inline(always)]
pub const fn set_fastwkup(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Refresh Period"]
#[must_use]
#[inline(always)]
pub const fn refresh(&self) -> u8 {
let val = (self.0 >> 8usize) & 0xff;
val as u8
}
#[doc = "Refresh Period"]
#[inline(always)]
pub const fn set_refresh(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 8usize)) | (((val as u32) & 0xff) << 8usize);
}
#[doc = "User Channel Selection"]
#[must_use]
#[inline(always)]
pub const fn user_sel(&self) -> super::vals::UserSel {
let val = (self.0 >> 16usize) & 0x03;
super::vals::UserSel::from_bits(val as u8)
}
#[doc = "User Channel Selection"]
#[inline(always)]
pub const fn set_user_sel(&mut self, val: super::vals::UserSel) {
self.0 = (self.0 & !(0x03 << 16usize)) | (((val.to_bits() as u32) & 0x03) << 16usize);
}
#[doc = "Tag Selection Mode"]
#[must_use]
#[inline(always)]
pub const fn tag(&self) -> super::vals::Tag {
let val = (self.0 >> 20usize) & 0x01;
super::vals::Tag::from_bits(val as u8)
}
#[doc = "Tag Selection Mode"]
#[inline(always)]
pub const fn set_tag(&mut self, val: super::vals::Tag) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val.to_bits() as u32) & 0x01) << 20usize);
}
#[doc = "Max Speed Mode"]
#[must_use]
#[inline(always)]
pub const fn maxs(&self) -> super::vals::Maxs {
let val = (self.0 >> 21usize) & 0x01;
super::vals::Maxs::from_bits(val as u8)
}
#[doc = "Max Speed Mode"]
#[inline(always)]
pub const fn set_maxs(&mut self, val: super::vals::Maxs) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val.to_bits() as u32) & 0x01) << 21usize);
}
#[doc = "Startup Time Selection"]
#[must_use]
#[inline(always)]
pub const fn startup(&self) -> super::vals::Startup {
let val = (self.0 >> 24usize) & 0x3f;
super::vals::Startup::from_bits(val as u8)
}
#[doc = "Startup Time Selection"]
#[inline(always)]
pub const fn set_startup(&mut self, val: super::vals::Startup) {
self.0 = (self.0 & !(0x3f << 24usize)) | (((val.to_bits() as u32) & 0x3f) << 24usize);
}
}
impl Default for Mr {
#[inline(always)]
fn default() -> Mr {
Mr(0)
}
}
impl core::fmt::Debug for Mr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Mr")
.field("trgen", &self.trgen())
.field("trgsel", &self.trgsel())
.field("word", &self.word())
.field("sleep", &self.sleep())
.field("fastwkup", &self.fastwkup())
.field("refresh", &self.refresh())
.field("user_sel", &self.user_sel())
.field("tag", &self.tag())
.field("maxs", &self.maxs())
.field("startup", &self.startup())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Mr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Mr {{ trgen: {:?}, trgsel: {=u8:?}, word: {:?}, sleep: {=bool:?}, fastwkup: {=bool:?}, refresh: {=u8:?}, user_sel: {:?}, tag: {:?}, maxs: {:?}, startup: {:?} }}",
self.trgen(),
self.trgsel(),
self.word(),
self.sleep(),
self.fastwkup(),
self.refresh(),
self.user_sel(),
self.tag(),
self.maxs(),
self.startup()
)
}
}
#[doc = "Transfer Control Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ptcr(pub u32);
impl Ptcr {
#[doc = "Receiver Transfer Enable"]
#[must_use]
#[inline(always)]
pub const fn rxten(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Receiver Transfer Enable"]
#[inline(always)]
pub const fn set_rxten(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Receiver Transfer Disable"]
#[must_use]
#[inline(always)]
pub const fn rxtdis(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Receiver Transfer Disable"]
#[inline(always)]
pub const fn set_rxtdis(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Transmitter Transfer Enable"]
#[must_use]
#[inline(always)]
pub const fn txten(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Transmitter Transfer Enable"]
#[inline(always)]
pub const fn set_txten(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Transmitter Transfer Disable"]
#[must_use]
#[inline(always)]
pub const fn txtdis(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Transmitter Transfer Disable"]
#[inline(always)]
pub const fn set_txtdis(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
}
impl Default for Ptcr {
#[inline(always)]
fn default() -> Ptcr {
Ptcr(0)
}
}
impl core::fmt::Debug for Ptcr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ptcr")
.field("rxten", &self.rxten())
.field("rxtdis", &self.rxtdis())
.field("txten", &self.txten())
.field("txtdis", &self.txtdis())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ptcr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ptcr {{ rxten: {=bool:?}, rxtdis: {=bool:?}, txten: {=bool:?}, txtdis: {=bool:?} }}",
self.rxten(),
self.rxtdis(),
self.txten(),
self.txtdis()
)
}
}
#[doc = "Transfer Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ptsr(pub u32);
impl Ptsr {
#[doc = "Receiver Transfer Enable"]
#[must_use]
#[inline(always)]
pub const fn rxten(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Receiver Transfer Enable"]
#[inline(always)]
pub const fn set_rxten(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Transmitter Transfer Enable"]
#[must_use]
#[inline(always)]
pub const fn txten(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Transmitter Transfer Enable"]
#[inline(always)]
pub const fn set_txten(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
}
impl Default for Ptsr {
#[inline(always)]
fn default() -> Ptsr {
Ptsr(0)
}
}
impl core::fmt::Debug for Ptsr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ptsr")
.field("rxten", &self.rxten())
.field("txten", &self.txten())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ptsr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ptsr {{ rxten: {=bool:?}, txten: {=bool:?} }}",
self.rxten(),
self.txten()
)
}
}
#[doc = "Transmit Counter Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tcr(pub u32);
impl Tcr {
#[doc = "Transmit Counter Register"]
#[must_use]
#[inline(always)]
pub const fn txctr(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Transmit Counter Register"]
#[inline(always)]
pub const fn set_txctr(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Tcr {
#[inline(always)]
fn default() -> Tcr {
Tcr(0)
}
}
impl core::fmt::Debug for Tcr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Tcr").field("txctr", &self.txctr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Tcr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Tcr {{ txctr: {=u16:?} }}", self.txctr())
}
}
#[doc = "Transmit Next Counter Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tncr(pub u32);
impl Tncr {
#[doc = "Transmit Counter Next"]
#[must_use]
#[inline(always)]
pub const fn txnctr(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Transmit Counter Next"]
#[inline(always)]
pub const fn set_txnctr(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Tncr {
#[inline(always)]
fn default() -> Tncr {
Tncr(0)
}
}
impl core::fmt::Debug for Tncr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Tncr")
.field("txnctr", &self.txnctr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Tncr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Tncr {{ txnctr: {=u16:?} }}", self.txnctr())
}
}
#[doc = "Transmit Next Pointer Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tnpr(pub u32);
impl Tnpr {
#[doc = "Transmit Next Pointer"]
#[must_use]
#[inline(always)]
pub const fn txnptr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Transmit Next Pointer"]
#[inline(always)]
pub const fn set_txnptr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Tnpr {
#[inline(always)]
fn default() -> Tnpr {
Tnpr(0)
}
}
impl core::fmt::Debug for Tnpr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Tnpr")
.field("txnptr", &self.txnptr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Tnpr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Tnpr {{ txnptr: {=u32:?} }}", self.txnptr())
}
}
#[doc = "Transmit Pointer Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tpr(pub u32);
impl Tpr {
#[doc = "Transmit Counter Register"]
#[must_use]
#[inline(always)]
pub const fn txptr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Transmit Counter Register"]
#[inline(always)]
pub const fn set_txptr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Tpr {
#[inline(always)]
fn default() -> Tpr {
Tpr(0)
}
}
impl core::fmt::Debug for Tpr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Tpr").field("txptr", &self.txptr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Tpr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Tpr {{ txptr: {=u32:?} }}", self.txptr())
}
}
#[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) -> u32 {
let val = (self.0 >> 8usize) & 0x00ff_ffff;
val as u32
}
#[doc = "Write Protect KEY"]
#[inline(always)]
pub const fn set_wpkey(&mut self, val: u32) {
self.0 = (self.0 & !(0x00ff_ffff << 8usize)) | (((val 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: {=u32:?} }}",
self.wpen(),
self.wpkey()
)
}
}
#[doc = "Write Protect Status register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Wpsr(pub u32);
impl Wpsr {
#[doc = "Write protection error"]
#[must_use]
#[inline(always)]
pub const fn wproterr(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Write protection error"]
#[inline(always)]
pub const fn set_wproterr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Write protection error address"]
#[must_use]
#[inline(always)]
pub const fn wprotaddr(&self) -> u8 {
let val = (self.0 >> 8usize) & 0xff;
val as u8
}
#[doc = "Write protection error address"]
#[inline(always)]
pub const fn set_wprotaddr(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 8usize)) | (((val as u32) & 0xff) << 8usize);
}
}
impl Default for Wpsr {
#[inline(always)]
fn default() -> Wpsr {
Wpsr(0)
}
}
impl core::fmt::Debug for Wpsr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Wpsr")
.field("wproterr", &self.wproterr())
.field("wprotaddr", &self.wprotaddr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Wpsr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Wpsr {{ wproterr: {=bool:?}, wprotaddr: {=u8:?} }}",
self.wproterr(),
self.wprotaddr()
)
}
}