#[doc = "Clock Mode Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cmr(pub u32);
impl Cmr {
#[doc = "Clock Divider"]
#[must_use]
#[inline(always)]
pub const fn div(&self) -> u16 {
let val = (self.0 >> 0usize) & 0x0fff;
val as u16
}
#[doc = "Clock Divider"]
#[inline(always)]
pub const fn set_div(&mut self, val: u16) {
self.0 = (self.0 & !(0x0fff << 0usize)) | (((val as u32) & 0x0fff) << 0usize);
}
}
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("div", &self.div()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cmr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Cmr {{ div: {=u16:?} }}", self.div())
}
}
#[doc = "Control Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cr(pub u32);
impl Cr {
#[doc = "Receive Enable"]
#[must_use]
#[inline(always)]
pub const fn rxen(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Receive Enable"]
#[inline(always)]
pub const fn set_rxen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Receive Disable"]
#[must_use]
#[inline(always)]
pub const fn rxdis(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Receive Disable"]
#[inline(always)]
pub const fn set_rxdis(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Transmit Enable"]
#[must_use]
#[inline(always)]
pub const fn txen(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Transmit Enable"]
#[inline(always)]
pub const fn set_txen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Transmit Disable"]
#[must_use]
#[inline(always)]
pub const fn txdis(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Transmit Disable"]
#[inline(always)]
pub const fn set_txdis(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Software Reset"]
#[must_use]
#[inline(always)]
pub const fn swrst(&self) -> bool {
let val = (self.0 >> 15usize) & 0x01;
val != 0
}
#[doc = "Software Reset"]
#[inline(always)]
pub const fn set_swrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
}
}
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("rxen", &self.rxen())
.field("rxdis", &self.rxdis())
.field("txen", &self.txen())
.field("txdis", &self.txdis())
.field("swrst", &self.swrst())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Cr {{ rxen: {=bool:?}, rxdis: {=bool:?}, txen: {=bool:?}, txdis: {=bool:?}, swrst: {=bool:?} }}",
self.rxen(),
self.rxdis(),
self.txen(),
self.txdis(),
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 = "Transmit Empty Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn txempty(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Transmit Empty Interrupt Disable"]
#[inline(always)]
pub const fn set_txempty(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Receive Ready Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn rxrdy(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Receive Ready Interrupt Disable"]
#[inline(always)]
pub const fn set_rxrdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Receive Overrun Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn ovrun(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Receive Overrun Interrupt Disable"]
#[inline(always)]
pub const fn set_ovrun(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Compare 0 Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn cp0(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Compare 0 Interrupt Disable"]
#[inline(always)]
pub const fn set_cp0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Compare 1 Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn cp1(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Compare 1 Interrupt Disable"]
#[inline(always)]
pub const fn set_cp1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Tx Sync Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn txsyn(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Tx Sync Interrupt Enable"]
#[inline(always)]
pub const fn set_txsyn(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Rx Sync Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn rxsyn(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Rx Sync Interrupt Enable"]
#[inline(always)]
pub const fn set_rxsyn(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
}
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("txempty", &self.txempty())
.field("rxrdy", &self.rxrdy())
.field("ovrun", &self.ovrun())
.field("cp0", &self.cp0())
.field("cp1", &self.cp1())
.field("txsyn", &self.txsyn())
.field("rxsyn", &self.rxsyn())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Idr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Idr {{ txrdy: {=bool:?}, txempty: {=bool:?}, rxrdy: {=bool:?}, ovrun: {=bool:?}, cp0: {=bool:?}, cp1: {=bool:?}, txsyn: {=bool:?}, rxsyn: {=bool:?} }}",
self.txrdy(),
self.txempty(),
self.rxrdy(),
self.ovrun(),
self.cp0(),
self.cp1(),
self.txsyn(),
self.rxsyn()
)
}
}
#[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 = "Transmit Empty Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn txempty(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Transmit Empty Interrupt Enable"]
#[inline(always)]
pub const fn set_txempty(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Receive Ready Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn rxrdy(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Receive Ready Interrupt Enable"]
#[inline(always)]
pub const fn set_rxrdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Receive Overrun Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn ovrun(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Receive Overrun Interrupt Enable"]
#[inline(always)]
pub const fn set_ovrun(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Compare 0 Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn cp0(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Compare 0 Interrupt Enable"]
#[inline(always)]
pub const fn set_cp0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Compare 1 Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn cp1(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Compare 1 Interrupt Enable"]
#[inline(always)]
pub const fn set_cp1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Tx Sync Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn txsyn(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Tx Sync Interrupt Enable"]
#[inline(always)]
pub const fn set_txsyn(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Rx Sync Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn rxsyn(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Rx Sync Interrupt Enable"]
#[inline(always)]
pub const fn set_rxsyn(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
}
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("txempty", &self.txempty())
.field("rxrdy", &self.rxrdy())
.field("ovrun", &self.ovrun())
.field("cp0", &self.cp0())
.field("cp1", &self.cp1())
.field("txsyn", &self.txsyn())
.field("rxsyn", &self.rxsyn())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ier {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ier {{ txrdy: {=bool:?}, txempty: {=bool:?}, rxrdy: {=bool:?}, ovrun: {=bool:?}, cp0: {=bool:?}, cp1: {=bool:?}, txsyn: {=bool:?}, rxsyn: {=bool:?} }}",
self.txrdy(),
self.txempty(),
self.rxrdy(),
self.ovrun(),
self.cp0(),
self.cp1(),
self.txsyn(),
self.rxsyn()
)
}
}
#[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 = "Transmit Empty Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn txempty(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Transmit Empty Interrupt Mask"]
#[inline(always)]
pub const fn set_txempty(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Receive Ready Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn rxrdy(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Receive Ready Interrupt Mask"]
#[inline(always)]
pub const fn set_rxrdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Receive Overrun Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn ovrun(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Receive Overrun Interrupt Mask"]
#[inline(always)]
pub const fn set_ovrun(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Compare 0 Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn cp0(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Compare 0 Interrupt Mask"]
#[inline(always)]
pub const fn set_cp0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Compare 1 Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn cp1(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Compare 1 Interrupt Mask"]
#[inline(always)]
pub const fn set_cp1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Tx Sync Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn txsyn(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Tx Sync Interrupt Mask"]
#[inline(always)]
pub const fn set_txsyn(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Rx Sync Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn rxsyn(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Rx Sync Interrupt Mask"]
#[inline(always)]
pub const fn set_rxsyn(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
}
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("txempty", &self.txempty())
.field("rxrdy", &self.rxrdy())
.field("ovrun", &self.ovrun())
.field("cp0", &self.cp0())
.field("cp1", &self.cp1())
.field("txsyn", &self.txsyn())
.field("rxsyn", &self.rxsyn())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Imr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Imr {{ txrdy: {=bool:?}, txempty: {=bool:?}, rxrdy: {=bool:?}, ovrun: {=bool:?}, cp0: {=bool:?}, cp1: {=bool:?}, txsyn: {=bool:?}, rxsyn: {=bool:?} }}",
self.txrdy(),
self.txempty(),
self.rxrdy(),
self.ovrun(),
self.cp0(),
self.cp1(),
self.txsyn(),
self.rxsyn()
)
}
}
#[doc = "Receive Compare 0 Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rc0r(pub u32);
impl Rc0r {
#[doc = "Receive Compare Data 0"]
#[must_use]
#[inline(always)]
pub const fn cp0(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Receive Compare Data 0"]
#[inline(always)]
pub const fn set_cp0(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Rc0r {
#[inline(always)]
fn default() -> Rc0r {
Rc0r(0)
}
}
impl core::fmt::Debug for Rc0r {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rc0r").field("cp0", &self.cp0()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rc0r {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Rc0r {{ cp0: {=u16:?} }}", self.cp0())
}
}
#[doc = "Receive Compare 1 Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rc1r(pub u32);
impl Rc1r {
#[doc = "Receive Compare Data 1"]
#[must_use]
#[inline(always)]
pub const fn cp1(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Receive Compare Data 1"]
#[inline(always)]
pub const fn set_cp1(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Rc1r {
#[inline(always)]
fn default() -> Rc1r {
Rc1r(0)
}
}
impl core::fmt::Debug for Rc1r {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rc1r").field("cp1", &self.cp1()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rc1r {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Rc1r {{ cp1: {=u16:?} }}", self.cp1())
}
}
#[doc = "Receive Clock Mode Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rcmr(pub u32);
impl Rcmr {
#[doc = "Receive Clock Selection"]
#[must_use]
#[inline(always)]
pub const fn cks(&self) -> super::vals::RcmrCks {
let val = (self.0 >> 0usize) & 0x03;
super::vals::RcmrCks::from_bits(val as u8)
}
#[doc = "Receive Clock Selection"]
#[inline(always)]
pub const fn set_cks(&mut self, val: super::vals::RcmrCks) {
self.0 = (self.0 & !(0x03 << 0usize)) | (((val.to_bits() as u32) & 0x03) << 0usize);
}
#[doc = "Receive Clock Output Mode Selection"]
#[must_use]
#[inline(always)]
pub const fn cko(&self) -> super::vals::RcmrCko {
let val = (self.0 >> 2usize) & 0x07;
super::vals::RcmrCko::from_bits(val as u8)
}
#[doc = "Receive Clock Output Mode Selection"]
#[inline(always)]
pub const fn set_cko(&mut self, val: super::vals::RcmrCko) {
self.0 = (self.0 & !(0x07 << 2usize)) | (((val.to_bits() as u32) & 0x07) << 2usize);
}
#[doc = "Receive Clock Inversion"]
#[must_use]
#[inline(always)]
pub const fn cki(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Receive Clock Inversion"]
#[inline(always)]
pub const fn set_cki(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Receive Clock Gating Selection"]
#[must_use]
#[inline(always)]
pub const fn ckg(&self) -> super::vals::RcmrCkg {
let val = (self.0 >> 6usize) & 0x03;
super::vals::RcmrCkg::from_bits(val as u8)
}
#[doc = "Receive Clock Gating Selection"]
#[inline(always)]
pub const fn set_ckg(&mut self, val: super::vals::RcmrCkg) {
self.0 = (self.0 & !(0x03 << 6usize)) | (((val.to_bits() as u32) & 0x03) << 6usize);
}
#[doc = "Receive Start Selection"]
#[must_use]
#[inline(always)]
pub const fn start(&self) -> super::vals::RcmrStart {
let val = (self.0 >> 8usize) & 0x0f;
super::vals::RcmrStart::from_bits(val as u8)
}
#[doc = "Receive Start Selection"]
#[inline(always)]
pub const fn set_start(&mut self, val: super::vals::RcmrStart) {
self.0 = (self.0 & !(0x0f << 8usize)) | (((val.to_bits() as u32) & 0x0f) << 8usize);
}
#[doc = "Receive Stop Selection"]
#[must_use]
#[inline(always)]
pub const fn stop(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "Receive Stop Selection"]
#[inline(always)]
pub const fn set_stop(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Receive Start Delay"]
#[must_use]
#[inline(always)]
pub const fn sttdly(&self) -> u8 {
let val = (self.0 >> 16usize) & 0xff;
val as u8
}
#[doc = "Receive Start Delay"]
#[inline(always)]
pub const fn set_sttdly(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 16usize)) | (((val as u32) & 0xff) << 16usize);
}
#[doc = "Receive Period Divider Selection"]
#[must_use]
#[inline(always)]
pub const fn period(&self) -> u8 {
let val = (self.0 >> 24usize) & 0xff;
val as u8
}
#[doc = "Receive Period Divider Selection"]
#[inline(always)]
pub const fn set_period(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 24usize)) | (((val as u32) & 0xff) << 24usize);
}
}
impl Default for Rcmr {
#[inline(always)]
fn default() -> Rcmr {
Rcmr(0)
}
}
impl core::fmt::Debug for Rcmr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rcmr")
.field("cks", &self.cks())
.field("cko", &self.cko())
.field("cki", &self.cki())
.field("ckg", &self.ckg())
.field("start", &self.start())
.field("stop", &self.stop())
.field("sttdly", &self.sttdly())
.field("period", &self.period())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rcmr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Rcmr {{ cks: {:?}, cko: {:?}, cki: {=bool:?}, ckg: {:?}, start: {:?}, stop: {=bool:?}, sttdly: {=u8:?}, period: {=u8:?} }}",
self.cks(),
self.cko(),
self.cki(),
self.ckg(),
self.start(),
self.stop(),
self.sttdly(),
self.period()
)
}
}
#[doc = "Receive Frame Mode Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rfmr(pub u32);
impl Rfmr {
#[doc = "Data Length"]
#[must_use]
#[inline(always)]
pub const fn datlen(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x1f;
val as u8
}
#[doc = "Data Length"]
#[inline(always)]
pub const fn set_datlen(&mut self, val: u8) {
self.0 = (self.0 & !(0x1f << 0usize)) | (((val as u32) & 0x1f) << 0usize);
}
#[doc = "Loop Mode"]
#[must_use]
#[inline(always)]
pub const fn loop_(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Loop Mode"]
#[inline(always)]
pub const fn set_loop_(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Most Significant Bit First"]
#[must_use]
#[inline(always)]
pub const fn msbf(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Most Significant Bit First"]
#[inline(always)]
pub const fn set_msbf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Data Number per Frame"]
#[must_use]
#[inline(always)]
pub const fn datnb(&self) -> u8 {
let val = (self.0 >> 8usize) & 0x0f;
val as u8
}
#[doc = "Data Number per Frame"]
#[inline(always)]
pub const fn set_datnb(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 8usize)) | (((val as u32) & 0x0f) << 8usize);
}
#[doc = "Receive Frame Sync Length"]
#[must_use]
#[inline(always)]
pub const fn fslen(&self) -> u8 {
let val = (self.0 >> 16usize) & 0x0f;
val as u8
}
#[doc = "Receive Frame Sync Length"]
#[inline(always)]
pub const fn set_fslen(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 16usize)) | (((val as u32) & 0x0f) << 16usize);
}
#[doc = "Receive Frame Sync Output Selection"]
#[must_use]
#[inline(always)]
pub const fn fsos(&self) -> super::vals::RfmrFsos {
let val = (self.0 >> 20usize) & 0x07;
super::vals::RfmrFsos::from_bits(val as u8)
}
#[doc = "Receive Frame Sync Output Selection"]
#[inline(always)]
pub const fn set_fsos(&mut self, val: super::vals::RfmrFsos) {
self.0 = (self.0 & !(0x07 << 20usize)) | (((val.to_bits() as u32) & 0x07) << 20usize);
}
#[doc = "Frame Sync Edge Detection"]
#[must_use]
#[inline(always)]
pub const fn fsedge(&self) -> super::vals::RfmrFsedge {
let val = (self.0 >> 24usize) & 0x01;
super::vals::RfmrFsedge::from_bits(val as u8)
}
#[doc = "Frame Sync Edge Detection"]
#[inline(always)]
pub const fn set_fsedge(&mut self, val: super::vals::RfmrFsedge) {
self.0 = (self.0 & !(0x01 << 24usize)) | (((val.to_bits() as u32) & 0x01) << 24usize);
}
#[doc = "FSLEN Field Extension"]
#[must_use]
#[inline(always)]
pub const fn fslen_ext(&self) -> u8 {
let val = (self.0 >> 28usize) & 0x0f;
val as u8
}
#[doc = "FSLEN Field Extension"]
#[inline(always)]
pub const fn set_fslen_ext(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 28usize)) | (((val as u32) & 0x0f) << 28usize);
}
}
impl Default for Rfmr {
#[inline(always)]
fn default() -> Rfmr {
Rfmr(0)
}
}
impl core::fmt::Debug for Rfmr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rfmr")
.field("datlen", &self.datlen())
.field("loop_", &self.loop_())
.field("msbf", &self.msbf())
.field("datnb", &self.datnb())
.field("fslen", &self.fslen())
.field("fsos", &self.fsos())
.field("fsedge", &self.fsedge())
.field("fslen_ext", &self.fslen_ext())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rfmr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Rfmr {{ datlen: {=u8:?}, loop_: {=bool:?}, msbf: {=bool:?}, datnb: {=u8:?}, fslen: {=u8:?}, fsos: {:?}, fsedge: {:?}, fslen_ext: {=u8:?} }}",
self.datlen(),
self.loop_(),
self.msbf(),
self.datnb(),
self.fslen(),
self.fsos(),
self.fsedge(),
self.fslen_ext()
)
}
}
#[doc = "Receive Holding Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rhr(pub u32);
impl Rhr {
#[doc = "Receive Data"]
#[must_use]
#[inline(always)]
pub const fn rdat(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Receive Data"]
#[inline(always)]
pub const fn set_rdat(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Rhr {
#[inline(always)]
fn default() -> Rhr {
Rhr(0)
}
}
impl core::fmt::Debug for Rhr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rhr").field("rdat", &self.rdat()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rhr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Rhr {{ rdat: {=u32:?} }}", self.rdat())
}
}
#[doc = "Receive Sync. Holding Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rshr(pub u32);
impl Rshr {
#[doc = "Receive Synchronization Data"]
#[must_use]
#[inline(always)]
pub const fn rsdat(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Receive Synchronization Data"]
#[inline(always)]
pub const fn set_rsdat(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Rshr {
#[inline(always)]
fn default() -> Rshr {
Rshr(0)
}
}
impl core::fmt::Debug for Rshr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rshr")
.field("rsdat", &self.rsdat())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rshr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Rshr {{ rsdat: {=u16:?} }}", self.rsdat())
}
}
#[doc = "Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sr(pub u32);
impl Sr {
#[doc = "Transmit Ready"]
#[must_use]
#[inline(always)]
pub const fn txrdy(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Transmit Ready"]
#[inline(always)]
pub const fn set_txrdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Transmit Empty"]
#[must_use]
#[inline(always)]
pub const fn txempty(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Transmit Empty"]
#[inline(always)]
pub const fn set_txempty(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Receive Ready"]
#[must_use]
#[inline(always)]
pub const fn rxrdy(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Receive Ready"]
#[inline(always)]
pub const fn set_rxrdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Receive Overrun"]
#[must_use]
#[inline(always)]
pub const fn ovrun(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Receive Overrun"]
#[inline(always)]
pub const fn set_ovrun(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Compare 0"]
#[must_use]
#[inline(always)]
pub const fn cp0(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Compare 0"]
#[inline(always)]
pub const fn set_cp0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Compare 1"]
#[must_use]
#[inline(always)]
pub const fn cp1(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Compare 1"]
#[inline(always)]
pub const fn set_cp1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Transmit Sync"]
#[must_use]
#[inline(always)]
pub const fn txsyn(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Transmit Sync"]
#[inline(always)]
pub const fn set_txsyn(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Receive Sync"]
#[must_use]
#[inline(always)]
pub const fn rxsyn(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Receive Sync"]
#[inline(always)]
pub const fn set_rxsyn(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "Transmit Enable"]
#[must_use]
#[inline(always)]
pub const fn txen(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Transmit Enable"]
#[inline(always)]
pub const fn set_txen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "Receive Enable"]
#[must_use]
#[inline(always)]
pub const fn rxen(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "Receive Enable"]
#[inline(always)]
pub const fn set_rxen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
}
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("txrdy", &self.txrdy())
.field("txempty", &self.txempty())
.field("rxrdy", &self.rxrdy())
.field("ovrun", &self.ovrun())
.field("cp0", &self.cp0())
.field("cp1", &self.cp1())
.field("txsyn", &self.txsyn())
.field("rxsyn", &self.rxsyn())
.field("txen", &self.txen())
.field("rxen", &self.rxen())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Sr {{ txrdy: {=bool:?}, txempty: {=bool:?}, rxrdy: {=bool:?}, ovrun: {=bool:?}, cp0: {=bool:?}, cp1: {=bool:?}, txsyn: {=bool:?}, rxsyn: {=bool:?}, txen: {=bool:?}, rxen: {=bool:?} }}",
self.txrdy(),
self.txempty(),
self.rxrdy(),
self.ovrun(),
self.cp0(),
self.cp1(),
self.txsyn(),
self.rxsyn(),
self.txen(),
self.rxen()
)
}
}
#[doc = "Transmit Clock Mode Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tcmr(pub u32);
impl Tcmr {
#[doc = "Transmit Clock Selection"]
#[must_use]
#[inline(always)]
pub const fn cks(&self) -> super::vals::TcmrCks {
let val = (self.0 >> 0usize) & 0x03;
super::vals::TcmrCks::from_bits(val as u8)
}
#[doc = "Transmit Clock Selection"]
#[inline(always)]
pub const fn set_cks(&mut self, val: super::vals::TcmrCks) {
self.0 = (self.0 & !(0x03 << 0usize)) | (((val.to_bits() as u32) & 0x03) << 0usize);
}
#[doc = "Transmit Clock Output Mode Selection"]
#[must_use]
#[inline(always)]
pub const fn cko(&self) -> super::vals::TcmrCko {
let val = (self.0 >> 2usize) & 0x07;
super::vals::TcmrCko::from_bits(val as u8)
}
#[doc = "Transmit Clock Output Mode Selection"]
#[inline(always)]
pub const fn set_cko(&mut self, val: super::vals::TcmrCko) {
self.0 = (self.0 & !(0x07 << 2usize)) | (((val.to_bits() as u32) & 0x07) << 2usize);
}
#[doc = "Transmit Clock Inversion"]
#[must_use]
#[inline(always)]
pub const fn cki(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Transmit Clock Inversion"]
#[inline(always)]
pub const fn set_cki(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Transmit Clock Gating Selection"]
#[must_use]
#[inline(always)]
pub const fn ckg(&self) -> super::vals::TcmrCkg {
let val = (self.0 >> 6usize) & 0x03;
super::vals::TcmrCkg::from_bits(val as u8)
}
#[doc = "Transmit Clock Gating Selection"]
#[inline(always)]
pub const fn set_ckg(&mut self, val: super::vals::TcmrCkg) {
self.0 = (self.0 & !(0x03 << 6usize)) | (((val.to_bits() as u32) & 0x03) << 6usize);
}
#[doc = "Transmit Start Selection"]
#[must_use]
#[inline(always)]
pub const fn start(&self) -> super::vals::TcmrStart {
let val = (self.0 >> 8usize) & 0x0f;
super::vals::TcmrStart::from_bits(val as u8)
}
#[doc = "Transmit Start Selection"]
#[inline(always)]
pub const fn set_start(&mut self, val: super::vals::TcmrStart) {
self.0 = (self.0 & !(0x0f << 8usize)) | (((val.to_bits() as u32) & 0x0f) << 8usize);
}
#[doc = "Transmit Start Delay"]
#[must_use]
#[inline(always)]
pub const fn sttdly(&self) -> u8 {
let val = (self.0 >> 16usize) & 0xff;
val as u8
}
#[doc = "Transmit Start Delay"]
#[inline(always)]
pub const fn set_sttdly(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 16usize)) | (((val as u32) & 0xff) << 16usize);
}
#[doc = "Transmit Period Divider Selection"]
#[must_use]
#[inline(always)]
pub const fn period(&self) -> u8 {
let val = (self.0 >> 24usize) & 0xff;
val as u8
}
#[doc = "Transmit Period Divider Selection"]
#[inline(always)]
pub const fn set_period(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 24usize)) | (((val as u32) & 0xff) << 24usize);
}
}
impl Default for Tcmr {
#[inline(always)]
fn default() -> Tcmr {
Tcmr(0)
}
}
impl core::fmt::Debug for Tcmr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Tcmr")
.field("cks", &self.cks())
.field("cko", &self.cko())
.field("cki", &self.cki())
.field("ckg", &self.ckg())
.field("start", &self.start())
.field("sttdly", &self.sttdly())
.field("period", &self.period())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Tcmr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Tcmr {{ cks: {:?}, cko: {:?}, cki: {=bool:?}, ckg: {:?}, start: {:?}, sttdly: {=u8:?}, period: {=u8:?} }}",
self.cks(),
self.cko(),
self.cki(),
self.ckg(),
self.start(),
self.sttdly(),
self.period()
)
}
}
#[doc = "Transmit Frame Mode Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tfmr(pub u32);
impl Tfmr {
#[doc = "Data Length"]
#[must_use]
#[inline(always)]
pub const fn datlen(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x1f;
val as u8
}
#[doc = "Data Length"]
#[inline(always)]
pub const fn set_datlen(&mut self, val: u8) {
self.0 = (self.0 & !(0x1f << 0usize)) | (((val as u32) & 0x1f) << 0usize);
}
#[doc = "Data Default Value"]
#[must_use]
#[inline(always)]
pub const fn datdef(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Data Default Value"]
#[inline(always)]
pub const fn set_datdef(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Most Significant Bit First"]
#[must_use]
#[inline(always)]
pub const fn msbf(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Most Significant Bit First"]
#[inline(always)]
pub const fn set_msbf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Data Number per frame"]
#[must_use]
#[inline(always)]
pub const fn datnb(&self) -> u8 {
let val = (self.0 >> 8usize) & 0x0f;
val as u8
}
#[doc = "Data Number per frame"]
#[inline(always)]
pub const fn set_datnb(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 8usize)) | (((val as u32) & 0x0f) << 8usize);
}
#[doc = "Transmit Frame Sync Length"]
#[must_use]
#[inline(always)]
pub const fn fslen(&self) -> u8 {
let val = (self.0 >> 16usize) & 0x0f;
val as u8
}
#[doc = "Transmit Frame Sync Length"]
#[inline(always)]
pub const fn set_fslen(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 16usize)) | (((val as u32) & 0x0f) << 16usize);
}
#[doc = "Transmit Frame Sync Output Selection"]
#[must_use]
#[inline(always)]
pub const fn fsos(&self) -> super::vals::TfmrFsos {
let val = (self.0 >> 20usize) & 0x07;
super::vals::TfmrFsos::from_bits(val as u8)
}
#[doc = "Transmit Frame Sync Output Selection"]
#[inline(always)]
pub const fn set_fsos(&mut self, val: super::vals::TfmrFsos) {
self.0 = (self.0 & !(0x07 << 20usize)) | (((val.to_bits() as u32) & 0x07) << 20usize);
}
#[doc = "Frame Sync Data Enable"]
#[must_use]
#[inline(always)]
pub const fn fsden(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[doc = "Frame Sync Data Enable"]
#[inline(always)]
pub const fn set_fsden(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
#[doc = "Frame Sync Edge Detection"]
#[must_use]
#[inline(always)]
pub const fn fsedge(&self) -> super::vals::TfmrFsedge {
let val = (self.0 >> 24usize) & 0x01;
super::vals::TfmrFsedge::from_bits(val as u8)
}
#[doc = "Frame Sync Edge Detection"]
#[inline(always)]
pub const fn set_fsedge(&mut self, val: super::vals::TfmrFsedge) {
self.0 = (self.0 & !(0x01 << 24usize)) | (((val.to_bits() as u32) & 0x01) << 24usize);
}
#[doc = "FSLEN Field Extension"]
#[must_use]
#[inline(always)]
pub const fn fslen_ext(&self) -> u8 {
let val = (self.0 >> 28usize) & 0x0f;
val as u8
}
#[doc = "FSLEN Field Extension"]
#[inline(always)]
pub const fn set_fslen_ext(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 28usize)) | (((val as u32) & 0x0f) << 28usize);
}
}
impl Default for Tfmr {
#[inline(always)]
fn default() -> Tfmr {
Tfmr(0)
}
}
impl core::fmt::Debug for Tfmr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Tfmr")
.field("datlen", &self.datlen())
.field("datdef", &self.datdef())
.field("msbf", &self.msbf())
.field("datnb", &self.datnb())
.field("fslen", &self.fslen())
.field("fsos", &self.fsos())
.field("fsden", &self.fsden())
.field("fsedge", &self.fsedge())
.field("fslen_ext", &self.fslen_ext())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Tfmr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Tfmr {{ datlen: {=u8:?}, datdef: {=bool:?}, msbf: {=bool:?}, datnb: {=u8:?}, fslen: {=u8:?}, fsos: {:?}, fsden: {=bool:?}, fsedge: {:?}, fslen_ext: {=u8:?} }}",
self.datlen(),
self.datdef(),
self.msbf(),
self.datnb(),
self.fslen(),
self.fsos(),
self.fsden(),
self.fsedge(),
self.fslen_ext()
)
}
}
#[doc = "Transmit Holding Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Thr(pub u32);
impl Thr {
#[doc = "Transmit Data"]
#[must_use]
#[inline(always)]
pub const fn tdat(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Transmit Data"]
#[inline(always)]
pub const fn set_tdat(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Thr {
#[inline(always)]
fn default() -> Thr {
Thr(0)
}
}
impl core::fmt::Debug for Thr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Thr").field("tdat", &self.tdat()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Thr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Thr {{ tdat: {=u32:?} }}", self.tdat())
}
}
#[doc = "Transmit Sync. Holding Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tshr(pub u32);
impl Tshr {
#[doc = "Transmit Synchronization Data"]
#[must_use]
#[inline(always)]
pub const fn tsdat(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Transmit Synchronization Data"]
#[inline(always)]
pub const fn set_tsdat(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Tshr {
#[inline(always)]
fn default() -> Tshr {
Tshr(0)
}
}
impl core::fmt::Debug for Tshr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Tshr")
.field("tsdat", &self.tsdat())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Tshr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Tshr {{ tsdat: {=u16:?} }}", self.tsdat())
}
}
#[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()
)
}
}