Struct stm32f429zi::can::Can

pub struct Can<'a> { /* private fields */ }

Implementations

impl<'a> Can<'a>

pub fn new(rcc: &'a Rcc, registers: StaticRef<Registers>) -> Can<'a>

pub fn enable(&self) -> Result<(), ErrorCode>

Enable the peripheral with the stored communication parameters: bit timing settings and communication mode

pub fn config_filter(&self, filter_info: FilterParameters, enable: bool)

Configure a filter to receive messages

pub fn enable_filter_config(&self)

pub fn enter_normal_mode(&self) -> Result<(), ErrorCode>

pub fn enter_sleep_mode(&self)

pub fn send_8byte_message( &self, id: Id, dlc: usize, rtr: u8 ) -> Result<(), ErrorCode>

This function sends an 8-byte message

pub fn find_empty_mailbox(&self) -> Option<usize>

pub fn is_enabled_clock(&self) -> bool

pub fn enable_clock(&self)

pub fn disable_clock(&self)

pub fn handle_transmit_interrupt(&self)

Handle the transmit interrupt. Check the status register for each transmit mailbox to find out the mailbox that the message was sent from.

pub fn process_received_message( &self, rx_mailbox: usize ) -> (Id, usize, [u8; 8])

pub fn handle_fifo0_interrupt(&self)

pub fn handle_fifo1_interrupt(&self)

pub fn handle_error_status_interrupt(&self)

pub fn enable_irq(&self, interrupt: CanInterruptMode)

pub fn disable_irq(&self, interrupt: CanInterruptMode)

pub fn enable_irqs(&self)

pub fn disable_irqs(&self)

Trait Implementations

impl Configure for Can<'_>

const MIN_BIT_TIMINGS: BitTiming = _

Constants that define the minimum and maximum values that the timing parameters can take. They are used when calculating the optimum timing parameters for a given bitrate.

const MAX_BIT_TIMINGS: BitTiming = _

const SYNC_SEG: u8 = 1u8

This constant represents the synchronization segment. Most CAN devices seems to have define this in hardware to 1 quantum long. 1 quantum long. It is used for the synchronization of the clocks.

fn set_bitrate(&self, bitrate: u32) -> Result<(), ErrorCode>

Configures the CAN peripheral at the given bitrate. This function is supposed to be called before the enable function. This function is synchronous as the driver should only calculate the timing parameters based on the bitrate and the frequency of the board and store them. This function does not configure the hardware.

fn set_bit_timing(&self, bit_timing: BitTiming) -> Result<(), ErrorCode>

Configures the CAN peripheral with the given arguments. This function is supposed to be called before the enable function. This function is synchronous as the driver should only store the arguments, and should not configure the hardware.

fn set_operation_mode(&self, mode: OperationMode) -> Result<(), ErrorCode>

Configures the CAN peripheral with the given arguments. This function is supposed to be called before the enable function. This function is synchronous as the driver should only store the arguments, and should not configure the hardware.

fn get_bit_timing(&self) -> Result<BitTiming, ErrorCode>

Returns the current timing parameters for the CAN peripheral.

fn get_operation_mode(&self) -> Result<OperationMode, ErrorCode>

Returns the current operating mode for the CAN peripheral.

fn set_automatic_retransmission(&self, automatic: bool) -> Result<(), ErrorCode>

Configures the CAN peripheral with the automatic retransmission setting. This function is optional, but if used, must be called before the enable function. This function is synchronous as the driver should only store the arguments, and should not configure the hardware.

fn set_wake_up(&self, wake_up: bool) -> Result<(), ErrorCode>

Configures the CAN peripheral with the automatic wake up setting. This function is optional, but if used, must be called before the enable function. This function is synchronous as the driver should only store the arguments, and should not configure the hardware.

fn get_automatic_retransmission(&self) -> Result<bool, ErrorCode>

Returns the current automatic retransmission setting of the peripheral.

fn get_wake_up(&self) -> Result<bool, ErrorCode>

Returns the current automatic wake up setting of the peripheral.

fn receive_fifo_count(&self) -> usize

Returns the number of receive FIFOs the peripheral provides

impl Controller for Can<'_>

fn set_client(&self, client: Option<&'static dyn ControllerClient>)

Set the client to be used for callbacks of the Controller implementation.

fn enable(&self) -> Result<(), ErrorCode>

This function enables the CAN peripheral with the Timing, Operation and Mode arguments that are provided to the driver before calling the enable function.

fn disable(&self) -> Result<(), ErrorCode>

This function disables the CAN peripheral and puts it in Sleep Mode. The peripheral must be previously enabled.

fn get_state(&self) -> Result<State, ErrorCode>

This function returns the current state of the CAN peripheral.

impl DeferredCallClient for Can<'_>

fn register(&'static self)

fn handle_deferred_call(&self)

impl Receive<stm32f4xx::::can::{impl#7}::{constant#0}> for Can<'_>

fn set_client( &self, client: Option<&'static dyn ReceiveClient<stm32f4xx::::can::{impl#7}::set_client::{constant#0}>> )

Set the client to be used for callbacks of the Receive implementation.

fn start_receive_process( &self, buffer: &'static mut [u8; 8] ) -> Result<(), (ErrorCode, &'static mut [u8; 8])>

Start receiving messaged on the CAN bus.

fn stop_receive(&self) -> Result<(), ErrorCode>

Asks the driver to stop receiving messages. This function should be called only after a call to the start_receive_process function.

const PACKET_SIZE: usize = PACKET_SIZE

impl Transmit<stm32f4xx::::can::{impl#6}::{constant#0}> for Can<'_>

fn set_client( &self, client: Option<&'static dyn TransmitClient<stm32f4xx::::can::{impl#6}::set_client::{constant#0}>> )

Set the client to be used for callbacks of the Transmit implementation.

fn send( &self, id: Id, buffer: &'static mut [u8; 8], len: usize ) -> Result<(), (ErrorCode, &'static mut [u8; 8])>

Sends a buffer using the CAN bus.

const PACKET_SIZE: usize = PACKET_SIZE