#[doc = "Abort Command Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Acr(pub u32);
impl Acr {
#[doc = "Abort Request for Mailbox 0"]
#[must_use]
#[inline(always)]
pub const fn mb(&self, n: usize) -> bool {
assert!(n < 8usize);
let offs = 0usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Abort Request for Mailbox 0"]
#[inline(always)]
pub const fn set_mb(&mut self, n: usize, val: bool) {
assert!(n < 8usize);
let offs = 0usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
}
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("mb[0]", &self.mb(0usize))
.field("mb[1]", &self.mb(1usize))
.field("mb[2]", &self.mb(2usize))
.field("mb[3]", &self.mb(3usize))
.field("mb[4]", &self.mb(4usize))
.field("mb[5]", &self.mb(5usize))
.field("mb[6]", &self.mb(6usize))
.field("mb[7]", &self.mb(7usize))
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Acr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Acr {{ mb[0]: {=bool:?}, mb[1]: {=bool:?}, mb[2]: {=bool:?}, mb[3]: {=bool:?}, mb[4]: {=bool:?}, mb[5]: {=bool:?}, mb[6]: {=bool:?}, mb[7]: {=bool:?} }}",
self.mb(0usize),
self.mb(1usize),
self.mb(2usize),
self.mb(3usize),
self.mb(4usize),
self.mb(5usize),
self.mb(6usize),
self.mb(7usize)
)
}
}
#[doc = "Baudrate Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Br(pub u32);
impl Br {
#[doc = "Phase 2 segment"]
#[must_use]
#[inline(always)]
pub const fn phase2(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x07;
val as u8
}
#[doc = "Phase 2 segment"]
#[inline(always)]
pub const fn set_phase2(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 0usize)) | (((val as u32) & 0x07) << 0usize);
}
#[doc = "Phase 1 segment"]
#[must_use]
#[inline(always)]
pub const fn phase1(&self) -> u8 {
let val = (self.0 >> 4usize) & 0x07;
val as u8
}
#[doc = "Phase 1 segment"]
#[inline(always)]
pub const fn set_phase1(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 4usize)) | (((val as u32) & 0x07) << 4usize);
}
#[doc = "Programming time segment"]
#[must_use]
#[inline(always)]
pub const fn propag(&self) -> u8 {
let val = (self.0 >> 8usize) & 0x07;
val as u8
}
#[doc = "Programming time segment"]
#[inline(always)]
pub const fn set_propag(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 8usize)) | (((val as u32) & 0x07) << 8usize);
}
#[doc = "Re-synchronization jump width"]
#[must_use]
#[inline(always)]
pub const fn sjw(&self) -> u8 {
let val = (self.0 >> 12usize) & 0x03;
val as u8
}
#[doc = "Re-synchronization jump width"]
#[inline(always)]
pub const fn set_sjw(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 12usize)) | (((val as u32) & 0x03) << 12usize);
}
#[doc = "Baudrate Prescaler."]
#[must_use]
#[inline(always)]
pub const fn brp(&self) -> u8 {
let val = (self.0 >> 16usize) & 0x7f;
val as u8
}
#[doc = "Baudrate Prescaler."]
#[inline(always)]
pub const fn set_brp(&mut self, val: u8) {
self.0 = (self.0 & !(0x7f << 16usize)) | (((val as u32) & 0x7f) << 16usize);
}
#[doc = "Sampling Mode"]
#[must_use]
#[inline(always)]
pub const fn smp(&self) -> super::vals::Smp {
let val = (self.0 >> 24usize) & 0x01;
super::vals::Smp::from_bits(val as u8)
}
#[doc = "Sampling Mode"]
#[inline(always)]
pub const fn set_smp(&mut self, val: super::vals::Smp) {
self.0 = (self.0 & !(0x01 << 24usize)) | (((val.to_bits() as u32) & 0x01) << 24usize);
}
}
impl Default for Br {
#[inline(always)]
fn default() -> Br {
Br(0)
}
}
impl core::fmt::Debug for Br {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Br")
.field("phase2", &self.phase2())
.field("phase1", &self.phase1())
.field("propag", &self.propag())
.field("sjw", &self.sjw())
.field("brp", &self.brp())
.field("smp", &self.smp())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Br {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Br {{ phase2: {=u8:?}, phase1: {=u8:?}, propag: {=u8:?}, sjw: {=u8:?}, brp: {=u8:?}, smp: {:?} }}",
self.phase2(),
self.phase1(),
self.propag(),
self.sjw(),
self.brp(),
self.smp()
)
}
}
#[doc = "Error Counter Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ecr(pub u32);
impl Ecr {
#[doc = "Receive Error Counter"]
#[must_use]
#[inline(always)]
pub const fn rec(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "Receive Error Counter"]
#[inline(always)]
pub const fn set_rec(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
#[doc = "Transmit Error Counter"]
#[must_use]
#[inline(always)]
pub const fn tec(&self) -> u8 {
let val = (self.0 >> 16usize) & 0xff;
val as u8
}
#[doc = "Transmit Error Counter"]
#[inline(always)]
pub const fn set_tec(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 16usize)) | (((val as u32) & 0xff) << 16usize);
}
}
impl Default for Ecr {
#[inline(always)]
fn default() -> Ecr {
Ecr(0)
}
}
impl core::fmt::Debug for Ecr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ecr")
.field("rec", &self.rec())
.field("tec", &self.tec())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ecr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ecr {{ rec: {=u8:?}, tec: {=u8:?} }}",
self.rec(),
self.tec()
)
}
}
#[doc = "Interrupt Disable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Idr(pub u32);
impl Idr {
#[doc = "Mailbox 0 Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn mb(&self, n: usize) -> bool {
assert!(n < 8usize);
let offs = 0usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Mailbox 0 Interrupt Disable"]
#[inline(always)]
pub const fn set_mb(&mut self, n: usize, val: bool) {
assert!(n < 8usize);
let offs = 0usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
#[doc = "Error Active Mode Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn erra(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Error Active Mode Interrupt Disable"]
#[inline(always)]
pub const fn set_erra(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "Warning Limit Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn warn(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "Warning Limit Interrupt Disable"]
#[inline(always)]
pub const fn set_warn(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "Error Passive Mode Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn errp(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "Error Passive Mode Interrupt Disable"]
#[inline(always)]
pub const fn set_errp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "Bus Off Mode Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn boff(&self) -> bool {
let val = (self.0 >> 19usize) & 0x01;
val != 0
}
#[doc = "Bus Off Mode Interrupt Disable"]
#[inline(always)]
pub const fn set_boff(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
}
#[doc = "Sleep Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn sleep(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "Sleep Interrupt Disable"]
#[inline(always)]
pub const fn set_sleep(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "Wakeup Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn wakeup(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "Wakeup Interrupt Disable"]
#[inline(always)]
pub const fn set_wakeup(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
#[doc = "Timer Overflow Interrupt"]
#[must_use]
#[inline(always)]
pub const fn tovf(&self) -> bool {
let val = (self.0 >> 22usize) & 0x01;
val != 0
}
#[doc = "Timer Overflow Interrupt"]
#[inline(always)]
pub const fn set_tovf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
}
#[doc = "TimeStamp Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn tstp(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[doc = "TimeStamp Interrupt Disable"]
#[inline(always)]
pub const fn set_tstp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
#[doc = "CRC Error Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn cerr(&self) -> bool {
let val = (self.0 >> 24usize) & 0x01;
val != 0
}
#[doc = "CRC Error Interrupt Disable"]
#[inline(always)]
pub const fn set_cerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
}
#[doc = "Stuffing Error Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn serr(&self) -> bool {
let val = (self.0 >> 25usize) & 0x01;
val != 0
}
#[doc = "Stuffing Error Interrupt Disable"]
#[inline(always)]
pub const fn set_serr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
}
#[doc = "Acknowledgment Error Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn aerr(&self) -> bool {
let val = (self.0 >> 26usize) & 0x01;
val != 0
}
#[doc = "Acknowledgment Error Interrupt Disable"]
#[inline(always)]
pub const fn set_aerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
}
#[doc = "Form Error Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn ferr(&self) -> bool {
let val = (self.0 >> 27usize) & 0x01;
val != 0
}
#[doc = "Form Error Interrupt Disable"]
#[inline(always)]
pub const fn set_ferr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
}
#[doc = "Bit Error Interrupt Disable"]
#[must_use]
#[inline(always)]
pub const fn berr(&self) -> bool {
let val = (self.0 >> 28usize) & 0x01;
val != 0
}
#[doc = "Bit Error Interrupt Disable"]
#[inline(always)]
pub const fn set_berr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
}
}
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("mb[0]", &self.mb(0usize))
.field("mb[1]", &self.mb(1usize))
.field("mb[2]", &self.mb(2usize))
.field("mb[3]", &self.mb(3usize))
.field("mb[4]", &self.mb(4usize))
.field("mb[5]", &self.mb(5usize))
.field("mb[6]", &self.mb(6usize))
.field("mb[7]", &self.mb(7usize))
.field("erra", &self.erra())
.field("warn", &self.warn())
.field("errp", &self.errp())
.field("boff", &self.boff())
.field("sleep", &self.sleep())
.field("wakeup", &self.wakeup())
.field("tovf", &self.tovf())
.field("tstp", &self.tstp())
.field("cerr", &self.cerr())
.field("serr", &self.serr())
.field("aerr", &self.aerr())
.field("ferr", &self.ferr())
.field("berr", &self.berr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Idr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Idr {{ mb[0]: {=bool:?}, mb[1]: {=bool:?}, mb[2]: {=bool:?}, mb[3]: {=bool:?}, mb[4]: {=bool:?}, mb[5]: {=bool:?}, mb[6]: {=bool:?}, mb[7]: {=bool:?}, erra: {=bool:?}, warn: {=bool:?}, errp: {=bool:?}, boff: {=bool:?}, sleep: {=bool:?}, wakeup: {=bool:?}, tovf: {=bool:?}, tstp: {=bool:?}, cerr: {=bool:?}, serr: {=bool:?}, aerr: {=bool:?}, ferr: {=bool:?}, berr: {=bool:?} }}",
self.mb(0usize),
self.mb(1usize),
self.mb(2usize),
self.mb(3usize),
self.mb(4usize),
self.mb(5usize),
self.mb(6usize),
self.mb(7usize),
self.erra(),
self.warn(),
self.errp(),
self.boff(),
self.sleep(),
self.wakeup(),
self.tovf(),
self.tstp(),
self.cerr(),
self.serr(),
self.aerr(),
self.ferr(),
self.berr()
)
}
}
#[doc = "Interrupt Enable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ier(pub u32);
impl Ier {
#[doc = "Mailbox 0 Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn mb(&self, n: usize) -> bool {
assert!(n < 8usize);
let offs = 0usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Mailbox 0 Interrupt Enable"]
#[inline(always)]
pub const fn set_mb(&mut self, n: usize, val: bool) {
assert!(n < 8usize);
let offs = 0usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
#[doc = "Error Active Mode Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn erra(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Error Active Mode Interrupt Enable"]
#[inline(always)]
pub const fn set_erra(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "Warning Limit Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn warn(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "Warning Limit Interrupt Enable"]
#[inline(always)]
pub const fn set_warn(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "Error Passive Mode Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn errp(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "Error Passive Mode Interrupt Enable"]
#[inline(always)]
pub const fn set_errp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "Bus Off Mode Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn boff(&self) -> bool {
let val = (self.0 >> 19usize) & 0x01;
val != 0
}
#[doc = "Bus Off Mode Interrupt Enable"]
#[inline(always)]
pub const fn set_boff(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
}
#[doc = "Sleep Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn sleep(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "Sleep Interrupt Enable"]
#[inline(always)]
pub const fn set_sleep(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "Wakeup Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn wakeup(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "Wakeup Interrupt Enable"]
#[inline(always)]
pub const fn set_wakeup(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
#[doc = "Timer Overflow Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn tovf(&self) -> bool {
let val = (self.0 >> 22usize) & 0x01;
val != 0
}
#[doc = "Timer Overflow Interrupt Enable"]
#[inline(always)]
pub const fn set_tovf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
}
#[doc = "TimeStamp Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn tstp(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[doc = "TimeStamp Interrupt Enable"]
#[inline(always)]
pub const fn set_tstp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
#[doc = "CRC Error Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn cerr(&self) -> bool {
let val = (self.0 >> 24usize) & 0x01;
val != 0
}
#[doc = "CRC Error Interrupt Enable"]
#[inline(always)]
pub const fn set_cerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
}
#[doc = "Stuffing Error Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn serr(&self) -> bool {
let val = (self.0 >> 25usize) & 0x01;
val != 0
}
#[doc = "Stuffing Error Interrupt Enable"]
#[inline(always)]
pub const fn set_serr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
}
#[doc = "Acknowledgment Error Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn aerr(&self) -> bool {
let val = (self.0 >> 26usize) & 0x01;
val != 0
}
#[doc = "Acknowledgment Error Interrupt Enable"]
#[inline(always)]
pub const fn set_aerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
}
#[doc = "Form Error Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn ferr(&self) -> bool {
let val = (self.0 >> 27usize) & 0x01;
val != 0
}
#[doc = "Form Error Interrupt Enable"]
#[inline(always)]
pub const fn set_ferr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
}
#[doc = "Bit Error Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn berr(&self) -> bool {
let val = (self.0 >> 28usize) & 0x01;
val != 0
}
#[doc = "Bit Error Interrupt Enable"]
#[inline(always)]
pub const fn set_berr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
}
}
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("mb[0]", &self.mb(0usize))
.field("mb[1]", &self.mb(1usize))
.field("mb[2]", &self.mb(2usize))
.field("mb[3]", &self.mb(3usize))
.field("mb[4]", &self.mb(4usize))
.field("mb[5]", &self.mb(5usize))
.field("mb[6]", &self.mb(6usize))
.field("mb[7]", &self.mb(7usize))
.field("erra", &self.erra())
.field("warn", &self.warn())
.field("errp", &self.errp())
.field("boff", &self.boff())
.field("sleep", &self.sleep())
.field("wakeup", &self.wakeup())
.field("tovf", &self.tovf())
.field("tstp", &self.tstp())
.field("cerr", &self.cerr())
.field("serr", &self.serr())
.field("aerr", &self.aerr())
.field("ferr", &self.ferr())
.field("berr", &self.berr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ier {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ier {{ mb[0]: {=bool:?}, mb[1]: {=bool:?}, mb[2]: {=bool:?}, mb[3]: {=bool:?}, mb[4]: {=bool:?}, mb[5]: {=bool:?}, mb[6]: {=bool:?}, mb[7]: {=bool:?}, erra: {=bool:?}, warn: {=bool:?}, errp: {=bool:?}, boff: {=bool:?}, sleep: {=bool:?}, wakeup: {=bool:?}, tovf: {=bool:?}, tstp: {=bool:?}, cerr: {=bool:?}, serr: {=bool:?}, aerr: {=bool:?}, ferr: {=bool:?}, berr: {=bool:?} }}",
self.mb(0usize),
self.mb(1usize),
self.mb(2usize),
self.mb(3usize),
self.mb(4usize),
self.mb(5usize),
self.mb(6usize),
self.mb(7usize),
self.erra(),
self.warn(),
self.errp(),
self.boff(),
self.sleep(),
self.wakeup(),
self.tovf(),
self.tstp(),
self.cerr(),
self.serr(),
self.aerr(),
self.ferr(),
self.berr()
)
}
}
#[doc = "Interrupt Mask Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Imr(pub u32);
impl Imr {
#[doc = "Mailbox 0 Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn mb(&self, n: usize) -> bool {
assert!(n < 8usize);
let offs = 0usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Mailbox 0 Interrupt Mask"]
#[inline(always)]
pub const fn set_mb(&mut self, n: usize, val: bool) {
assert!(n < 8usize);
let offs = 0usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
#[doc = "Error Active Mode Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn erra(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Error Active Mode Interrupt Mask"]
#[inline(always)]
pub const fn set_erra(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "Warning Limit Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn warn(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "Warning Limit Interrupt Mask"]
#[inline(always)]
pub const fn set_warn(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "Error Passive Mode Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn errp(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "Error Passive Mode Interrupt Mask"]
#[inline(always)]
pub const fn set_errp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "Bus Off Mode Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn boff(&self) -> bool {
let val = (self.0 >> 19usize) & 0x01;
val != 0
}
#[doc = "Bus Off Mode Interrupt Mask"]
#[inline(always)]
pub const fn set_boff(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
}
#[doc = "Sleep Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn sleep(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "Sleep Interrupt Mask"]
#[inline(always)]
pub const fn set_sleep(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "Wakeup Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn wakeup(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "Wakeup Interrupt Mask"]
#[inline(always)]
pub const fn set_wakeup(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
#[doc = "Timer Overflow Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn tovf(&self) -> bool {
let val = (self.0 >> 22usize) & 0x01;
val != 0
}
#[doc = "Timer Overflow Interrupt Mask"]
#[inline(always)]
pub const fn set_tovf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
}
#[doc = "Timestamp Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn tstp(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[doc = "Timestamp Interrupt Mask"]
#[inline(always)]
pub const fn set_tstp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
#[doc = "CRC Error Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn cerr(&self) -> bool {
let val = (self.0 >> 24usize) & 0x01;
val != 0
}
#[doc = "CRC Error Interrupt Mask"]
#[inline(always)]
pub const fn set_cerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
}
#[doc = "Stuffing Error Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn serr(&self) -> bool {
let val = (self.0 >> 25usize) & 0x01;
val != 0
}
#[doc = "Stuffing Error Interrupt Mask"]
#[inline(always)]
pub const fn set_serr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
}
#[doc = "Acknowledgment Error Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn aerr(&self) -> bool {
let val = (self.0 >> 26usize) & 0x01;
val != 0
}
#[doc = "Acknowledgment Error Interrupt Mask"]
#[inline(always)]
pub const fn set_aerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
}
#[doc = "Form Error Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn ferr(&self) -> bool {
let val = (self.0 >> 27usize) & 0x01;
val != 0
}
#[doc = "Form Error Interrupt Mask"]
#[inline(always)]
pub const fn set_ferr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
}
#[doc = "Bit Error Interrupt Mask"]
#[must_use]
#[inline(always)]
pub const fn berr(&self) -> bool {
let val = (self.0 >> 28usize) & 0x01;
val != 0
}
#[doc = "Bit Error Interrupt Mask"]
#[inline(always)]
pub const fn set_berr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
}
}
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("mb[0]", &self.mb(0usize))
.field("mb[1]", &self.mb(1usize))
.field("mb[2]", &self.mb(2usize))
.field("mb[3]", &self.mb(3usize))
.field("mb[4]", &self.mb(4usize))
.field("mb[5]", &self.mb(5usize))
.field("mb[6]", &self.mb(6usize))
.field("mb[7]", &self.mb(7usize))
.field("erra", &self.erra())
.field("warn", &self.warn())
.field("errp", &self.errp())
.field("boff", &self.boff())
.field("sleep", &self.sleep())
.field("wakeup", &self.wakeup())
.field("tovf", &self.tovf())
.field("tstp", &self.tstp())
.field("cerr", &self.cerr())
.field("serr", &self.serr())
.field("aerr", &self.aerr())
.field("ferr", &self.ferr())
.field("berr", &self.berr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Imr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Imr {{ mb[0]: {=bool:?}, mb[1]: {=bool:?}, mb[2]: {=bool:?}, mb[3]: {=bool:?}, mb[4]: {=bool:?}, mb[5]: {=bool:?}, mb[6]: {=bool:?}, mb[7]: {=bool:?}, erra: {=bool:?}, warn: {=bool:?}, errp: {=bool:?}, boff: {=bool:?}, sleep: {=bool:?}, wakeup: {=bool:?}, tovf: {=bool:?}, tstp: {=bool:?}, cerr: {=bool:?}, serr: {=bool:?}, aerr: {=bool:?}, ferr: {=bool:?}, berr: {=bool:?} }}",
self.mb(0usize),
self.mb(1usize),
self.mb(2usize),
self.mb(3usize),
self.mb(4usize),
self.mb(5usize),
self.mb(6usize),
self.mb(7usize),
self.erra(),
self.warn(),
self.errp(),
self.boff(),
self.sleep(),
self.wakeup(),
self.tovf(),
self.tstp(),
self.cerr(),
self.serr(),
self.aerr(),
self.ferr(),
self.berr()
)
}
}
#[doc = "Mailbox Acceptance Mask Register (MB = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Mam(pub u32);
impl Mam {
#[doc = "Complementary bits for identifier in extended frame mode"]
#[must_use]
#[inline(always)]
pub const fn midv_b(&self) -> u32 {
let val = (self.0 >> 0usize) & 0x0003_ffff;
val as u32
}
#[doc = "Complementary bits for identifier in extended frame mode"]
#[inline(always)]
pub const fn set_midv_b(&mut self, val: u32) {
self.0 = (self.0 & !(0x0003_ffff << 0usize)) | (((val as u32) & 0x0003_ffff) << 0usize);
}
#[doc = "Identifier for standard frame mode"]
#[must_use]
#[inline(always)]
pub const fn midv_a(&self) -> u16 {
let val = (self.0 >> 18usize) & 0x07ff;
val as u16
}
#[doc = "Identifier for standard frame mode"]
#[inline(always)]
pub const fn set_midv_a(&mut self, val: u16) {
self.0 = (self.0 & !(0x07ff << 18usize)) | (((val as u32) & 0x07ff) << 18usize);
}
#[doc = "Identifier Version"]
#[must_use]
#[inline(always)]
pub const fn mide(&self) -> bool {
let val = (self.0 >> 29usize) & 0x01;
val != 0
}
#[doc = "Identifier Version"]
#[inline(always)]
pub const fn set_mide(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
}
}
impl Default for Mam {
#[inline(always)]
fn default() -> Mam {
Mam(0)
}
}
impl core::fmt::Debug for Mam {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Mam")
.field("midv_b", &self.midv_b())
.field("midv_a", &self.midv_a())
.field("mide", &self.mide())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Mam {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Mam {{ midv_b: {=u32:?}, midv_a: {=u16:?}, mide: {=bool:?} }}",
self.midv_b(),
self.midv_a(),
self.mide()
)
}
}
#[doc = "Mailbox Control Register (MB = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Mcr(pub u32);
impl Mcr {
#[doc = "Mailbox Data Length Code"]
#[must_use]
#[inline(always)]
pub const fn mdlc(&self) -> u8 {
let val = (self.0 >> 16usize) & 0x0f;
val as u8
}
#[doc = "Mailbox Data Length Code"]
#[inline(always)]
pub const fn set_mdlc(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 16usize)) | (((val as u32) & 0x0f) << 16usize);
}
#[doc = "Mailbox Remote Transmission Request"]
#[must_use]
#[inline(always)]
pub const fn mrtr(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "Mailbox Remote Transmission Request"]
#[inline(always)]
pub const fn set_mrtr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "Abort Request for Mailbox x"]
#[must_use]
#[inline(always)]
pub const fn macr(&self) -> bool {
let val = (self.0 >> 22usize) & 0x01;
val != 0
}
#[doc = "Abort Request for Mailbox x"]
#[inline(always)]
pub const fn set_macr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
}
#[doc = "Mailbox Transfer Command"]
#[must_use]
#[inline(always)]
pub const fn mtcr(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[doc = "Mailbox Transfer Command"]
#[inline(always)]
pub const fn set_mtcr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
}
impl Default for Mcr {
#[inline(always)]
fn default() -> Mcr {
Mcr(0)
}
}
impl core::fmt::Debug for Mcr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Mcr")
.field("mdlc", &self.mdlc())
.field("mrtr", &self.mrtr())
.field("macr", &self.macr())
.field("mtcr", &self.mtcr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Mcr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Mcr {{ mdlc: {=u8:?}, mrtr: {=bool:?}, macr: {=bool:?}, mtcr: {=bool:?} }}",
self.mdlc(),
self.mrtr(),
self.macr(),
self.mtcr()
)
}
}
#[doc = "Mailbox Data High Register (MB = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Mdh(pub u32);
impl Mdh {
#[doc = "Message Data High Value"]
#[must_use]
#[inline(always)]
pub const fn mdh(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Message Data High Value"]
#[inline(always)]
pub const fn set_mdh(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Mdh {
#[inline(always)]
fn default() -> Mdh {
Mdh(0)
}
}
impl core::fmt::Debug for Mdh {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Mdh").field("mdh", &self.mdh()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Mdh {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Mdh {{ mdh: {=u32:?} }}", self.mdh())
}
}
#[doc = "Mailbox Data Low Register (MB = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Mdl(pub u32);
impl Mdl {
#[doc = "Message Data Low Value"]
#[must_use]
#[inline(always)]
pub const fn mdl(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Message Data Low Value"]
#[inline(always)]
pub const fn set_mdl(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Mdl {
#[inline(always)]
fn default() -> Mdl {
Mdl(0)
}
}
impl core::fmt::Debug for Mdl {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Mdl").field("mdl", &self.mdl()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Mdl {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Mdl {{ mdl: {=u32:?} }}", self.mdl())
}
}
#[doc = "Mailbox Family ID Register (MB = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Mfid(pub u32);
impl Mfid {
#[doc = "Family ID"]
#[must_use]
#[inline(always)]
pub const fn mfid(&self) -> u32 {
let val = (self.0 >> 0usize) & 0x1fff_ffff;
val as u32
}
#[doc = "Family ID"]
#[inline(always)]
pub const fn set_mfid(&mut self, val: u32) {
self.0 = (self.0 & !(0x1fff_ffff << 0usize)) | (((val as u32) & 0x1fff_ffff) << 0usize);
}
}
impl Default for Mfid {
#[inline(always)]
fn default() -> Mfid {
Mfid(0)
}
}
impl core::fmt::Debug for Mfid {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Mfid").field("mfid", &self.mfid()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Mfid {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Mfid {{ mfid: {=u32:?} }}", self.mfid())
}
}
#[doc = "Mailbox ID Register (MB = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Mid(pub u32);
impl Mid {
#[doc = "Complementary bits for identifier in extended frame mode"]
#[must_use]
#[inline(always)]
pub const fn midv_b(&self) -> u32 {
let val = (self.0 >> 0usize) & 0x0003_ffff;
val as u32
}
#[doc = "Complementary bits for identifier in extended frame mode"]
#[inline(always)]
pub const fn set_midv_b(&mut self, val: u32) {
self.0 = (self.0 & !(0x0003_ffff << 0usize)) | (((val as u32) & 0x0003_ffff) << 0usize);
}
#[doc = "Identifier for standard frame mode"]
#[must_use]
#[inline(always)]
pub const fn midv_a(&self) -> u16 {
let val = (self.0 >> 18usize) & 0x07ff;
val as u16
}
#[doc = "Identifier for standard frame mode"]
#[inline(always)]
pub const fn set_midv_a(&mut self, val: u16) {
self.0 = (self.0 & !(0x07ff << 18usize)) | (((val as u32) & 0x07ff) << 18usize);
}
#[doc = "Identifier Version"]
#[must_use]
#[inline(always)]
pub const fn mide(&self) -> bool {
let val = (self.0 >> 29usize) & 0x01;
val != 0
}
#[doc = "Identifier Version"]
#[inline(always)]
pub const fn set_mide(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
}
}
impl Default for Mid {
#[inline(always)]
fn default() -> Mid {
Mid(0)
}
}
impl core::fmt::Debug for Mid {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Mid")
.field("midv_b", &self.midv_b())
.field("midv_a", &self.midv_a())
.field("mide", &self.mide())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Mid {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Mid {{ midv_b: {=u32:?}, midv_a: {=u16:?}, mide: {=bool:?} }}",
self.midv_b(),
self.midv_a(),
self.mide()
)
}
}
#[doc = "Mailbox Mode Register (MB = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Mmr(pub u32);
impl Mmr {
#[doc = "Mailbox Timemark"]
#[must_use]
#[inline(always)]
pub const fn mtimemark(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Mailbox Timemark"]
#[inline(always)]
pub const fn set_mtimemark(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
#[doc = "Mailbox Priority"]
#[must_use]
#[inline(always)]
pub const fn prior(&self) -> u8 {
let val = (self.0 >> 16usize) & 0x0f;
val as u8
}
#[doc = "Mailbox Priority"]
#[inline(always)]
pub const fn set_prior(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 16usize)) | (((val as u32) & 0x0f) << 16usize);
}
#[doc = "Mailbox Object Type"]
#[must_use]
#[inline(always)]
pub const fn mot(&self) -> super::vals::MmrMot {
let val = (self.0 >> 24usize) & 0x07;
super::vals::MmrMot::from_bits(val as u8)
}
#[doc = "Mailbox Object Type"]
#[inline(always)]
pub const fn set_mot(&mut self, val: super::vals::MmrMot) {
self.0 = (self.0 & !(0x07 << 24usize)) | (((val.to_bits() as u32) & 0x07) << 24usize);
}
}
impl Default for Mmr {
#[inline(always)]
fn default() -> Mmr {
Mmr(0)
}
}
impl core::fmt::Debug for Mmr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Mmr")
.field("mtimemark", &self.mtimemark())
.field("prior", &self.prior())
.field("mot", &self.mot())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Mmr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Mmr {{ mtimemark: {=u16:?}, prior: {=u8:?}, mot: {:?} }}",
self.mtimemark(),
self.prior(),
self.mot()
)
}
}
#[doc = "Mode Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Mr(pub u32);
impl Mr {
#[doc = "CAN Controller Enable"]
#[must_use]
#[inline(always)]
pub const fn canen(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "CAN Controller Enable"]
#[inline(always)]
pub const fn set_canen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Disable/Enable Low Power Mode"]
#[must_use]
#[inline(always)]
pub const fn lpm(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Disable/Enable Low Power Mode"]
#[inline(always)]
pub const fn set_lpm(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Disable/Enable Autobaud/Listen mode"]
#[must_use]
#[inline(always)]
pub const fn abm(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Disable/Enable Autobaud/Listen mode"]
#[inline(always)]
pub const fn set_abm(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Disable/Enable Overload Frame"]
#[must_use]
#[inline(always)]
pub const fn ovl(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Disable/Enable Overload Frame"]
#[inline(always)]
pub const fn set_ovl(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Timestamp messages at each end of Frame"]
#[must_use]
#[inline(always)]
pub const fn teof(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Timestamp messages at each end of Frame"]
#[inline(always)]
pub const fn set_teof(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Disable/Enable Time Triggered Mode"]
#[must_use]
#[inline(always)]
pub const fn ttm(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Disable/Enable Time Triggered Mode"]
#[inline(always)]
pub const fn set_ttm(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Enable Timer Freeze"]
#[must_use]
#[inline(always)]
pub const fn timfrz(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Enable Timer Freeze"]
#[inline(always)]
pub const fn set_timfrz(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Disable Repeat"]
#[must_use]
#[inline(always)]
pub const fn drpt(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Disable Repeat"]
#[inline(always)]
pub const fn set_drpt(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Reception Synchronization Stage (not readable)"]
#[must_use]
#[inline(always)]
pub const fn rxsync(&self) -> super::vals::Rxsync {
let val = (self.0 >> 24usize) & 0x07;
super::vals::Rxsync::from_bits(val as u8)
}
#[doc = "Reception Synchronization Stage (not readable)"]
#[inline(always)]
pub const fn set_rxsync(&mut self, val: super::vals::Rxsync) {
self.0 = (self.0 & !(0x07 << 24usize)) | (((val.to_bits() as u32) & 0x07) << 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("canen", &self.canen())
.field("lpm", &self.lpm())
.field("abm", &self.abm())
.field("ovl", &self.ovl())
.field("teof", &self.teof())
.field("ttm", &self.ttm())
.field("timfrz", &self.timfrz())
.field("drpt", &self.drpt())
.field("rxsync", &self.rxsync())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Mr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Mr {{ canen: {=bool:?}, lpm: {=bool:?}, abm: {=bool:?}, ovl: {=bool:?}, teof: {=bool:?}, ttm: {=bool:?}, timfrz: {=bool:?}, drpt: {=bool:?}, rxsync: {:?} }}",
self.canen(),
self.lpm(),
self.abm(),
self.ovl(),
self.teof(),
self.ttm(),
self.timfrz(),
self.drpt(),
self.rxsync()
)
}
}
#[doc = "Mailbox Status Register (MB = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Msr(pub u32);
impl Msr {
#[doc = "Timer value"]
#[must_use]
#[inline(always)]
pub const fn mtimestamp(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Timer value"]
#[inline(always)]
pub const fn set_mtimestamp(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
#[doc = "Mailbox Data Length Code"]
#[must_use]
#[inline(always)]
pub const fn mdlc(&self) -> u8 {
let val = (self.0 >> 16usize) & 0x0f;
val as u8
}
#[doc = "Mailbox Data Length Code"]
#[inline(always)]
pub const fn set_mdlc(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 16usize)) | (((val as u32) & 0x0f) << 16usize);
}
#[doc = "Mailbox Remote Transmission Request"]
#[must_use]
#[inline(always)]
pub const fn mrtr(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "Mailbox Remote Transmission Request"]
#[inline(always)]
pub const fn set_mrtr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "Mailbox Message Abort"]
#[must_use]
#[inline(always)]
pub const fn mabt(&self) -> bool {
let val = (self.0 >> 22usize) & 0x01;
val != 0
}
#[doc = "Mailbox Message Abort"]
#[inline(always)]
pub const fn set_mabt(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
}
#[doc = "Mailbox Ready"]
#[must_use]
#[inline(always)]
pub const fn mrdy(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[doc = "Mailbox Ready"]
#[inline(always)]
pub const fn set_mrdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
#[doc = "Mailbox Message Ignored"]
#[must_use]
#[inline(always)]
pub const fn mmi(&self) -> bool {
let val = (self.0 >> 24usize) & 0x01;
val != 0
}
#[doc = "Mailbox Message Ignored"]
#[inline(always)]
pub const fn set_mmi(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
}
}
impl Default for Msr {
#[inline(always)]
fn default() -> Msr {
Msr(0)
}
}
impl core::fmt::Debug for Msr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Msr")
.field("mtimestamp", &self.mtimestamp())
.field("mdlc", &self.mdlc())
.field("mrtr", &self.mrtr())
.field("mabt", &self.mabt())
.field("mrdy", &self.mrdy())
.field("mmi", &self.mmi())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Msr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Msr {{ mtimestamp: {=u16:?}, mdlc: {=u8:?}, mrtr: {=bool:?}, mabt: {=bool:?}, mrdy: {=bool:?}, mmi: {=bool:?} }}",
self.mtimestamp(),
self.mdlc(),
self.mrtr(),
self.mabt(),
self.mrdy(),
self.mmi()
)
}
}
#[doc = "Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sr(pub u32);
impl Sr {
#[doc = "Mailbox 0 Event"]
#[must_use]
#[inline(always)]
pub const fn mb(&self, n: usize) -> bool {
assert!(n < 8usize);
let offs = 0usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Mailbox 0 Event"]
#[inline(always)]
pub const fn set_mb(&mut self, n: usize, val: bool) {
assert!(n < 8usize);
let offs = 0usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
#[doc = "Error Active Mode"]
#[must_use]
#[inline(always)]
pub const fn erra(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Error Active Mode"]
#[inline(always)]
pub const fn set_erra(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "Warning Limit"]
#[must_use]
#[inline(always)]
pub const fn warn(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "Warning Limit"]
#[inline(always)]
pub const fn set_warn(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "Error Passive Mode"]
#[must_use]
#[inline(always)]
pub const fn errp(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "Error Passive Mode"]
#[inline(always)]
pub const fn set_errp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "Bus Off Mode"]
#[must_use]
#[inline(always)]
pub const fn boff(&self) -> bool {
let val = (self.0 >> 19usize) & 0x01;
val != 0
}
#[doc = "Bus Off Mode"]
#[inline(always)]
pub const fn set_boff(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
}
#[doc = "CAN controller in Low power Mode"]
#[must_use]
#[inline(always)]
pub const fn sleep(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "CAN controller in Low power Mode"]
#[inline(always)]
pub const fn set_sleep(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "CAN controller is not in Low power Mode"]
#[must_use]
#[inline(always)]
pub const fn wakeup(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "CAN controller is not in Low power Mode"]
#[inline(always)]
pub const fn set_wakeup(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
#[doc = "Timer Overflow"]
#[must_use]
#[inline(always)]
pub const fn tovf(&self) -> bool {
let val = (self.0 >> 22usize) & 0x01;
val != 0
}
#[doc = "Timer Overflow"]
#[inline(always)]
pub const fn set_tovf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
}
#[must_use]
#[inline(always)]
pub const fn tstp(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[inline(always)]
pub const fn set_tstp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
#[doc = "Mailbox CRC Error"]
#[must_use]
#[inline(always)]
pub const fn cerr(&self) -> bool {
let val = (self.0 >> 24usize) & 0x01;
val != 0
}
#[doc = "Mailbox CRC Error"]
#[inline(always)]
pub const fn set_cerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
}
#[doc = "Mailbox Stuffing Error"]
#[must_use]
#[inline(always)]
pub const fn serr(&self) -> bool {
let val = (self.0 >> 25usize) & 0x01;
val != 0
}
#[doc = "Mailbox Stuffing Error"]
#[inline(always)]
pub const fn set_serr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
}
#[doc = "Acknowledgment Error"]
#[must_use]
#[inline(always)]
pub const fn aerr(&self) -> bool {
let val = (self.0 >> 26usize) & 0x01;
val != 0
}
#[doc = "Acknowledgment Error"]
#[inline(always)]
pub const fn set_aerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
}
#[doc = "Form Error"]
#[must_use]
#[inline(always)]
pub const fn ferr(&self) -> bool {
let val = (self.0 >> 27usize) & 0x01;
val != 0
}
#[doc = "Form Error"]
#[inline(always)]
pub const fn set_ferr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
}
#[doc = "Bit Error"]
#[must_use]
#[inline(always)]
pub const fn berr(&self) -> bool {
let val = (self.0 >> 28usize) & 0x01;
val != 0
}
#[doc = "Bit Error"]
#[inline(always)]
pub const fn set_berr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
}
#[doc = "Receiver busy"]
#[must_use]
#[inline(always)]
pub const fn rbsy(&self) -> bool {
let val = (self.0 >> 29usize) & 0x01;
val != 0
}
#[doc = "Receiver busy"]
#[inline(always)]
pub const fn set_rbsy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
}
#[doc = "Transmitter busy"]
#[must_use]
#[inline(always)]
pub const fn tbsy(&self) -> bool {
let val = (self.0 >> 30usize) & 0x01;
val != 0
}
#[doc = "Transmitter busy"]
#[inline(always)]
pub const fn set_tbsy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
}
#[doc = "Overload busy"]
#[must_use]
#[inline(always)]
pub const fn ovlsy(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "Overload busy"]
#[inline(always)]
pub const fn set_ovlsy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
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("mb[0]", &self.mb(0usize))
.field("mb[1]", &self.mb(1usize))
.field("mb[2]", &self.mb(2usize))
.field("mb[3]", &self.mb(3usize))
.field("mb[4]", &self.mb(4usize))
.field("mb[5]", &self.mb(5usize))
.field("mb[6]", &self.mb(6usize))
.field("mb[7]", &self.mb(7usize))
.field("erra", &self.erra())
.field("warn", &self.warn())
.field("errp", &self.errp())
.field("boff", &self.boff())
.field("sleep", &self.sleep())
.field("wakeup", &self.wakeup())
.field("tovf", &self.tovf())
.field("tstp", &self.tstp())
.field("cerr", &self.cerr())
.field("serr", &self.serr())
.field("aerr", &self.aerr())
.field("ferr", &self.ferr())
.field("berr", &self.berr())
.field("rbsy", &self.rbsy())
.field("tbsy", &self.tbsy())
.field("ovlsy", &self.ovlsy())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Sr {{ mb[0]: {=bool:?}, mb[1]: {=bool:?}, mb[2]: {=bool:?}, mb[3]: {=bool:?}, mb[4]: {=bool:?}, mb[5]: {=bool:?}, mb[6]: {=bool:?}, mb[7]: {=bool:?}, erra: {=bool:?}, warn: {=bool:?}, errp: {=bool:?}, boff: {=bool:?}, sleep: {=bool:?}, wakeup: {=bool:?}, tovf: {=bool:?}, tstp: {=bool:?}, cerr: {=bool:?}, serr: {=bool:?}, aerr: {=bool:?}, ferr: {=bool:?}, berr: {=bool:?}, rbsy: {=bool:?}, tbsy: {=bool:?}, ovlsy: {=bool:?} }}",
self.mb(0usize),
self.mb(1usize),
self.mb(2usize),
self.mb(3usize),
self.mb(4usize),
self.mb(5usize),
self.mb(6usize),
self.mb(7usize),
self.erra(),
self.warn(),
self.errp(),
self.boff(),
self.sleep(),
self.wakeup(),
self.tovf(),
self.tstp(),
self.cerr(),
self.serr(),
self.aerr(),
self.ferr(),
self.berr(),
self.rbsy(),
self.tbsy(),
self.ovlsy()
)
}
}
#[doc = "Transfer Command Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tcr(pub u32);
impl Tcr {
#[doc = "Transfer Request for Mailbox 0"]
#[must_use]
#[inline(always)]
pub const fn mb(&self, n: usize) -> bool {
assert!(n < 8usize);
let offs = 0usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Transfer Request for Mailbox 0"]
#[inline(always)]
pub const fn set_mb(&mut self, n: usize, val: bool) {
assert!(n < 8usize);
let offs = 0usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
#[doc = "Timer Reset"]
#[must_use]
#[inline(always)]
pub const fn timrst(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "Timer Reset"]
#[inline(always)]
pub const fn set_timrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
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("mb[0]", &self.mb(0usize))
.field("mb[1]", &self.mb(1usize))
.field("mb[2]", &self.mb(2usize))
.field("mb[3]", &self.mb(3usize))
.field("mb[4]", &self.mb(4usize))
.field("mb[5]", &self.mb(5usize))
.field("mb[6]", &self.mb(6usize))
.field("mb[7]", &self.mb(7usize))
.field("timrst", &self.timrst())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Tcr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Tcr {{ mb[0]: {=bool:?}, mb[1]: {=bool:?}, mb[2]: {=bool:?}, mb[3]: {=bool:?}, mb[4]: {=bool:?}, mb[5]: {=bool:?}, mb[6]: {=bool:?}, mb[7]: {=bool:?}, timrst: {=bool:?} }}",
self.mb(0usize),
self.mb(1usize),
self.mb(2usize),
self.mb(3usize),
self.mb(4usize),
self.mb(5usize),
self.mb(6usize),
self.mb(7usize),
self.timrst()
)
}
}
#[doc = "Timer Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tim(pub u32);
impl Tim {
#[doc = "Timer"]
#[must_use]
#[inline(always)]
pub const fn timer(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Timer"]
#[inline(always)]
pub const fn set_timer(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Tim {
#[inline(always)]
fn default() -> Tim {
Tim(0)
}
}
impl core::fmt::Debug for Tim {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Tim").field("timer", &self.timer()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Tim {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Tim {{ timer: {=u16:?} }}", self.timer())
}
}
#[doc = "Timestamp Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Timestp(pub u32);
impl Timestp {
#[doc = "Timestamp"]
#[must_use]
#[inline(always)]
pub const fn mtimestamp(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Timestamp"]
#[inline(always)]
pub const fn set_mtimestamp(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Timestp {
#[inline(always)]
fn default() -> Timestp {
Timestp(0)
}
}
impl core::fmt::Debug for Timestp {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Timestp")
.field("mtimestamp", &self.mtimestamp())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Timestp {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Timestp {{ mtimestamp: {=u16:?} }}", self.mtimestamp())
}
}
#[doc = "Write Protect Mode Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Wpmr(pub u32);
impl Wpmr {
#[doc = "Write Protection Enable"]
#[must_use]
#[inline(always)]
pub const fn wpen(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Write Protection 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 Protection Key Password"]
#[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 Protection Key Password"]
#[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()
)
}
}
#[doc = "Write Protect Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Wpsr(pub u32);
impl Wpsr {
#[doc = "Write Protection Violation Status"]
#[must_use]
#[inline(always)]
pub const fn wpvs(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Write Protection Violation Status"]
#[inline(always)]
pub const fn set_wpvs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Write Protection Violation Source"]
#[must_use]
#[inline(always)]
pub const fn wpvsrc(&self) -> u8 {
let val = (self.0 >> 8usize) & 0xff;
val as u8
}
#[doc = "Write Protection Violation Source"]
#[inline(always)]
pub const fn set_wpvsrc(&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("wpvs", &self.wpvs())
.field("wpvsrc", &self.wpvsrc())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Wpsr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Wpsr {{ wpvs: {=bool:?}, wpvsrc: {=u8:?} }}",
self.wpvs(),
self.wpvsrc()
)
}
}