Struct embassy_stm32::can::Can

pub struct Can<'d, T: Instance> { /* private fields */ }

CAN driver

Implementations

impl<'d, T: Instance> Can<'d, T>

pub fn new( peri: impl Peripheral<P = T> + 'd, rx: impl Peripheral<P = impl RxPin<T>> + 'd, tx: impl Peripheral<P = impl TxPin<T>> + 'd, _irqs: impl Binding<T::TXInterrupt, TxInterruptHandler<T>> + Binding<T::RX0Interrupt, Rx0InterruptHandler<T>> + Binding<T::RX1Interrupt, Rx1InterruptHandler<T>> + Binding<T::SCEInterrupt, SceInterruptHandler<T>> + 'd ) -> Self

Creates a new Bxcan instance, keeping the peripheral in sleep mode. You must call [Can::enable_non_blocking] to use the peripheral.

pub fn set_bitrate(&mut self, bitrate: u32)

Set CAN bit rate.

pub fn modify_config(&mut self) -> CanConfig<'_, T>

Configure bit timings and silent/loop-back mode.

Calling this method will enter initialization mode. You must enable the peripheral again afterwards with enable.

pub async fn enable(&mut self)

Enables the peripheral and synchronizes with the bus.

This will wait for 11 consecutive recessive bits (bus idle state). Contrary to enable method from bxcan library, this will not freeze the executor while waiting.

pub fn set_automatic_wakeup(&mut self, enabled: bool)

Enables or disables the peripheral from automatically wakeup when a SOF is detected on the bus while the peripheral is in sleep mode

pub fn wakeup(&mut self)

Manually wake the peripheral from sleep mode.

Waking the peripheral manually does not trigger a wake-up interrupt. This will wait until the peripheral has acknowledged it has awoken from sleep mode

pub fn is_sleeping(&self) -> bool

Check if the peripheral is currently in sleep mode

pub async fn sleep(&mut self)

Put the peripheral in sleep mode

When the peripherial is in sleep mode, messages can still be queued for transmission and any previously received messages can be read from the receive FIFOs, however no messages will be transmitted and no additional messages will be received.

If the peripheral has automatic wakeup enabled, when a Start-of-Frame is detected the peripheral will automatically wake and receive the incoming message.

pub async fn write(&mut self, frame: &Frame) -> TransmitStatus

Queues the message to be sent.

If the TX queue is full, this will wait until there is space, therefore exerting backpressure.

pub fn try_write( &mut self, frame: &Frame ) -> Result<TransmitStatus, TryWriteError>

Attempts to transmit a frame without blocking.

Returns [Err(TryWriteError::Full)] if all transmit mailboxes are full.

pub async fn flush(&self, mb: Mailbox)

Waits for a specific transmit mailbox to become empty

pub async fn flush_any(&self)

Waits until any of the transmit mailboxes become empty

pub async fn flush_all(&self)

Waits until all of the transmit mailboxes become empty

pub fn abort(&mut self, mailbox: Mailbox) -> bool

Attempts to abort the sending of a frame that is pending in a mailbox.

If there is no frame in the provided mailbox, or its transmission succeeds before it can be aborted, this function has no effect and returns false.

If there is a frame in the provided mailbox, and it is canceled successfully, this function returns true.

pub fn is_transmitter_idle(&self) -> bool

Returns true if no frame is pending for transmission.

pub async fn read(&mut self) -> Result<Envelope, BusError>

Read a CAN frame.

If no CAN frame is in the RX buffer, this will wait until there is one.

Returns a tuple of the time the message was received and the message frame

pub fn try_read(&mut self) -> Result<Envelope, TryReadError>

Attempts to read a CAN frame without blocking.

Returns [Err(TryReadError::Empty)] if there are no frames in the rx queue.

pub async fn wait_not_empty(&mut self)

Waits while receive queue is empty.

pub fn split<'c>(&'c mut self) -> (CanTx<'d, T>, CanRx<'d, T>)

Split the CAN driver into transmit and receive halves.

Useful for doing separate transmit/receive tasks.

pub fn buffered<'c, const TX_BUF_SIZE: usize, const RX_BUF_SIZE: usize>( &'c mut self, txb: &'static mut TxBuf<TX_BUF_SIZE>, rxb: &'static mut RxBuf<RX_BUF_SIZE> ) -> BufferedCan<'d, T, TX_BUF_SIZE, RX_BUF_SIZE>

Return a buffered instance of driver. User must supply Buffers

impl<'d, T: FilterOwner> Can<'d, T>

pub fn modify_filters(&mut self) -> MasterFilters<'_, T>

Accesses the filter banks owned by this CAN peripheral.

To modify filters of a slave peripheral, modify_filters has to be called on the master peripheral instead.

Trait Implementations

impl<'d, T: Instance> Drop for Can<'d, T>

fn drop(&mut self)

Executes the destructor for this type.