#[doc = "Register `TSTAT` reader"]
pub struct R(crate::R<TSTAT_SPEC>);
impl core::ops::Deref for R {
type Target = crate::R<TSTAT_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::convert::From<crate::R<TSTAT_SPEC>> for R {
fn from(reader: crate::R<TSTAT_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `TSTAT` writer"]
pub struct W(crate::W<TSTAT_SPEC>);
impl core::ops::Deref for W {
type Target = crate::W<TSTAT_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl core::convert::From<crate::W<TSTAT_SPEC>> for W {
fn from(writer: crate::W<TSTAT_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Transmit mailbox 2 last sending in transmit FIFO\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TMLS2_A {
#[doc = "0: The mailbox doesn't have the last sending order"]
NOTLAST = 0,
#[doc = "1: The mailbox has the last sending order with at least two frames pending"]
LAST = 1,
}
impl From<TMLS2_A> for bool {
#[inline(always)]
fn from(variant: TMLS2_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `TMLS2` reader - Transmit mailbox 2 last sending in transmit FIFO"]
pub struct TMLS2_R(crate::FieldReader<bool, TMLS2_A>);
impl TMLS2_R {
pub(crate) fn new(bits: bool) -> Self {
TMLS2_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> TMLS2_A {
match self.bits {
false => TMLS2_A::NOTLAST,
true => TMLS2_A::LAST,
}
}
#[doc = "Checks if the value of the field is `NOTLAST`"]
#[inline(always)]
pub fn is_not_last(&self) -> bool {
**self == TMLS2_A::NOTLAST
}
#[doc = "Checks if the value of the field is `LAST`"]
#[inline(always)]
pub fn is_last(&self) -> bool {
**self == TMLS2_A::LAST
}
}
impl core::ops::Deref for TMLS2_R {
type Target = crate::FieldReader<bool, TMLS2_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Transmit mailbox 1 last sending in transmit FIFO"]
pub type TMLS1_A = TMLS2_A;
#[doc = "Field `TMLS1` reader - Transmit mailbox 1 last sending in transmit FIFO"]
pub type TMLS1_R = TMLS2_R;
#[doc = "Transmit mailbox 0 last sending in transmit FIFO"]
pub type TMLS0_A = TMLS2_A;
#[doc = "Field `TMLS0` reader - Transmit mailbox 0 last sending in transmit FIFO"]
pub type TMLS0_R = TMLS2_R;
#[doc = "Transmit mailbox 2 empty\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TME2_A {
#[doc = "0: Transmit mailbox not empty"]
NOTEMPTY = 0,
#[doc = "1: Transmit mailbox is empty"]
EMPTY = 1,
}
impl From<TME2_A> for bool {
#[inline(always)]
fn from(variant: TME2_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `TME2` reader - Transmit mailbox 2 empty"]
pub struct TME2_R(crate::FieldReader<bool, TME2_A>);
impl TME2_R {
pub(crate) fn new(bits: bool) -> Self {
TME2_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> TME2_A {
match self.bits {
false => TME2_A::NOTEMPTY,
true => TME2_A::EMPTY,
}
}
#[doc = "Checks if the value of the field is `NOTEMPTY`"]
#[inline(always)]
pub fn is_not_empty(&self) -> bool {
**self == TME2_A::NOTEMPTY
}
#[doc = "Checks if the value of the field is `EMPTY`"]
#[inline(always)]
pub fn is_empty(&self) -> bool {
**self == TME2_A::EMPTY
}
}
impl core::ops::Deref for TME2_R {
type Target = crate::FieldReader<bool, TME2_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Transmit mailbox 1 empty"]
pub type TME1_A = TME2_A;
#[doc = "Field `TME1` reader - Transmit mailbox 1 empty"]
pub type TME1_R = TME2_R;
#[doc = "Transmit mailbox 0 empty"]
pub type TME0_A = TME2_A;
#[doc = "Field `TME0` reader - Transmit mailbox 0 empty"]
pub type TME0_R = TME2_R;
#[doc = "Field `NUM` reader - number of the transmit FIFO mailbox in which the frame will be transmitted if at least one mailbox is empty"]
pub struct NUM_R(crate::FieldReader<u8, u8>);
impl NUM_R {
pub(crate) fn new(bits: u8) -> Self {
NUM_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for NUM_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Mailbox 2 stop transmitting\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MST2_A {
#[doc = "0: Mailbox is not stopped, or is empty"]
NOTSTOP = 0,
#[doc = "1: Stop mailbox transmitting"]
STOP = 1,
}
impl From<MST2_A> for bool {
#[inline(always)]
fn from(variant: MST2_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `MST2` reader - Mailbox 2 stop transmitting"]
pub struct MST2_R(crate::FieldReader<bool, MST2_A>);
impl MST2_R {
pub(crate) fn new(bits: bool) -> Self {
MST2_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> MST2_A {
match self.bits {
false => MST2_A::NOTSTOP,
true => MST2_A::STOP,
}
}
#[doc = "Checks if the value of the field is `NOTSTOP`"]
#[inline(always)]
pub fn is_not_stop(&self) -> bool {
**self == MST2_A::NOTSTOP
}
#[doc = "Checks if the value of the field is `STOP`"]
#[inline(always)]
pub fn is_stop(&self) -> bool {
**self == MST2_A::STOP
}
}
impl core::ops::Deref for MST2_R {
type Target = crate::FieldReader<bool, MST2_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Mailbox 2 stop transmitting\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MST2_AW {
#[doc = "1: Stop mailbox transmitting"]
STOP = 1,
}
impl From<MST2_AW> for bool {
#[inline(always)]
fn from(variant: MST2_AW) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `MST2` writer - Mailbox 2 stop transmitting"]
pub struct MST2_W<'a> {
w: &'a mut W,
}
impl<'a> MST2_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MST2_AW) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Stop mailbox transmitting"]
#[inline(always)]
pub fn stop(self) -> &'a mut W {
self.variant(MST2_AW::STOP)
}
#[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 << 23)) | ((value as u32 & 0x01) << 23);
self.w
}
}
#[doc = "Mailbox 2 transmit error\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MTE2_A {
#[doc = "0: There was no error"]
NOERROR = 0,
#[doc = "1: An error was detected"]
ERROR = 1,
}
impl From<MTE2_A> for bool {
#[inline(always)]
fn from(variant: MTE2_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `MTE2` reader - Mailbox 2 transmit error"]
pub struct MTE2_R(crate::FieldReader<bool, MTE2_A>);
impl MTE2_R {
pub(crate) fn new(bits: bool) -> Self {
MTE2_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> MTE2_A {
match self.bits {
false => MTE2_A::NOERROR,
true => MTE2_A::ERROR,
}
}
#[doc = "Checks if the value of the field is `NOERROR`"]
#[inline(always)]
pub fn is_no_error(&self) -> bool {
**self == MTE2_A::NOERROR
}
#[doc = "Checks if the value of the field is `ERROR`"]
#[inline(always)]
pub fn is_error(&self) -> bool {
**self == MTE2_A::ERROR
}
}
impl core::ops::Deref for MTE2_R {
type Target = crate::FieldReader<bool, MTE2_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Mailbox 2 transmit error\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MTE2_AW {
#[doc = "1: Clears error flag"]
CLEAR = 1,
}
impl From<MTE2_AW> for bool {
#[inline(always)]
fn from(variant: MTE2_AW) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `MTE2` writer - Mailbox 2 transmit error"]
pub struct MTE2_W<'a> {
w: &'a mut W,
}
impl<'a> MTE2_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MTE2_AW) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Clears error flag"]
#[inline(always)]
pub fn clear(self) -> &'a mut W {
self.variant(MTE2_AW::CLEAR)
}
#[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 << 19)) | ((value as u32 & 0x01) << 19);
self.w
}
}
#[doc = "Mailbox 2 arbitration lost\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MAL2_A {
#[doc = "0: Arbitration was not lost"]
NOARBITRATIONLOST = 0,
#[doc = "1: Arbitration lost"]
ARBITRATIONLOST = 1,
}
impl From<MAL2_A> for bool {
#[inline(always)]
fn from(variant: MAL2_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `MAL2` reader - Mailbox 2 arbitration lost"]
pub struct MAL2_R(crate::FieldReader<bool, MAL2_A>);
impl MAL2_R {
pub(crate) fn new(bits: bool) -> Self {
MAL2_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> MAL2_A {
match self.bits {
false => MAL2_A::NOARBITRATIONLOST,
true => MAL2_A::ARBITRATIONLOST,
}
}
#[doc = "Checks if the value of the field is `NOARBITRATIONLOST`"]
#[inline(always)]
pub fn is_no_arbitration_lost(&self) -> bool {
**self == MAL2_A::NOARBITRATIONLOST
}
#[doc = "Checks if the value of the field is `ARBITRATIONLOST`"]
#[inline(always)]
pub fn is_arbitration_lost(&self) -> bool {
**self == MAL2_A::ARBITRATIONLOST
}
}
impl core::ops::Deref for MAL2_R {
type Target = crate::FieldReader<bool, MAL2_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Mailbox 2 arbitration lost\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MAL2_AW {
#[doc = "1: Clears flag"]
CLEAR = 1,
}
impl From<MAL2_AW> for bool {
#[inline(always)]
fn from(variant: MAL2_AW) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `MAL2` writer - Mailbox 2 arbitration lost"]
pub struct MAL2_W<'a> {
w: &'a mut W,
}
impl<'a> MAL2_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MAL2_AW) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Clears flag"]
#[inline(always)]
pub fn clear(self) -> &'a mut W {
self.variant(MAL2_AW::CLEAR)
}
#[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 = "Mailbox 2 transmit finished and no error\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MTFNERR2_A {
#[doc = "0: Mailbox transmission finished with an error"]
FINISHEDWITHERROR = 0,
#[doc = "1: Mailbox transmission finished with no error"]
FINISHEDNOERROR = 1,
}
impl From<MTFNERR2_A> for bool {
#[inline(always)]
fn from(variant: MTFNERR2_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `MTFNERR2` reader - Mailbox 2 transmit finished and no error"]
pub struct MTFNERR2_R(crate::FieldReader<bool, MTFNERR2_A>);
impl MTFNERR2_R {
pub(crate) fn new(bits: bool) -> Self {
MTFNERR2_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> MTFNERR2_A {
match self.bits {
false => MTFNERR2_A::FINISHEDWITHERROR,
true => MTFNERR2_A::FINISHEDNOERROR,
}
}
#[doc = "Checks if the value of the field is `FINISHEDWITHERROR`"]
#[inline(always)]
pub fn is_finished_with_error(&self) -> bool {
**self == MTFNERR2_A::FINISHEDWITHERROR
}
#[doc = "Checks if the value of the field is `FINISHEDNOERROR`"]
#[inline(always)]
pub fn is_finished_no_error(&self) -> bool {
**self == MTFNERR2_A::FINISHEDNOERROR
}
}
impl core::ops::Deref for MTFNERR2_R {
type Target = crate::FieldReader<bool, MTFNERR2_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Mailbox 2 transmit finished and no error\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MTFNERR2_AW {
#[doc = "1: Clears flag"]
CLEAR = 1,
}
impl From<MTFNERR2_AW> for bool {
#[inline(always)]
fn from(variant: MTFNERR2_AW) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `MTFNERR2` writer - Mailbox 2 transmit finished and no error"]
pub struct MTFNERR2_W<'a> {
w: &'a mut W,
}
impl<'a> MTFNERR2_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MTFNERR2_AW) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Clears flag"]
#[inline(always)]
pub fn clear(self) -> &'a mut W {
self.variant(MTFNERR2_AW::CLEAR)
}
#[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 = "Mailbox 2 transmit finished\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MTF2_A {
#[doc = "0: Mailbox transmission still in progress"]
INPROGRESS = 0,
#[doc = "1: Mailbox transmission finished"]
FINISHED = 1,
}
impl From<MTF2_A> for bool {
#[inline(always)]
fn from(variant: MTF2_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `MTF2` reader - Mailbox 2 transmit finished"]
pub struct MTF2_R(crate::FieldReader<bool, MTF2_A>);
impl MTF2_R {
pub(crate) fn new(bits: bool) -> Self {
MTF2_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> MTF2_A {
match self.bits {
false => MTF2_A::INPROGRESS,
true => MTF2_A::FINISHED,
}
}
#[doc = "Checks if the value of the field is `INPROGRESS`"]
#[inline(always)]
pub fn is_in_progress(&self) -> bool {
**self == MTF2_A::INPROGRESS
}
#[doc = "Checks if the value of the field is `FINISHED`"]
#[inline(always)]
pub fn is_finished(&self) -> bool {
**self == MTF2_A::FINISHED
}
}
impl core::ops::Deref for MTF2_R {
type Target = crate::FieldReader<bool, MTF2_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Mailbox 2 transmit finished\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MTF2_AW {
#[doc = "1: Clears flag"]
CLEAR = 1,
}
impl From<MTF2_AW> for bool {
#[inline(always)]
fn from(variant: MTF2_AW) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `MTF2` writer - Mailbox 2 transmit finished"]
pub struct MTF2_W<'a> {
w: &'a mut W,
}
impl<'a> MTF2_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MTF2_AW) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Clears flag"]
#[inline(always)]
pub fn clear(self) -> &'a mut W {
self.variant(MTF2_AW::CLEAR)
}
#[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 = "Mailbox 1 stop transmitting"]
pub type MST1_A = MST2_A;
#[doc = "Field `MST1` reader - Mailbox 1 stop transmitting"]
pub type MST1_R = MST2_R;
#[doc = "Mailbox 1 stop transmitting"]
pub type MST1_AW = MST2_AW;
#[doc = "Field `MST1` writer - Mailbox 1 stop transmitting"]
pub struct MST1_W<'a> {
w: &'a mut W,
}
impl<'a> MST1_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MST1_AW) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Stop mailbox transmitting"]
#[inline(always)]
pub fn stop(self) -> &'a mut W {
self.variant(MST1_AW::STOP)
}
#[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 = "Mailbox 1 transmit error"]
pub type MTE1_A = MTE2_A;
#[doc = "Field `MTE1` reader - Mailbox 1 transmit error"]
pub type MTE1_R = MTE2_R;
#[doc = "Mailbox 1 transmit error"]
pub type MTE1_AW = MTE2_AW;
#[doc = "Field `MTE1` writer - Mailbox 1 transmit error"]
pub struct MTE1_W<'a> {
w: &'a mut W,
}
impl<'a> MTE1_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MTE1_AW) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Clears error flag"]
#[inline(always)]
pub fn clear(self) -> &'a mut W {
self.variant(MTE1_AW::CLEAR)
}
#[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 = "Mailbox 1 arbitration lost"]
pub type MAL1_A = MAL2_A;
#[doc = "Field `MAL1` reader - Mailbox 1 arbitration lost"]
pub type MAL1_R = MAL2_R;
#[doc = "Mailbox 1 arbitration lost"]
pub type MAL1_AW = MAL2_AW;
#[doc = "Field `MAL1` writer - Mailbox 1 arbitration lost"]
pub struct MAL1_W<'a> {
w: &'a mut W,
}
impl<'a> MAL1_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MAL1_AW) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Clears flag"]
#[inline(always)]
pub fn clear(self) -> &'a mut W {
self.variant(MAL1_AW::CLEAR)
}
#[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 << 10)) | ((value as u32 & 0x01) << 10);
self.w
}
}
#[doc = "Mailbox 1 transmit finished and no error"]
pub type MTFNERR1_A = MTFNERR2_A;
#[doc = "Field `MTFNERR1` reader - Mailbox 1 transmit finished and no error"]
pub type MTFNERR1_R = MTFNERR2_R;
#[doc = "Mailbox 1 transmit finished and no error"]
pub type MTFNERR1_AW = MTFNERR2_AW;
#[doc = "Field `MTFNERR1` writer - Mailbox 1 transmit finished and no error"]
pub struct MTFNERR1_W<'a> {
w: &'a mut W,
}
impl<'a> MTFNERR1_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MTFNERR1_AW) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Clears flag"]
#[inline(always)]
pub fn clear(self) -> &'a mut W {
self.variant(MTFNERR1_AW::CLEAR)
}
#[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 << 9)) | ((value as u32 & 0x01) << 9);
self.w
}
}
#[doc = "Mailbox 1 transmit finished"]
pub type MTF1_A = MTF2_A;
#[doc = "Field `MTF1` reader - Mailbox 1 transmit finished"]
pub type MTF1_R = MTF2_R;
#[doc = "Mailbox 1 transmit finished"]
pub type MTF1_AW = MTF2_AW;
#[doc = "Field `MTF1` writer - Mailbox 1 transmit finished"]
pub struct MTF1_W<'a> {
w: &'a mut W,
}
impl<'a> MTF1_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MTF1_AW) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Clears flag"]
#[inline(always)]
pub fn clear(self) -> &'a mut W {
self.variant(MTF1_AW::CLEAR)
}
#[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 << 8)) | ((value as u32 & 0x01) << 8);
self.w
}
}
#[doc = "Mailbox 0 stop transmitting"]
pub type MST0_A = MST2_A;
#[doc = "Field `MST0` reader - Mailbox 0 stop transmitting"]
pub type MST0_R = MST2_R;
#[doc = "Mailbox 0 stop transmitting"]
pub type MST0_AW = MST2_AW;
#[doc = "Field `MST0` writer - Mailbox 0 stop transmitting"]
pub struct MST0_W<'a> {
w: &'a mut W,
}
impl<'a> MST0_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MST0_AW) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Stop mailbox transmitting"]
#[inline(always)]
pub fn stop(self) -> &'a mut W {
self.variant(MST0_AW::STOP)
}
#[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 << 7)) | ((value as u32 & 0x01) << 7);
self.w
}
}
#[doc = "Mailbox 0 transmit error"]
pub type MTE0_A = MTE2_A;
#[doc = "Field `MTE0` reader - Mailbox 0 transmit error"]
pub type MTE0_R = MTE2_R;
#[doc = "Mailbox 0 transmit error"]
pub type MTE0_AW = MTE2_AW;
#[doc = "Field `MTE0` writer - Mailbox 0 transmit error"]
pub struct MTE0_W<'a> {
w: &'a mut W,
}
impl<'a> MTE0_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MTE0_AW) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Clears error flag"]
#[inline(always)]
pub fn clear(self) -> &'a mut W {
self.variant(MTE0_AW::CLEAR)
}
#[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 << 3)) | ((value as u32 & 0x01) << 3);
self.w
}
}
#[doc = "Mailbox 0 arbitration lost"]
pub type MAL0_A = MAL2_A;
#[doc = "Field `MAL0` reader - Mailbox 0 arbitration lost"]
pub type MAL0_R = MAL2_R;
#[doc = "Mailbox 0 arbitration lost"]
pub type MAL0_AW = MAL2_AW;
#[doc = "Field `MAL0` writer - Mailbox 0 arbitration lost"]
pub struct MAL0_W<'a> {
w: &'a mut W,
}
impl<'a> MAL0_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MAL0_AW) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Clears flag"]
#[inline(always)]
pub fn clear(self) -> &'a mut W {
self.variant(MAL0_AW::CLEAR)
}
#[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 << 2)) | ((value as u32 & 0x01) << 2);
self.w
}
}
#[doc = "Mailbox 0 transmit finished and no error"]
pub type MTFNERR0_A = MTFNERR2_A;
#[doc = "Field `MTFNERR0` reader - Mailbox 0 transmit finished and no error"]
pub type MTFNERR0_R = MTFNERR2_R;
#[doc = "Mailbox 0 transmit finished and no error"]
pub type MTFNERR0_AW = MTFNERR2_AW;
#[doc = "Field `MTFNERR0` writer - Mailbox 0 transmit finished and no error"]
pub struct MTFNERR0_W<'a> {
w: &'a mut W,
}
impl<'a> MTFNERR0_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MTFNERR0_AW) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Clears flag"]
#[inline(always)]
pub fn clear(self) -> &'a mut W {
self.variant(MTFNERR0_AW::CLEAR)
}
#[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 << 1)) | ((value as u32 & 0x01) << 1);
self.w
}
}
#[doc = "Mailbox 0 transmit finished"]
pub type MTF0_A = MTF2_A;
#[doc = "Field `MTF0` reader - Mailbox 0 transmit finished"]
pub type MTF0_R = MTF2_R;
#[doc = "Mailbox 0 transmit finished"]
pub type MTF0_AW = MTF2_AW;
#[doc = "Field `MTF0` writer - Mailbox 0 transmit finished"]
pub struct MTF0_W<'a> {
w: &'a mut W,
}
impl<'a> MTF0_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MTF0_AW) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Clears flag"]
#[inline(always)]
pub fn clear(self) -> &'a mut W {
self.variant(MTF0_AW::CLEAR)
}
#[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) | (value as u32 & 0x01);
self.w
}
}
impl R {
#[doc = "Bit 31 - Transmit mailbox 2 last sending in transmit FIFO"]
#[inline(always)]
pub fn tmls2(&self) -> TMLS2_R {
TMLS2_R::new(((self.bits >> 31) & 0x01) != 0)
}
#[doc = "Bit 30 - Transmit mailbox 1 last sending in transmit FIFO"]
#[inline(always)]
pub fn tmls1(&self) -> TMLS1_R {
TMLS1_R::new(((self.bits >> 30) & 0x01) != 0)
}
#[doc = "Bit 29 - Transmit mailbox 0 last sending in transmit FIFO"]
#[inline(always)]
pub fn tmls0(&self) -> TMLS0_R {
TMLS0_R::new(((self.bits >> 29) & 0x01) != 0)
}
#[doc = "Bit 28 - Transmit mailbox 2 empty"]
#[inline(always)]
pub fn tme2(&self) -> TME2_R {
TME2_R::new(((self.bits >> 28) & 0x01) != 0)
}
#[doc = "Bit 27 - Transmit mailbox 1 empty"]
#[inline(always)]
pub fn tme1(&self) -> TME1_R {
TME1_R::new(((self.bits >> 27) & 0x01) != 0)
}
#[doc = "Bit 26 - Transmit mailbox 0 empty"]
#[inline(always)]
pub fn tme0(&self) -> TME0_R {
TME0_R::new(((self.bits >> 26) & 0x01) != 0)
}
#[doc = "Bits 24:25 - number of the transmit FIFO mailbox in which the frame will be transmitted if at least one mailbox is empty"]
#[inline(always)]
pub fn num(&self) -> NUM_R {
NUM_R::new(((self.bits >> 24) & 0x03) as u8)
}
#[doc = "Bit 23 - Mailbox 2 stop transmitting"]
#[inline(always)]
pub fn mst2(&self) -> MST2_R {
MST2_R::new(((self.bits >> 23) & 0x01) != 0)
}
#[doc = "Bit 19 - Mailbox 2 transmit error"]
#[inline(always)]
pub fn mte2(&self) -> MTE2_R {
MTE2_R::new(((self.bits >> 19) & 0x01) != 0)
}
#[doc = "Bit 18 - Mailbox 2 arbitration lost"]
#[inline(always)]
pub fn mal2(&self) -> MAL2_R {
MAL2_R::new(((self.bits >> 18) & 0x01) != 0)
}
#[doc = "Bit 17 - Mailbox 2 transmit finished and no error"]
#[inline(always)]
pub fn mtfnerr2(&self) -> MTFNERR2_R {
MTFNERR2_R::new(((self.bits >> 17) & 0x01) != 0)
}
#[doc = "Bit 16 - Mailbox 2 transmit finished"]
#[inline(always)]
pub fn mtf2(&self) -> MTF2_R {
MTF2_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 15 - Mailbox 1 stop transmitting"]
#[inline(always)]
pub fn mst1(&self) -> MST1_R {
MST1_R::new(((self.bits >> 15) & 0x01) != 0)
}
#[doc = "Bit 11 - Mailbox 1 transmit error"]
#[inline(always)]
pub fn mte1(&self) -> MTE1_R {
MTE1_R::new(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bit 10 - Mailbox 1 arbitration lost"]
#[inline(always)]
pub fn mal1(&self) -> MAL1_R {
MAL1_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 9 - Mailbox 1 transmit finished and no error"]
#[inline(always)]
pub fn mtfnerr1(&self) -> MTFNERR1_R {
MTFNERR1_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 8 - Mailbox 1 transmit finished"]
#[inline(always)]
pub fn mtf1(&self) -> MTF1_R {
MTF1_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 7 - Mailbox 0 stop transmitting"]
#[inline(always)]
pub fn mst0(&self) -> MST0_R {
MST0_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 3 - Mailbox 0 transmit error"]
#[inline(always)]
pub fn mte0(&self) -> MTE0_R {
MTE0_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 2 - Mailbox 0 arbitration lost"]
#[inline(always)]
pub fn mal0(&self) -> MAL0_R {
MAL0_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 1 - Mailbox 0 transmit finished and no error"]
#[inline(always)]
pub fn mtfnerr0(&self) -> MTFNERR0_R {
MTFNERR0_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 0 - Mailbox 0 transmit finished"]
#[inline(always)]
pub fn mtf0(&self) -> MTF0_R {
MTF0_R::new((self.bits & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 23 - Mailbox 2 stop transmitting"]
#[inline(always)]
pub fn mst2(&mut self) -> MST2_W {
MST2_W { w: self }
}
#[doc = "Bit 19 - Mailbox 2 transmit error"]
#[inline(always)]
pub fn mte2(&mut self) -> MTE2_W {
MTE2_W { w: self }
}
#[doc = "Bit 18 - Mailbox 2 arbitration lost"]
#[inline(always)]
pub fn mal2(&mut self) -> MAL2_W {
MAL2_W { w: self }
}
#[doc = "Bit 17 - Mailbox 2 transmit finished and no error"]
#[inline(always)]
pub fn mtfnerr2(&mut self) -> MTFNERR2_W {
MTFNERR2_W { w: self }
}
#[doc = "Bit 16 - Mailbox 2 transmit finished"]
#[inline(always)]
pub fn mtf2(&mut self) -> MTF2_W {
MTF2_W { w: self }
}
#[doc = "Bit 15 - Mailbox 1 stop transmitting"]
#[inline(always)]
pub fn mst1(&mut self) -> MST1_W {
MST1_W { w: self }
}
#[doc = "Bit 11 - Mailbox 1 transmit error"]
#[inline(always)]
pub fn mte1(&mut self) -> MTE1_W {
MTE1_W { w: self }
}
#[doc = "Bit 10 - Mailbox 1 arbitration lost"]
#[inline(always)]
pub fn mal1(&mut self) -> MAL1_W {
MAL1_W { w: self }
}
#[doc = "Bit 9 - Mailbox 1 transmit finished and no error"]
#[inline(always)]
pub fn mtfnerr1(&mut self) -> MTFNERR1_W {
MTFNERR1_W { w: self }
}
#[doc = "Bit 8 - Mailbox 1 transmit finished"]
#[inline(always)]
pub fn mtf1(&mut self) -> MTF1_W {
MTF1_W { w: self }
}
#[doc = "Bit 7 - Mailbox 0 stop transmitting"]
#[inline(always)]
pub fn mst0(&mut self) -> MST0_W {
MST0_W { w: self }
}
#[doc = "Bit 3 - Mailbox 0 transmit error"]
#[inline(always)]
pub fn mte0(&mut self) -> MTE0_W {
MTE0_W { w: self }
}
#[doc = "Bit 2 - Mailbox 0 arbitration lost"]
#[inline(always)]
pub fn mal0(&mut self) -> MAL0_W {
MAL0_W { w: self }
}
#[doc = "Bit 1 - Mailbox 0 transmit finished and no error"]
#[inline(always)]
pub fn mtfnerr0(&mut self) -> MTFNERR0_W {
MTFNERR0_W { w: self }
}
#[doc = "Bit 0 - Mailbox 0 transmit finished"]
#[inline(always)]
pub fn mtf0(&mut self) -> MTF0_W {
MTF0_W { w: self }
}
#[doc = "Writes raw bits to the register."]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
}
}
#[doc = "Transmit status register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [tstat](index.html) module"]
pub struct TSTAT_SPEC;
impl crate::RegisterSpec for TSTAT_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [tstat::R](R) reader structure"]
impl crate::Readable for TSTAT_SPEC {
type Reader = R;
}
#[doc = "`write(|w| ..)` method takes [tstat::W](W) writer structure"]
impl crate::Writable for TSTAT_SPEC {
type Writer = W;
}
#[doc = "`reset()` method sets TSTAT to value 0x1c00_0000"]
impl crate::Resettable for TSTAT_SPEC {
#[inline(always)]
fn reset_value() -> Self::Ux {
0x1c00_0000
}
}