Enum Interrupt

#[non_exhaustive]
pub enum Interrupt {
    RxFifo0NewMsg = 1,
    RxFifo0Full = 2,
    RxFifo0MsgLost = 4,
    RxFifo1NewMsg = 8,
    RxFifo1Full = 16,
    RxFifo1MsgLost = 32,
    RxHighPrio = 64,
    TxComplete = 128,
    TxCancel = 256,
    TxEmpty = 512,
    TxEventNew = 1_024,
    TxEventFull = 2_048,
    TxEventLost = 4_096,
    TsWrapAround = 8_192,
    MsgRamAccessFailure = 16_384,
    TimeoutOccurred = 32_768,
    ErrLogOverflow = 65_536,
    ErrPassive = 131_072,
    WarningStatus = 262_144,
    BusOff = 524_288,
    WatchdogInt = 1_048_576,
    ProtErrArbritation = 2_097_152,
    ProtErrData = 4_194_304,
    ReservedAccess = 8_388_608,
}

FdCAN interrupt sources.

These can be individually enabled and disabled in the FdCAN peripheral. Note that each FdCAN peripheral only exposes 2 interrupts to the microcontroller:

FDCANx_INTR0, FDCANx_INTR1,

The interrupts available on each line can be configured using the [crate::config::FdCanConfig] struct.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

RxFifo0NewMsg = 1

Rx FIFO 0 has a new message

RxFifo0Full = 2

Rx FIFO 0 is full

RxFifo0MsgLost = 4

Rx FIFO 0 has lost a message

RxFifo1NewMsg = 8

Rx FIFO 1 has a new message

RxFifo1Full = 16

Rx FIFO 1 is full

RxFifo1MsgLost = 32

Rx FIFO 1 has lost a message

RxHighPrio = 64

A High Priority Message has been flagged by a filter

TxComplete = 128

Transmit has been completed

TxCancel = 256

Tx message has been cancelled

TxEmpty = 512

Tx Fifo is empty

TxEventNew = 1_024

An new Event has been received in the Tx Event Fifo

TxEventFull = 2_048

The TxEvent Fifo is full

TxEventLost = 4_096

An Tx Event has been lost

TsWrapAround = 8_192

Timestamp wrap around has occurred

MsgRamAccessFailure = 16_384

Message RAM access failure. The flag is set when the Rx handler: has not completed acceptance filtering or storage of an accepted message until the arbitration field of the following message has been received. In this case acceptance filtering or message storage is aborted and the Rx handler starts processing of the following message. was unable to write a message to the message RAM. In this case message storage is aborted. In both cases the FIFO put index is not updated. The partly stored message is overwritten when the next message is stored to this location. The flag is also set when the Tx Handler was not able to read a message from the Message RAM in time. In this case message transmission is aborted. In case of a Tx Handler access failure the FDCAN is switched into Restricted operation Mode (see Restricted operation mode).

TimeoutOccurred = 32_768

Timeout Occurred

ErrLogOverflow = 65_536

Overflow of CAN error logging counter occurred

ErrPassive = 131_072

Errr Passive

WarningStatus = 262_144

Warning Status

BusOff = 524_288

Bus_Off status

WatchdogInt = 1_048_576

Watchdog interrupt

ProtErrArbritation = 2_097_152

Protocol error in arbitration phase (nominal bit time is used)

ProtErrData = 4_194_304

Protocol error in data phase (data bit time is used)

ReservedAccess = 8_388_608

Access to reserved address

Trait Implementations

impl BitOrAssign<Interrupt> for Interrupts

Adds an interrupt to the interrupt set.

fn bitor_assign(&mut self, rhs: Interrupt)

Performs the |= operation.

impl Clone for Interrupt

fn clone(&self) -> Interrupt

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Interrupt

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Interrupt> for Interrupts

fn from(i: Interrupt) -> Self

Converts to this type from the input type.

impl PartialEq for Interrupt

fn eq(&self, other: &Interrupt) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Interrupt

impl Eq for Interrupt

impl StructuralPartialEq for Interrupt