#[doc = "Reader of register CTRL2"]
pub type R = crate::R<u32, super::CTRL2>;
#[doc = "Writer for register CTRL2"]
pub type W = crate::W<u32, super::CTRL2>;
#[doc = "Register CTRL2 `reset()`'s with value 0x0080_0000"]
impl crate::ResetValue for super::CTRL2 {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0x0080_0000
}
}
#[doc = "Time Stamp Capture Point\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum TSTAMPCAP_A {
#[doc = "0: The high resolution time stamp capture is disabled"]
TSTAMPCAP_0 = 0,
#[doc = "1: The high resolution time stamp is captured in the end of the CAN frame"]
TSTAMPCAP_1 = 1,
#[doc = "2: The high resolution time stamp is captured in the start of the CAN frame"]
TSTAMPCAP_2 = 2,
#[doc = "3: The high resolution time stamp is captured in the start of frame for classical CAN frames and in res bit for CAN FD frames"]
TSTAMPCAP_3 = 3,
}
impl From<TSTAMPCAP_A> for u8 {
#[inline(always)]
fn from(variant: TSTAMPCAP_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `TSTAMPCAP`"]
pub type TSTAMPCAP_R = crate::R<u8, TSTAMPCAP_A>;
impl TSTAMPCAP_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> TSTAMPCAP_A {
match self.bits {
0 => TSTAMPCAP_A::TSTAMPCAP_0,
1 => TSTAMPCAP_A::TSTAMPCAP_1,
2 => TSTAMPCAP_A::TSTAMPCAP_2,
3 => TSTAMPCAP_A::TSTAMPCAP_3,
_ => unreachable!(),
}
}
#[doc = "Checks if the value of the field is `TSTAMPCAP_0`"]
#[inline(always)]
pub fn is_tstampcap_0(&self) -> bool {
*self == TSTAMPCAP_A::TSTAMPCAP_0
}
#[doc = "Checks if the value of the field is `TSTAMPCAP_1`"]
#[inline(always)]
pub fn is_tstampcap_1(&self) -> bool {
*self == TSTAMPCAP_A::TSTAMPCAP_1
}
#[doc = "Checks if the value of the field is `TSTAMPCAP_2`"]
#[inline(always)]
pub fn is_tstampcap_2(&self) -> bool {
*self == TSTAMPCAP_A::TSTAMPCAP_2
}
#[doc = "Checks if the value of the field is `TSTAMPCAP_3`"]
#[inline(always)]
pub fn is_tstampcap_3(&self) -> bool {
*self == TSTAMPCAP_A::TSTAMPCAP_3
}
}
#[doc = "Write proxy for field `TSTAMPCAP`"]
pub struct TSTAMPCAP_W<'a> {
w: &'a mut W,
}
impl<'a> TSTAMPCAP_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: TSTAMPCAP_A) -> &'a mut W {
{
self.bits(variant.into())
}
}
#[doc = "The high resolution time stamp capture is disabled"]
#[inline(always)]
pub fn tstampcap_0(self) -> &'a mut W {
self.variant(TSTAMPCAP_A::TSTAMPCAP_0)
}
#[doc = "The high resolution time stamp is captured in the end of the CAN frame"]
#[inline(always)]
pub fn tstampcap_1(self) -> &'a mut W {
self.variant(TSTAMPCAP_A::TSTAMPCAP_1)
}
#[doc = "The high resolution time stamp is captured in the start of the CAN frame"]
#[inline(always)]
pub fn tstampcap_2(self) -> &'a mut W {
self.variant(TSTAMPCAP_A::TSTAMPCAP_2)
}
#[doc = "The high resolution time stamp is captured in the start of frame for classical CAN frames and in res bit for CAN FD frames"]
#[inline(always)]
pub fn tstampcap_3(self) -> &'a mut W {
self.variant(TSTAMPCAP_A::TSTAMPCAP_3)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 6)) | (((value as u32) & 0x03) << 6);
self.w
}
}
#[doc = "Message Buffer Time Stamp Base\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum MBTSBASE_A {
#[doc = "0: Message Buffer Time Stamp base is CAN_TIMER"]
MBTSBASE_0 = 0,
#[doc = "1: Message Buffer Time Stamp base is lower 16-bits of high resolution timer"]
MBTSBASE_1 = 1,
#[doc = "2: Message Buffer Time Stamp base is upper 16-bits of high resolution timerT"]
MBTSBASE_2 = 2,
}
impl From<MBTSBASE_A> for u8 {
#[inline(always)]
fn from(variant: MBTSBASE_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `MBTSBASE`"]
pub type MBTSBASE_R = crate::R<u8, MBTSBASE_A>;
impl MBTSBASE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<u8, MBTSBASE_A> {
use crate::Variant::*;
match self.bits {
0 => Val(MBTSBASE_A::MBTSBASE_0),
1 => Val(MBTSBASE_A::MBTSBASE_1),
2 => Val(MBTSBASE_A::MBTSBASE_2),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `MBTSBASE_0`"]
#[inline(always)]
pub fn is_mbtsbase_0(&self) -> bool {
*self == MBTSBASE_A::MBTSBASE_0
}
#[doc = "Checks if the value of the field is `MBTSBASE_1`"]
#[inline(always)]
pub fn is_mbtsbase_1(&self) -> bool {
*self == MBTSBASE_A::MBTSBASE_1
}
#[doc = "Checks if the value of the field is `MBTSBASE_2`"]
#[inline(always)]
pub fn is_mbtsbase_2(&self) -> bool {
*self == MBTSBASE_A::MBTSBASE_2
}
}
#[doc = "Write proxy for field `MBTSBASE`"]
pub struct MBTSBASE_W<'a> {
w: &'a mut W,
}
impl<'a> MBTSBASE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MBTSBASE_A) -> &'a mut W {
unsafe { self.bits(variant.into()) }
}
#[doc = "Message Buffer Time Stamp base is CAN_TIMER"]
#[inline(always)]
pub fn mbtsbase_0(self) -> &'a mut W {
self.variant(MBTSBASE_A::MBTSBASE_0)
}
#[doc = "Message Buffer Time Stamp base is lower 16-bits of high resolution timer"]
#[inline(always)]
pub fn mbtsbase_1(self) -> &'a mut W {
self.variant(MBTSBASE_A::MBTSBASE_1)
}
#[doc = "Message Buffer Time Stamp base is upper 16-bits of high resolution timerT"]
#[inline(always)]
pub fn mbtsbase_2(self) -> &'a mut W {
self.variant(MBTSBASE_A::MBTSBASE_2)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 8)) | (((value as u32) & 0x03) << 8);
self.w
}
}
#[doc = "Edge Filter Disable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EDFLTDIS_A {
#[doc = "0: Edge Filter is enabled"]
EDFLTDIS_0 = 0,
#[doc = "1: Edge Filter is disabled"]
EDFLTDIS_1 = 1,
}
impl From<EDFLTDIS_A> for bool {
#[inline(always)]
fn from(variant: EDFLTDIS_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `EDFLTDIS`"]
pub type EDFLTDIS_R = crate::R<bool, EDFLTDIS_A>;
impl EDFLTDIS_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> EDFLTDIS_A {
match self.bits {
false => EDFLTDIS_A::EDFLTDIS_0,
true => EDFLTDIS_A::EDFLTDIS_1,
}
}
#[doc = "Checks if the value of the field is `EDFLTDIS_0`"]
#[inline(always)]
pub fn is_edfltdis_0(&self) -> bool {
*self == EDFLTDIS_A::EDFLTDIS_0
}
#[doc = "Checks if the value of the field is `EDFLTDIS_1`"]
#[inline(always)]
pub fn is_edfltdis_1(&self) -> bool {
*self == EDFLTDIS_A::EDFLTDIS_1
}
}
#[doc = "Write proxy for field `EDFLTDIS`"]
pub struct EDFLTDIS_W<'a> {
w: &'a mut W,
}
impl<'a> EDFLTDIS_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: EDFLTDIS_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Edge Filter is enabled"]
#[inline(always)]
pub fn edfltdis_0(self) -> &'a mut W {
self.variant(EDFLTDIS_A::EDFLTDIS_0)
}
#[doc = "Edge Filter is disabled"]
#[inline(always)]
pub fn edfltdis_1(self) -> &'a mut W {
self.variant(EDFLTDIS_A::EDFLTDIS_1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 11)) | (((value as u32) & 0x01) << 11);
self.w
}
}
#[doc = "ISO CAN FD Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ISOCANFDEN_A {
#[doc = "0: FlexCAN operates using the non-ISO CAN FD protocol."]
ISOCANFDEN_0 = 0,
#[doc = "1: FlexCAN operates using the ISO CAN FD protocol (ISO 11898-1)."]
ISOCANFDEN_1 = 1,
}
impl From<ISOCANFDEN_A> for bool {
#[inline(always)]
fn from(variant: ISOCANFDEN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `ISOCANFDEN`"]
pub type ISOCANFDEN_R = crate::R<bool, ISOCANFDEN_A>;
impl ISOCANFDEN_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> ISOCANFDEN_A {
match self.bits {
false => ISOCANFDEN_A::ISOCANFDEN_0,
true => ISOCANFDEN_A::ISOCANFDEN_1,
}
}
#[doc = "Checks if the value of the field is `ISOCANFDEN_0`"]
#[inline(always)]
pub fn is_isocanfden_0(&self) -> bool {
*self == ISOCANFDEN_A::ISOCANFDEN_0
}
#[doc = "Checks if the value of the field is `ISOCANFDEN_1`"]
#[inline(always)]
pub fn is_isocanfden_1(&self) -> bool {
*self == ISOCANFDEN_A::ISOCANFDEN_1
}
}
#[doc = "Write proxy for field `ISOCANFDEN`"]
pub struct ISOCANFDEN_W<'a> {
w: &'a mut W,
}
impl<'a> ISOCANFDEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: ISOCANFDEN_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "FlexCAN operates using the non-ISO CAN FD protocol."]
#[inline(always)]
pub fn isocanfden_0(self) -> &'a mut W {
self.variant(ISOCANFDEN_A::ISOCANFDEN_0)
}
#[doc = "FlexCAN operates using the ISO CAN FD protocol (ISO 11898-1)."]
#[inline(always)]
pub fn isocanfden_1(self) -> &'a mut W {
self.variant(ISOCANFDEN_A::ISOCANFDEN_1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 12)) | (((value as u32) & 0x01) << 12);
self.w
}
}
#[doc = "Bit Timing Expansion enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum BTE_A {
#[doc = "0: CAN Bit timing expansion is disabled."]
BTE_0 = 0,
#[doc = "1: CAN bit timing expansion is enabled."]
BTE_1 = 1,
}
impl From<BTE_A> for bool {
#[inline(always)]
fn from(variant: BTE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `BTE`"]
pub type BTE_R = crate::R<bool, BTE_A>;
impl BTE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> BTE_A {
match self.bits {
false => BTE_A::BTE_0,
true => BTE_A::BTE_1,
}
}
#[doc = "Checks if the value of the field is `BTE_0`"]
#[inline(always)]
pub fn is_bte_0(&self) -> bool {
*self == BTE_A::BTE_0
}
#[doc = "Checks if the value of the field is `BTE_1`"]
#[inline(always)]
pub fn is_bte_1(&self) -> bool {
*self == BTE_A::BTE_1
}
}
#[doc = "Write proxy for field `BTE`"]
pub struct BTE_W<'a> {
w: &'a mut W,
}
impl<'a> BTE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: BTE_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "CAN Bit timing expansion is disabled."]
#[inline(always)]
pub fn bte_0(self) -> &'a mut W {
self.variant(BTE_A::BTE_0)
}
#[doc = "CAN bit timing expansion is enabled."]
#[inline(always)]
pub fn bte_1(self) -> &'a mut W {
self.variant(BTE_A::BTE_1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 13)) | (((value as u32) & 0x01) << 13);
self.w
}
}
#[doc = "Protocol Exception Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PREXCEN_A {
#[doc = "0: Protocol Exception is disabled."]
PREXCEN_0 = 0,
#[doc = "1: Protocol Exception is enabled."]
PREXCEN_1 = 1,
}
impl From<PREXCEN_A> for bool {
#[inline(always)]
fn from(variant: PREXCEN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `PREXCEN`"]
pub type PREXCEN_R = crate::R<bool, PREXCEN_A>;
impl PREXCEN_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> PREXCEN_A {
match self.bits {
false => PREXCEN_A::PREXCEN_0,
true => PREXCEN_A::PREXCEN_1,
}
}
#[doc = "Checks if the value of the field is `PREXCEN_0`"]
#[inline(always)]
pub fn is_prexcen_0(&self) -> bool {
*self == PREXCEN_A::PREXCEN_0
}
#[doc = "Checks if the value of the field is `PREXCEN_1`"]
#[inline(always)]
pub fn is_prexcen_1(&self) -> bool {
*self == PREXCEN_A::PREXCEN_1
}
}
#[doc = "Write proxy for field `PREXCEN`"]
pub struct PREXCEN_W<'a> {
w: &'a mut W,
}
impl<'a> PREXCEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: PREXCEN_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Protocol Exception is disabled."]
#[inline(always)]
pub fn prexcen_0(self) -> &'a mut W {
self.variant(PREXCEN_A::PREXCEN_0)
}
#[doc = "Protocol Exception is enabled."]
#[inline(always)]
pub fn prexcen_1(self) -> &'a mut W {
self.variant(PREXCEN_A::PREXCEN_1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 14)) | (((value as u32) & 0x01) << 14);
self.w
}
}
#[doc = "Timer Source\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TIMER_SRC_A {
#[doc = "0: The Free Running Timer is clocked by the CAN bit clock, which defines the baud rate on the CAN bus."]
TIMER_SRC_0 = 0,
#[doc = "1: The Free Running Timer is clocked by an external time tick. The period can be either adjusted to be equal to the baud rate on the CAN bus, or a different value as required. See the device specific section for details about the external time tick."]
TIMER_SRC_1 = 1,
}
impl From<TIMER_SRC_A> for bool {
#[inline(always)]
fn from(variant: TIMER_SRC_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `TIMER_SRC`"]
pub type TIMER_SRC_R = crate::R<bool, TIMER_SRC_A>;
impl TIMER_SRC_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> TIMER_SRC_A {
match self.bits {
false => TIMER_SRC_A::TIMER_SRC_0,
true => TIMER_SRC_A::TIMER_SRC_1,
}
}
#[doc = "Checks if the value of the field is `TIMER_SRC_0`"]
#[inline(always)]
pub fn is_timer_src_0(&self) -> bool {
*self == TIMER_SRC_A::TIMER_SRC_0
}
#[doc = "Checks if the value of the field is `TIMER_SRC_1`"]
#[inline(always)]
pub fn is_timer_src_1(&self) -> bool {
*self == TIMER_SRC_A::TIMER_SRC_1
}
}
#[doc = "Write proxy for field `TIMER_SRC`"]
pub struct TIMER_SRC_W<'a> {
w: &'a mut W,
}
impl<'a> TIMER_SRC_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: TIMER_SRC_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "The Free Running Timer is clocked by the CAN bit clock, which defines the baud rate on the CAN bus."]
#[inline(always)]
pub fn timer_src_0(self) -> &'a mut W {
self.variant(TIMER_SRC_A::TIMER_SRC_0)
}
#[doc = "The Free Running Timer is clocked by an external time tick. The period can be either adjusted to be equal to the baud rate on the CAN bus, or a different value as required. See the device specific section for details about the external time tick."]
#[inline(always)]
pub fn timer_src_1(self) -> &'a mut W {
self.variant(TIMER_SRC_A::TIMER_SRC_1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 15)) | (((value as u32) & 0x01) << 15);
self.w
}
}
#[doc = "Entire Frame Arbitration Field Comparison Enable For Rx Mailboxes\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EACEN_A {
#[doc = "0: Rx Mailbox filter's IDE bit is always compared and RTR is never compared despite mask bits."]
EACEN_0 = 0,
#[doc = "1: Enables the comparison of both Rx Mailbox filter's IDE and RTR bit with their corresponding bits within the incoming frame. Mask bits do apply."]
EACEN_1 = 1,
}
impl From<EACEN_A> for bool {
#[inline(always)]
fn from(variant: EACEN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `EACEN`"]
pub type EACEN_R = crate::R<bool, EACEN_A>;
impl EACEN_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> EACEN_A {
match self.bits {
false => EACEN_A::EACEN_0,
true => EACEN_A::EACEN_1,
}
}
#[doc = "Checks if the value of the field is `EACEN_0`"]
#[inline(always)]
pub fn is_eacen_0(&self) -> bool {
*self == EACEN_A::EACEN_0
}
#[doc = "Checks if the value of the field is `EACEN_1`"]
#[inline(always)]
pub fn is_eacen_1(&self) -> bool {
*self == EACEN_A::EACEN_1
}
}
#[doc = "Write proxy for field `EACEN`"]
pub struct EACEN_W<'a> {
w: &'a mut W,
}
impl<'a> EACEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: EACEN_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Rx Mailbox filter's IDE bit is always compared and RTR is never compared despite mask bits."]
#[inline(always)]
pub fn eacen_0(self) -> &'a mut W {
self.variant(EACEN_A::EACEN_0)
}
#[doc = "Enables the comparison of both Rx Mailbox filter's IDE and RTR bit with their corresponding bits within the incoming frame. Mask bits do apply."]
#[inline(always)]
pub fn eacen_1(self) -> &'a mut W {
self.variant(EACEN_A::EACEN_1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 16)) | (((value as u32) & 0x01) << 16);
self.w
}
}
#[doc = "Remote Request Storing\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RRS_A {
#[doc = "0: Remote Response Frame is generated."]
RRS_0 = 0,
#[doc = "1: Remote Request Frame is stored."]
RRS_1 = 1,
}
impl From<RRS_A> for bool {
#[inline(always)]
fn from(variant: RRS_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `RRS`"]
pub type RRS_R = crate::R<bool, RRS_A>;
impl RRS_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> RRS_A {
match self.bits {
false => RRS_A::RRS_0,
true => RRS_A::RRS_1,
}
}
#[doc = "Checks if the value of the field is `RRS_0`"]
#[inline(always)]
pub fn is_rrs_0(&self) -> bool {
*self == RRS_A::RRS_0
}
#[doc = "Checks if the value of the field is `RRS_1`"]
#[inline(always)]
pub fn is_rrs_1(&self) -> bool {
*self == RRS_A::RRS_1
}
}
#[doc = "Write proxy for field `RRS`"]
pub struct RRS_W<'a> {
w: &'a mut W,
}
impl<'a> RRS_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: RRS_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Remote Response Frame is generated."]
#[inline(always)]
pub fn rrs_0(self) -> &'a mut W {
self.variant(RRS_A::RRS_0)
}
#[doc = "Remote Request Frame is stored."]
#[inline(always)]
pub fn rrs_1(self) -> &'a mut W {
self.variant(RRS_A::RRS_1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 17)) | (((value as u32) & 0x01) << 17);
self.w
}
}
#[doc = "Mailboxes Reception Priority\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MRP_A {
#[doc = "0: Matching starts from Legacy Rx FIFO or Enhanced Rx FIFO and continues on Mailboxes."]
MRP_0 = 0,
#[doc = "1: Matching starts from Mailboxes and continues on Legacy Rx FIFO or Enhanced Rx FIFO ."]
MRP_1 = 1,
}
impl From<MRP_A> for bool {
#[inline(always)]
fn from(variant: MRP_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `MRP`"]
pub type MRP_R = crate::R<bool, MRP_A>;
impl MRP_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> MRP_A {
match self.bits {
false => MRP_A::MRP_0,
true => MRP_A::MRP_1,
}
}
#[doc = "Checks if the value of the field is `MRP_0`"]
#[inline(always)]
pub fn is_mrp_0(&self) -> bool {
*self == MRP_A::MRP_0
}
#[doc = "Checks if the value of the field is `MRP_1`"]
#[inline(always)]
pub fn is_mrp_1(&self) -> bool {
*self == MRP_A::MRP_1
}
}
#[doc = "Write proxy for field `MRP`"]
pub struct MRP_W<'a> {
w: &'a mut W,
}
impl<'a> MRP_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MRP_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Matching starts from Legacy Rx FIFO or Enhanced Rx FIFO and continues on Mailboxes."]
#[inline(always)]
pub fn mrp_0(self) -> &'a mut W {
self.variant(MRP_A::MRP_0)
}
#[doc = "Matching starts from Mailboxes and continues on Legacy Rx FIFO or Enhanced Rx FIFO ."]
#[inline(always)]
pub fn mrp_1(self) -> &'a mut W {
self.variant(MRP_A::MRP_1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 18)) | (((value as u32) & 0x01) << 18);
self.w
}
}
#[doc = "Reader of field `TASD`"]
pub type TASD_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `TASD`"]
pub struct TASD_W<'a> {
w: &'a mut W,
}
impl<'a> TASD_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x1f << 19)) | (((value as u32) & 0x1f) << 19);
self.w
}
}
#[doc = "Reader of field `RFFN`"]
pub type RFFN_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `RFFN`"]
pub struct RFFN_W<'a> {
w: &'a mut W,
}
impl<'a> RFFN_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 24)) | (((value as u32) & 0x0f) << 24);
self.w
}
}
#[doc = "Bus Off Done Interrupt Mask\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum BOFFDONEMSK_A {
#[doc = "0: Bus Off Done interrupt disabled."]
BOFFDONEMSK_0 = 0,
#[doc = "1: Bus Off Done interrupt enabled."]
BOFFDONEMSK_1 = 1,
}
impl From<BOFFDONEMSK_A> for bool {
#[inline(always)]
fn from(variant: BOFFDONEMSK_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `BOFFDONEMSK`"]
pub type BOFFDONEMSK_R = crate::R<bool, BOFFDONEMSK_A>;
impl BOFFDONEMSK_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> BOFFDONEMSK_A {
match self.bits {
false => BOFFDONEMSK_A::BOFFDONEMSK_0,
true => BOFFDONEMSK_A::BOFFDONEMSK_1,
}
}
#[doc = "Checks if the value of the field is `BOFFDONEMSK_0`"]
#[inline(always)]
pub fn is_boffdonemsk_0(&self) -> bool {
*self == BOFFDONEMSK_A::BOFFDONEMSK_0
}
#[doc = "Checks if the value of the field is `BOFFDONEMSK_1`"]
#[inline(always)]
pub fn is_boffdonemsk_1(&self) -> bool {
*self == BOFFDONEMSK_A::BOFFDONEMSK_1
}
}
#[doc = "Write proxy for field `BOFFDONEMSK`"]
pub struct BOFFDONEMSK_W<'a> {
w: &'a mut W,
}
impl<'a> BOFFDONEMSK_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: BOFFDONEMSK_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Bus Off Done interrupt disabled."]
#[inline(always)]
pub fn boffdonemsk_0(self) -> &'a mut W {
self.variant(BOFFDONEMSK_A::BOFFDONEMSK_0)
}
#[doc = "Bus Off Done interrupt enabled."]
#[inline(always)]
pub fn boffdonemsk_1(self) -> &'a mut W {
self.variant(BOFFDONEMSK_A::BOFFDONEMSK_1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 30)) | (((value as u32) & 0x01) << 30);
self.w
}
}
#[doc = "Error Interrupt Mask for errors detected in the Data Phase of fast CAN FD frames\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ERRMSK_FAST_A {
#[doc = "0: ERRINT_FAST Error interrupt disabled."]
ERRMSK_FAST_0 = 0,
#[doc = "1: ERRINT_FAST Error interrupt enabled."]
ERRMSK_FAST_1 = 1,
}
impl From<ERRMSK_FAST_A> for bool {
#[inline(always)]
fn from(variant: ERRMSK_FAST_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `ERRMSK_FAST`"]
pub type ERRMSK_FAST_R = crate::R<bool, ERRMSK_FAST_A>;
impl ERRMSK_FAST_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> ERRMSK_FAST_A {
match self.bits {
false => ERRMSK_FAST_A::ERRMSK_FAST_0,
true => ERRMSK_FAST_A::ERRMSK_FAST_1,
}
}
#[doc = "Checks if the value of the field is `ERRMSK_FAST_0`"]
#[inline(always)]
pub fn is_errmsk_fast_0(&self) -> bool {
*self == ERRMSK_FAST_A::ERRMSK_FAST_0
}
#[doc = "Checks if the value of the field is `ERRMSK_FAST_1`"]
#[inline(always)]
pub fn is_errmsk_fast_1(&self) -> bool {
*self == ERRMSK_FAST_A::ERRMSK_FAST_1
}
}
#[doc = "Write proxy for field `ERRMSK_FAST`"]
pub struct ERRMSK_FAST_W<'a> {
w: &'a mut W,
}
impl<'a> ERRMSK_FAST_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: ERRMSK_FAST_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "ERRINT_FAST Error interrupt disabled."]
#[inline(always)]
pub fn errmsk_fast_0(self) -> &'a mut W {
self.variant(ERRMSK_FAST_A::ERRMSK_FAST_0)
}
#[doc = "ERRINT_FAST Error interrupt enabled."]
#[inline(always)]
pub fn errmsk_fast_1(self) -> &'a mut W {
self.variant(ERRMSK_FAST_A::ERRMSK_FAST_1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 31)) | (((value as u32) & 0x01) << 31);
self.w
}
}
impl R {
#[doc = "Bits 6:7 - Time Stamp Capture Point"]
#[inline(always)]
pub fn tstampcap(&self) -> TSTAMPCAP_R {
TSTAMPCAP_R::new(((self.bits >> 6) & 0x03) as u8)
}
#[doc = "Bits 8:9 - Message Buffer Time Stamp Base"]
#[inline(always)]
pub fn mbtsbase(&self) -> MBTSBASE_R {
MBTSBASE_R::new(((self.bits >> 8) & 0x03) as u8)
}
#[doc = "Bit 11 - Edge Filter Disable"]
#[inline(always)]
pub fn edfltdis(&self) -> EDFLTDIS_R {
EDFLTDIS_R::new(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bit 12 - ISO CAN FD Enable"]
#[inline(always)]
pub fn isocanfden(&self) -> ISOCANFDEN_R {
ISOCANFDEN_R::new(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 13 - Bit Timing Expansion enable"]
#[inline(always)]
pub fn bte(&self) -> BTE_R {
BTE_R::new(((self.bits >> 13) & 0x01) != 0)
}
#[doc = "Bit 14 - Protocol Exception Enable"]
#[inline(always)]
pub fn prexcen(&self) -> PREXCEN_R {
PREXCEN_R::new(((self.bits >> 14) & 0x01) != 0)
}
#[doc = "Bit 15 - Timer Source"]
#[inline(always)]
pub fn timer_src(&self) -> TIMER_SRC_R {
TIMER_SRC_R::new(((self.bits >> 15) & 0x01) != 0)
}
#[doc = "Bit 16 - Entire Frame Arbitration Field Comparison Enable For Rx Mailboxes"]
#[inline(always)]
pub fn eacen(&self) -> EACEN_R {
EACEN_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 17 - Remote Request Storing"]
#[inline(always)]
pub fn rrs(&self) -> RRS_R {
RRS_R::new(((self.bits >> 17) & 0x01) != 0)
}
#[doc = "Bit 18 - Mailboxes Reception Priority"]
#[inline(always)]
pub fn mrp(&self) -> MRP_R {
MRP_R::new(((self.bits >> 18) & 0x01) != 0)
}
#[doc = "Bits 19:23 - Tx Arbitration Start Delay"]
#[inline(always)]
pub fn tasd(&self) -> TASD_R {
TASD_R::new(((self.bits >> 19) & 0x1f) as u8)
}
#[doc = "Bits 24:27 - Number Of Legacy Rx FIFO Filters"]
#[inline(always)]
pub fn rffn(&self) -> RFFN_R {
RFFN_R::new(((self.bits >> 24) & 0x0f) as u8)
}
#[doc = "Bit 30 - Bus Off Done Interrupt Mask"]
#[inline(always)]
pub fn boffdonemsk(&self) -> BOFFDONEMSK_R {
BOFFDONEMSK_R::new(((self.bits >> 30) & 0x01) != 0)
}
#[doc = "Bit 31 - Error Interrupt Mask for errors detected in the Data Phase of fast CAN FD frames"]
#[inline(always)]
pub fn errmsk_fast(&self) -> ERRMSK_FAST_R {
ERRMSK_FAST_R::new(((self.bits >> 31) & 0x01) != 0)
}
}
impl W {
#[doc = "Bits 6:7 - Time Stamp Capture Point"]
#[inline(always)]
pub fn tstampcap(&mut self) -> TSTAMPCAP_W {
TSTAMPCAP_W { w: self }
}
#[doc = "Bits 8:9 - Message Buffer Time Stamp Base"]
#[inline(always)]
pub fn mbtsbase(&mut self) -> MBTSBASE_W {
MBTSBASE_W { w: self }
}
#[doc = "Bit 11 - Edge Filter Disable"]
#[inline(always)]
pub fn edfltdis(&mut self) -> EDFLTDIS_W {
EDFLTDIS_W { w: self }
}
#[doc = "Bit 12 - ISO CAN FD Enable"]
#[inline(always)]
pub fn isocanfden(&mut self) -> ISOCANFDEN_W {
ISOCANFDEN_W { w: self }
}
#[doc = "Bit 13 - Bit Timing Expansion enable"]
#[inline(always)]
pub fn bte(&mut self) -> BTE_W {
BTE_W { w: self }
}
#[doc = "Bit 14 - Protocol Exception Enable"]
#[inline(always)]
pub fn prexcen(&mut self) -> PREXCEN_W {
PREXCEN_W { w: self }
}
#[doc = "Bit 15 - Timer Source"]
#[inline(always)]
pub fn timer_src(&mut self) -> TIMER_SRC_W {
TIMER_SRC_W { w: self }
}
#[doc = "Bit 16 - Entire Frame Arbitration Field Comparison Enable For Rx Mailboxes"]
#[inline(always)]
pub fn eacen(&mut self) -> EACEN_W {
EACEN_W { w: self }
}
#[doc = "Bit 17 - Remote Request Storing"]
#[inline(always)]
pub fn rrs(&mut self) -> RRS_W {
RRS_W { w: self }
}
#[doc = "Bit 18 - Mailboxes Reception Priority"]
#[inline(always)]
pub fn mrp(&mut self) -> MRP_W {
MRP_W { w: self }
}
#[doc = "Bits 19:23 - Tx Arbitration Start Delay"]
#[inline(always)]
pub fn tasd(&mut self) -> TASD_W {
TASD_W { w: self }
}
#[doc = "Bits 24:27 - Number Of Legacy Rx FIFO Filters"]
#[inline(always)]
pub fn rffn(&mut self) -> RFFN_W {
RFFN_W { w: self }
}
#[doc = "Bit 30 - Bus Off Done Interrupt Mask"]
#[inline(always)]
pub fn boffdonemsk(&mut self) -> BOFFDONEMSK_W {
BOFFDONEMSK_W { w: self }
}
#[doc = "Bit 31 - Error Interrupt Mask for errors detected in the Data Phase of fast CAN FD frames"]
#[inline(always)]
pub fn errmsk_fast(&mut self) -> ERRMSK_FAST_W {
ERRMSK_FAST_W { w: self }
}
}