#![allow(clippy::missing_safety_doc)]
#![allow(clippy::identity_op)]
#![allow(clippy::unnecessary_cast)]
#![allow(clippy::erasing_op)]
#[doc = "Controller area network."]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Can {
ptr: *mut u8,
}
unsafe impl Send for Can {}
unsafe impl Sync for Can {}
impl Can {
#[inline(always)]
pub const unsafe fn from_ptr(ptr: *mut ()) -> Self {
Self { ptr: ptr as _ }
}
#[inline(always)]
pub const fn as_ptr(&self) -> *mut () {
self.ptr as _
}
#[doc = "CAN Master control register."]
#[inline(always)]
pub const fn ctlr(self) -> crate::common::Reg<regs::Ctlr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0usize) as _) }
}
#[doc = "CAN master status register."]
#[inline(always)]
pub const fn statr(self) -> crate::common::Reg<regs::Statr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04usize) as _) }
}
#[doc = "CAN transmit status register."]
#[inline(always)]
pub const fn tstatr(self) -> crate::common::Reg<regs::Tstatr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x08usize) as _) }
}
#[doc = "CAN receive FIFO register."]
#[inline(always)]
pub const fn rfifo(self, n: usize) -> crate::common::Reg<regs::Rfifo, crate::common::RW> {
assert!(n < 2usize);
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0cusize + n * 32usize) as _) }
}
#[doc = "CAN interrupt enable register."]
#[inline(always)]
pub const fn intenr(self) -> crate::common::Reg<regs::Intenr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x14usize) as _) }
}
#[doc = "CAN error status register."]
#[inline(always)]
pub const fn errsr(self) -> crate::common::Reg<regs::Errsr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x18usize) as _) }
}
#[doc = "CAN bit timing register."]
#[inline(always)]
pub const fn btimr(self) -> crate::common::Reg<regs::Btimr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x1cusize) as _) }
}
#[doc = "CAN time trigger control register."]
#[inline(always)]
pub const fn ttctlr(self) -> crate::common::Reg<regs::Ttctlr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x20usize) as _) }
}
#[doc = "CAN Time Trigger Count Value Register."]
#[inline(always)]
pub const fn ttcnt(self) -> crate::common::Reg<u16, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x24usize) as _) }
}
#[doc = "CAN TX mailbox identifier register."]
#[inline(always)]
pub const fn txmir(self, n: usize) -> crate::common::Reg<regs::Txmir, crate::common::RW> {
assert!(n < 3usize);
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0180usize + n * 16usize) as _) }
}
#[doc = "CAN mailbox data length control and time stamp register."]
#[inline(always)]
pub const fn txmdtr(self, n: usize) -> crate::common::Reg<regs::Txmdtr, crate::common::RW> {
assert!(n < 3usize);
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0184usize + n * 16usize) as _) }
}
#[doc = "CAN mailbox data low register."]
#[inline(always)]
pub const fn txmdlr(self, n: usize) -> crate::common::Reg<regs::Txmdlr, crate::common::RW> {
assert!(n < 3usize);
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0188usize + n * 16usize) as _) }
}
#[doc = "CAN mailbox data high register."]
#[inline(always)]
pub const fn txmdhr(self, n: usize) -> crate::common::Reg<regs::Txmdhr, crate::common::RW> {
assert!(n < 3usize);
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x018cusize + n * 16usize) as _) }
}
#[doc = "CAN receive FIFO mailbox identifier register."]
#[inline(always)]
pub const fn rxmir(self, n: usize) -> crate::common::Reg<regs::Rxmir, crate::common::R> {
assert!(n < 2usize);
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01b0usize + n * 16usize) as _) }
}
#[doc = "CAN receive FIFO mailbox data length control and time stamp register."]
#[inline(always)]
pub const fn rxmdtr(self, n: usize) -> crate::common::Reg<regs::Rxmdtr, crate::common::R> {
assert!(n < 2usize);
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01b4usize + n * 16usize) as _) }
}
#[doc = "CAN receive FIFO mailbox data low register."]
#[inline(always)]
pub const fn rxmdlr(self, n: usize) -> crate::common::Reg<regs::Rxmdlr, crate::common::R> {
assert!(n < 2usize);
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01b8usize + n * 16usize) as _) }
}
#[doc = "CAN receive FIFO mailbox data high register."]
#[inline(always)]
pub const fn rxmdhr(self, n: usize) -> crate::common::Reg<regs::Rxmdhr, crate::common::R> {
assert!(n < 2usize);
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01bcusize + n * 16usize) as _) }
}
#[doc = "CAN filter master register."]
#[inline(always)]
pub const fn fctlr(self) -> crate::common::Reg<regs::Fctlr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0200usize) as _) }
}
#[doc = "CAN filter mode register."]
#[inline(always)]
pub const fn fmcfgr(self) -> crate::common::Reg<regs::Fmcfgr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0204usize) as _) }
}
#[doc = "CAN filter scale register."]
#[inline(always)]
pub const fn fscfgr(self) -> crate::common::Reg<regs::Fscfgr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x020cusize) as _) }
}
#[doc = "CAN filter FIFO assignment register."]
#[inline(always)]
pub const fn fafifor(self) -> crate::common::Reg<regs::Fafifor, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0214usize) as _) }
}
#[doc = "CAN filter activation register."]
#[inline(always)]
pub const fn fwr(self) -> crate::common::Reg<regs::Fwr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x021cusize) as _) }
}
#[doc = "Filter bank 0 register 1."]
#[inline(always)]
pub const fn fr(self, n: usize) -> crate::common::Reg<regs::Fr, crate::common::RW> {
assert!(n < 56usize);
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0240usize + n * 4usize) as _) }
}
}
pub mod regs {
#[doc = "CAN bit timing register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Btimr(pub u32);
impl Btimr {
#[doc = "Baud rate prescaler."]
#[inline(always)]
pub const fn brp(&self) -> u16 {
let val = (self.0 >> 0usize) & 0x03ff;
val as u16
}
#[doc = "Baud rate prescaler."]
#[inline(always)]
pub fn set_brp(&mut self, val: u16) {
self.0 = (self.0 & !(0x03ff << 0usize)) | (((val as u32) & 0x03ff) << 0usize);
}
#[doc = "Time segment 1."]
#[inline(always)]
pub const fn ts1(&self) -> u8 {
let val = (self.0 >> 16usize) & 0x0f;
val as u8
}
#[doc = "Time segment 1."]
#[inline(always)]
pub fn set_ts1(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 16usize)) | (((val as u32) & 0x0f) << 16usize);
}
#[doc = "Time segment 2."]
#[inline(always)]
pub const fn ts2(&self) -> u8 {
let val = (self.0 >> 20usize) & 0x07;
val as u8
}
#[doc = "Time segment 2."]
#[inline(always)]
pub fn set_ts2(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 20usize)) | (((val as u32) & 0x07) << 20usize);
}
#[doc = "Resynchronization jump width."]
#[inline(always)]
pub const fn sjw(&self) -> u8 {
let val = (self.0 >> 24usize) & 0x03;
val as u8
}
#[doc = "Resynchronization jump width."]
#[inline(always)]
pub fn set_sjw(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 24usize)) | (((val as u32) & 0x03) << 24usize);
}
#[doc = "Loop back mode (debug)."]
#[inline(always)]
pub const fn lbkm(&self) -> bool {
let val = (self.0 >> 30usize) & 0x01;
val != 0
}
#[doc = "Loop back mode (debug)."]
#[inline(always)]
pub fn set_lbkm(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
}
#[doc = "Silent mode (debug)."]
#[inline(always)]
pub const fn silm(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "Silent mode (debug)."]
#[inline(always)]
pub fn set_silm(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
impl Default for Btimr {
#[inline(always)]
fn default() -> Btimr {
Btimr(0)
}
}
#[doc = "CAN Master control register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ctlr(pub u32);
impl Ctlr {
#[doc = "Initialization request."]
#[inline(always)]
pub const fn inrq(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Initialization request."]
#[inline(always)]
pub fn set_inrq(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Sleep mode request."]
#[inline(always)]
pub const fn sleep(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Sleep mode request."]
#[inline(always)]
pub fn set_sleep(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Transmit FIFO priority."]
#[inline(always)]
pub const fn txfp(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Transmit FIFO priority."]
#[inline(always)]
pub fn set_txfp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Receive FIFO locked mode."]
#[inline(always)]
pub const fn rflm(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Receive FIFO locked mode."]
#[inline(always)]
pub fn set_rflm(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "No automatic retransmission."]
#[inline(always)]
pub const fn nart(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "No automatic retransmission."]
#[inline(always)]
pub fn set_nart(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Automatic wakeup mode."]
#[inline(always)]
pub const fn awum(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Automatic wakeup mode."]
#[inline(always)]
pub fn set_awum(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Automatic bus-off management."]
#[inline(always)]
pub const fn abom(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Automatic bus-off management."]
#[inline(always)]
pub fn set_abom(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Time triggered communication mode."]
#[inline(always)]
pub const fn ttcm(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Time triggered communication mode."]
#[inline(always)]
pub fn set_ttcm(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Software master reset."]
#[inline(always)]
pub const fn reset(&self) -> bool {
let val = (self.0 >> 15usize) & 0x01;
val != 0
}
#[doc = "Software master reset."]
#[inline(always)]
pub fn set_reset(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
}
#[doc = "Debug freeze."]
#[inline(always)]
pub const fn dbf(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Debug freeze."]
#[inline(always)]
pub fn set_dbf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
}
impl Default for Ctlr {
#[inline(always)]
fn default() -> Ctlr {
Ctlr(0)
}
}
#[doc = "CAN error status register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Errsr(pub u32);
impl Errsr {
#[doc = "Error warning flag."]
#[inline(always)]
pub const fn ewgf(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Error warning flag."]
#[inline(always)]
pub fn set_ewgf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Error passive flag."]
#[inline(always)]
pub const fn epvf(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Error passive flag."]
#[inline(always)]
pub fn set_epvf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Bus-off flag."]
#[inline(always)]
pub const fn boff(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Bus-off flag."]
#[inline(always)]
pub fn set_boff(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Last error code."]
#[inline(always)]
pub const fn lec(&self) -> u8 {
let val = (self.0 >> 4usize) & 0x07;
val as u8
}
#[doc = "Last error code."]
#[inline(always)]
pub fn set_lec(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 4usize)) | (((val as u32) & 0x07) << 4usize);
}
#[doc = "Least significant byte of the 9-bit transmit error counter."]
#[inline(always)]
pub const fn tec(&self) -> u8 {
let val = (self.0 >> 16usize) & 0xff;
val as u8
}
#[doc = "Least significant byte of the 9-bit transmit error counter."]
#[inline(always)]
pub fn set_tec(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 16usize)) | (((val as u32) & 0xff) << 16usize);
}
#[doc = "Receive error counter."]
#[inline(always)]
pub const fn rec(&self) -> u8 {
let val = (self.0 >> 24usize) & 0xff;
val as u8
}
#[doc = "Receive error counter."]
#[inline(always)]
pub fn set_rec(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 24usize)) | (((val as u32) & 0xff) << 24usize);
}
}
impl Default for Errsr {
#[inline(always)]
fn default() -> Errsr {
Errsr(0)
}
}
#[doc = "CAN filter FIFO assignment register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Fafifor(pub u32);
impl Fafifor {
#[doc = "Filter FIFO assignment for filter 0."]
#[inline(always)]
pub const fn ffa(&self, n: usize) -> bool {
assert!(n < 14usize);
let offs = 0usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Filter FIFO assignment for filter 0."]
#[inline(always)]
pub fn set_ffa(&mut self, n: usize, val: bool) {
assert!(n < 14usize);
let offs = 0usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
}
impl Default for Fafifor {
#[inline(always)]
fn default() -> Fafifor {
Fafifor(0)
}
}
#[doc = "CAN filter master register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Fctlr(pub u32);
impl Fctlr {
#[doc = "Filter init mode."]
#[inline(always)]
pub const fn finit(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Filter init mode."]
#[inline(always)]
pub fn set_finit(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "CAN2 start bank."]
#[inline(always)]
pub const fn can2sb(&self) -> u8 {
let val = (self.0 >> 8usize) & 0x3f;
val as u8
}
#[doc = "CAN2 start bank."]
#[inline(always)]
pub fn set_can2sb(&mut self, val: u8) {
self.0 = (self.0 & !(0x3f << 8usize)) | (((val as u32) & 0x3f) << 8usize);
}
}
impl Default for Fctlr {
#[inline(always)]
fn default() -> Fctlr {
Fctlr(0)
}
}
#[doc = "CAN filter mode register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Fmcfgr(pub u32);
impl Fmcfgr {
#[doc = "Filter mode."]
#[inline(always)]
pub const fn fbm(&self, n: usize) -> bool {
assert!(n < 14usize);
let offs = 0usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Filter mode."]
#[inline(always)]
pub fn set_fbm(&mut self, n: usize, val: bool) {
assert!(n < 14usize);
let offs = 0usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
}
impl Default for Fmcfgr {
#[inline(always)]
fn default() -> Fmcfgr {
Fmcfgr(0)
}
}
#[doc = "Filter bank 24 register 2."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Fr(pub u32);
impl Fr {
#[doc = "Filter bits."]
#[inline(always)]
pub const fn fb(&self, n: usize) -> bool {
assert!(n < 32usize);
let offs = 0usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Filter bits."]
#[inline(always)]
pub fn set_fb(&mut self, n: usize, val: bool) {
assert!(n < 32usize);
let offs = 0usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
}
impl Default for Fr {
#[inline(always)]
fn default() -> Fr {
Fr(0)
}
}
#[doc = "CAN filter scale register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Fscfgr(pub u32);
impl Fscfgr {
#[doc = "Filter scale configuration."]
#[inline(always)]
pub const fn fsc(&self, n: usize) -> bool {
assert!(n < 14usize);
let offs = 0usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Filter scale configuration."]
#[inline(always)]
pub fn set_fsc(&mut self, n: usize, val: bool) {
assert!(n < 14usize);
let offs = 0usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
}
impl Default for Fscfgr {
#[inline(always)]
fn default() -> Fscfgr {
Fscfgr(0)
}
}
#[doc = "CAN filter activation register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Fwr(pub u32);
impl Fwr {
#[doc = "Filter active."]
#[inline(always)]
pub const fn fact(&self, n: usize) -> bool {
assert!(n < 14usize);
let offs = 0usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Filter active."]
#[inline(always)]
pub fn set_fact(&mut self, n: usize, val: bool) {
assert!(n < 14usize);
let offs = 0usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
}
impl Default for Fwr {
#[inline(always)]
fn default() -> Fwr {
Fwr(0)
}
}
#[doc = "CAN interrupt enable register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Intenr(pub u32);
impl Intenr {
#[doc = "Transmit mailbox empty interrupt enable."]
#[inline(always)]
pub const fn tmeie(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Transmit mailbox empty interrupt enable."]
#[inline(always)]
pub fn set_tmeie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "FIFO message pending interrupt enable."]
#[inline(always)]
pub const fn fmpie0(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "FIFO message pending interrupt enable."]
#[inline(always)]
pub fn set_fmpie0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "FIFO full interrupt enable."]
#[inline(always)]
pub const fn ffie0(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "FIFO full interrupt enable."]
#[inline(always)]
pub fn set_ffie0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "FIFO overrun interrupt enable."]
#[inline(always)]
pub const fn fovie0(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "FIFO overrun interrupt enable."]
#[inline(always)]
pub fn set_fovie0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "FIFO message pending interrupt enable."]
#[inline(always)]
pub const fn fmpie1(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "FIFO message pending interrupt enable."]
#[inline(always)]
pub fn set_fmpie1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "FIFO full interrupt enable."]
#[inline(always)]
pub const fn ffie1(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "FIFO full interrupt enable."]
#[inline(always)]
pub fn set_ffie1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "FIFO overrun interrupt enable."]
#[inline(always)]
pub const fn fovie1(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "FIFO overrun interrupt enable."]
#[inline(always)]
pub fn set_fovie1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Error warning interrupt enable."]
#[inline(always)]
pub const fn ewgie(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Error warning interrupt enable."]
#[inline(always)]
pub fn set_ewgie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Error passive interrupt enable."]
#[inline(always)]
pub const fn epvie(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Error passive interrupt enable."]
#[inline(always)]
pub fn set_epvie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Bus-off interrupt enable."]
#[inline(always)]
pub const fn bofie(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Bus-off interrupt enable."]
#[inline(always)]
pub fn set_bofie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Last error code interrupt enable."]
#[inline(always)]
pub const fn lecie(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Last error code interrupt enable."]
#[inline(always)]
pub fn set_lecie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "Error interrupt enable."]
#[inline(always)]
pub const fn errie(&self) -> bool {
let val = (self.0 >> 15usize) & 0x01;
val != 0
}
#[doc = "Error interrupt enable."]
#[inline(always)]
pub fn set_errie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
}
#[doc = "Wakeup interrupt enable."]
#[inline(always)]
pub const fn wkuie(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Wakeup interrupt enable."]
#[inline(always)]
pub fn set_wkuie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "Sleep interrupt enable."]
#[inline(always)]
pub const fn slkie(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "Sleep interrupt enable."]
#[inline(always)]
pub fn set_slkie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
}
impl Default for Intenr {
#[inline(always)]
fn default() -> Intenr {
Intenr(0)
}
}
#[doc = "CAN receive FIFO register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rfifo(pub u32);
impl Rfifo {
#[doc = "FIFO message pending."]
#[inline(always)]
pub const fn fmp(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x03;
val as u8
}
#[doc = "FIFO message pending."]
#[inline(always)]
pub fn set_fmp(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 0usize)) | (((val as u32) & 0x03) << 0usize);
}
#[doc = "FIFO full."]
#[inline(always)]
pub const fn full(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "FIFO full."]
#[inline(always)]
pub fn set_full(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "FIFO overrun."]
#[inline(always)]
pub const fn fovr(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "FIFO overrun."]
#[inline(always)]
pub fn set_fovr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Release FIFO output mailbox."]
#[inline(always)]
pub const fn rfom(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Release FIFO output mailbox."]
#[inline(always)]
pub fn set_rfom(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
}
impl Default for Rfifo {
#[inline(always)]
fn default() -> Rfifo {
Rfifo(0)
}
}
#[doc = "CAN receive FIFO mailbox data high register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rxmdhr(pub u32);
impl Rxmdhr {
#[doc = "DATA4."]
#[inline(always)]
pub const fn data(&self, n: usize) -> u8 {
assert!(n < 4usize);
let offs = 0usize + n * 8usize;
let val = (self.0 >> offs) & 0xff;
val as u8
}
#[doc = "DATA4."]
#[inline(always)]
pub fn set_data(&mut self, n: usize, val: u8) {
assert!(n < 4usize);
let offs = 0usize + n * 8usize;
self.0 = (self.0 & !(0xff << offs)) | (((val as u32) & 0xff) << offs);
}
}
impl Default for Rxmdhr {
#[inline(always)]
fn default() -> Rxmdhr {
Rxmdhr(0)
}
}
#[doc = "CAN receive FIFO mailbox data low register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rxmdlr(pub u32);
impl Rxmdlr {
#[doc = "Data Byte 0."]
#[inline(always)]
pub const fn data(&self, n: usize) -> u8 {
assert!(n < 4usize);
let offs = 0usize + n * 8usize;
let val = (self.0 >> offs) & 0xff;
val as u8
}
#[doc = "Data Byte 0."]
#[inline(always)]
pub fn set_data(&mut self, n: usize, val: u8) {
assert!(n < 4usize);
let offs = 0usize + n * 8usize;
self.0 = (self.0 & !(0xff << offs)) | (((val as u32) & 0xff) << offs);
}
}
impl Default for Rxmdlr {
#[inline(always)]
fn default() -> Rxmdlr {
Rxmdlr(0)
}
}
#[doc = "CAN receive FIFO mailbox data length control and time stamp register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rxmdtr(pub u32);
impl Rxmdtr {
#[doc = "Data length code."]
#[inline(always)]
pub const fn dlc(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x0f;
val as u8
}
#[doc = "Data length code."]
#[inline(always)]
pub fn set_dlc(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 0usize)) | (((val as u32) & 0x0f) << 0usize);
}
#[doc = "Filter match index."]
#[inline(always)]
pub const fn fmi(&self) -> u8 {
let val = (self.0 >> 8usize) & 0xff;
val as u8
}
#[doc = "Filter match index."]
#[inline(always)]
pub fn set_fmi(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 8usize)) | (((val as u32) & 0xff) << 8usize);
}
#[doc = "Message time stamp."]
#[inline(always)]
pub const fn time(&self) -> u16 {
let val = (self.0 >> 16usize) & 0xffff;
val as u16
}
#[doc = "Message time stamp."]
#[inline(always)]
pub fn set_time(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 16usize)) | (((val as u32) & 0xffff) << 16usize);
}
}
impl Default for Rxmdtr {
#[inline(always)]
fn default() -> Rxmdtr {
Rxmdtr(0)
}
}
#[doc = "CAN receive FIFO mailbox identifier register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rxmir(pub u32);
impl Rxmir {
#[doc = "Remote transmission request."]
#[inline(always)]
pub const fn rtr(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Remote transmission request."]
#[inline(always)]
pub fn set_rtr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Identifier extension."]
#[inline(always)]
pub const fn ide(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Identifier extension."]
#[inline(always)]
pub fn set_ide(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "extended identifier."]
#[inline(always)]
pub const fn exid(&self) -> u32 {
let val = (self.0 >> 3usize) & 0x0003_ffff;
val as u32
}
#[doc = "extended identifier."]
#[inline(always)]
pub fn set_exid(&mut self, val: u32) {
self.0 = (self.0 & !(0x0003_ffff << 3usize)) | (((val as u32) & 0x0003_ffff) << 3usize);
}
#[doc = "Standard identifier."]
#[inline(always)]
pub const fn stid(&self) -> u16 {
let val = (self.0 >> 21usize) & 0x07ff;
val as u16
}
#[doc = "Standard identifier."]
#[inline(always)]
pub fn set_stid(&mut self, val: u16) {
self.0 = (self.0 & !(0x07ff << 21usize)) | (((val as u32) & 0x07ff) << 21usize);
}
}
impl Default for Rxmir {
#[inline(always)]
fn default() -> Rxmir {
Rxmir(0)
}
}
#[doc = "CAN master status register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Statr(pub u32);
impl Statr {
#[doc = "Initialization acknowledge."]
#[inline(always)]
pub const fn inak(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Initialization acknowledge."]
#[inline(always)]
pub fn set_inak(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Sleep acknowledge."]
#[inline(always)]
pub const fn slak(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Sleep acknowledge."]
#[inline(always)]
pub fn set_slak(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Error interrupt."]
#[inline(always)]
pub const fn erri(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Error interrupt."]
#[inline(always)]
pub fn set_erri(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Wakeup interrupt."]
#[inline(always)]
pub const fn wkui(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Wakeup interrupt."]
#[inline(always)]
pub fn set_wkui(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Sleep acknowledge interrupt."]
#[inline(always)]
pub const fn slaki(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Sleep acknowledge interrupt."]
#[inline(always)]
pub fn set_slaki(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Transmit mode."]
#[inline(always)]
pub const fn txm(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Transmit mode."]
#[inline(always)]
pub fn set_txm(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Receive mode."]
#[inline(always)]
pub const fn rxm(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Receive mode."]
#[inline(always)]
pub fn set_rxm(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Last sample point."]
#[inline(always)]
pub const fn samp(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Last sample point."]
#[inline(always)]
pub fn set_samp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Rx signal."]
#[inline(always)]
pub const fn rx(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Rx signal."]
#[inline(always)]
pub fn set_rx(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
}
impl Default for Statr {
#[inline(always)]
fn default() -> Statr {
Statr(0)
}
}
#[doc = "CAN transmit status register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tstatr(pub u32);
impl Tstatr {
#[doc = "Request completed mailbox0."]
#[inline(always)]
pub const fn rqcp(&self, n: usize) -> bool {
assert!(n < 3usize);
let offs = 0usize + n * 8usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Request completed mailbox0."]
#[inline(always)]
pub fn set_rqcp(&mut self, n: usize, val: bool) {
assert!(n < 3usize);
let offs = 0usize + n * 8usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
#[doc = "Transmission OK of mailbox0."]
#[inline(always)]
pub const fn txok(&self, n: usize) -> bool {
assert!(n < 3usize);
let offs = 1usize + n * 8usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Transmission OK of mailbox0."]
#[inline(always)]
pub fn set_txok(&mut self, n: usize, val: bool) {
assert!(n < 3usize);
let offs = 1usize + n * 8usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
#[doc = "Arbitration lost for mailbox0."]
#[inline(always)]
pub const fn alst(&self, n: usize) -> bool {
assert!(n < 3usize);
let offs = 2usize + n * 8usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Arbitration lost for mailbox0."]
#[inline(always)]
pub fn set_alst(&mut self, n: usize, val: bool) {
assert!(n < 3usize);
let offs = 2usize + n * 8usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
#[doc = "Transmission error of mailbox0."]
#[inline(always)]
pub const fn terr(&self, n: usize) -> bool {
assert!(n < 3usize);
let offs = 3usize + n * 8usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Transmission error of mailbox0."]
#[inline(always)]
pub fn set_terr(&mut self, n: usize, val: bool) {
assert!(n < 3usize);
let offs = 3usize + n * 8usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
#[doc = "Abort request for mailbox0."]
#[inline(always)]
pub const fn abrq(&self, n: usize) -> bool {
assert!(n < 3usize);
let offs = 7usize + n * 8usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Abort request for mailbox0."]
#[inline(always)]
pub fn set_abrq(&mut self, n: usize, val: bool) {
assert!(n < 3usize);
let offs = 7usize + n * 8usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
#[doc = "Mailbox code."]
#[inline(always)]
pub const fn code(&self) -> u8 {
let val = (self.0 >> 24usize) & 0x03;
val as u8
}
#[doc = "Mailbox code."]
#[inline(always)]
pub fn set_code(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 24usize)) | (((val as u32) & 0x03) << 24usize);
}
#[doc = "Transmit mailbox 0 empty."]
#[inline(always)]
pub const fn tme(&self, n: usize) -> bool {
assert!(n < 3usize);
let offs = 26usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Transmit mailbox 0 empty."]
#[inline(always)]
pub fn set_tme(&mut self, n: usize, val: bool) {
assert!(n < 3usize);
let offs = 26usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
#[doc = "Lowest priority flag for mailbox 0."]
#[inline(always)]
pub const fn low(&self, n: usize) -> bool {
assert!(n < 3usize);
let offs = 29usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Lowest priority flag for mailbox 0."]
#[inline(always)]
pub fn set_low(&mut self, n: usize, val: bool) {
assert!(n < 3usize);
let offs = 29usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
}
impl Default for Tstatr {
#[inline(always)]
fn default() -> Tstatr {
Tstatr(0)
}
}
#[doc = "CAN time trigger control register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ttctlr(pub u32);
impl Ttctlr {
#[doc = "Internal counter count end value."]
#[inline(always)]
pub const fn timcmv(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Internal counter count end value."]
#[inline(always)]
pub fn set_timcmv(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
#[doc = "Internal counter reset control."]
#[inline(always)]
pub const fn timrst(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Internal counter reset control."]
#[inline(always)]
pub fn set_timrst(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "Time-triggered mode selection."]
#[inline(always)]
pub const fn mode(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "Time-triggered mode selection."]
#[inline(always)]
pub fn set_mode(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
}
impl Default for Ttctlr {
#[inline(always)]
fn default() -> Ttctlr {
Ttctlr(0)
}
}
#[doc = "CAN mailbox data high register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Txmdhr(pub u32);
impl Txmdhr {
#[doc = "Data byte 4."]
#[inline(always)]
pub const fn data(&self, n: usize) -> u8 {
assert!(n < 4usize);
let offs = 0usize + n * 8usize;
let val = (self.0 >> offs) & 0xff;
val as u8
}
#[doc = "Data byte 4."]
#[inline(always)]
pub fn set_data(&mut self, n: usize, val: u8) {
assert!(n < 4usize);
let offs = 0usize + n * 8usize;
self.0 = (self.0 & !(0xff << offs)) | (((val as u32) & 0xff) << offs);
}
}
impl Default for Txmdhr {
#[inline(always)]
fn default() -> Txmdhr {
Txmdhr(0)
}
}
#[doc = "CAN mailbox data low register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Txmdlr(pub u32);
impl Txmdlr {
#[doc = "Data byte 0."]
#[inline(always)]
pub const fn data(&self, n: usize) -> u8 {
assert!(n < 4usize);
let offs = 0usize + n * 8usize;
let val = (self.0 >> offs) & 0xff;
val as u8
}
#[doc = "Data byte 0."]
#[inline(always)]
pub fn set_data(&mut self, n: usize, val: u8) {
assert!(n < 4usize);
let offs = 0usize + n * 8usize;
self.0 = (self.0 & !(0xff << offs)) | (((val as u32) & 0xff) << offs);
}
}
impl Default for Txmdlr {
#[inline(always)]
fn default() -> Txmdlr {
Txmdlr(0)
}
}
#[doc = "CAN mailbox data length control and time stamp register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Txmdtr(pub u32);
impl Txmdtr {
#[doc = "Data length code."]
#[inline(always)]
pub const fn dlc(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x0f;
val as u8
}
#[doc = "Data length code."]
#[inline(always)]
pub fn set_dlc(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 0usize)) | (((val as u32) & 0x0f) << 0usize);
}
#[doc = "Transmit global time."]
#[inline(always)]
pub const fn tgt(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Transmit global time."]
#[inline(always)]
pub fn set_tgt(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Message time stamp."]
#[inline(always)]
pub const fn time(&self) -> u16 {
let val = (self.0 >> 16usize) & 0xffff;
val as u16
}
#[doc = "Message time stamp."]
#[inline(always)]
pub fn set_time(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 16usize)) | (((val as u32) & 0xffff) << 16usize);
}
}
impl Default for Txmdtr {
#[inline(always)]
fn default() -> Txmdtr {
Txmdtr(0)
}
}
#[doc = "CAN TX mailbox identifier register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Txmir(pub u32);
impl Txmir {
#[doc = "Transmit mailbox request."]
#[inline(always)]
pub const fn txrq(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Transmit mailbox request."]
#[inline(always)]
pub fn set_txrq(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Remote transmission request."]
#[inline(always)]
pub const fn rtr(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Remote transmission request."]
#[inline(always)]
pub fn set_rtr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Identifier extension."]
#[inline(always)]
pub const fn ide(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Identifier extension."]
#[inline(always)]
pub fn set_ide(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "extended identifier."]
#[inline(always)]
pub const fn exid(&self) -> u32 {
let val = (self.0 >> 3usize) & 0x0003_ffff;
val as u32
}
#[doc = "extended identifier."]
#[inline(always)]
pub fn set_exid(&mut self, val: u32) {
self.0 = (self.0 & !(0x0003_ffff << 3usize)) | (((val as u32) & 0x0003_ffff) << 3usize);
}
#[doc = "Standard identifier."]
#[inline(always)]
pub const fn stid(&self) -> u16 {
let val = (self.0 >> 21usize) & 0x07ff;
val as u16
}
#[doc = "Standard identifier."]
#[inline(always)]
pub fn set_stid(&mut self, val: u16) {
self.0 = (self.0 & !(0x07ff << 21usize)) | (((val as u32) & 0x07ff) << 21usize);
}
}
impl Default for Txmir {
#[inline(always)]
fn default() -> Txmir {
Txmir(0)
}
}
}