Struct canadensis_can::CanReceiver

pub struct CanReceiver<C: Clock, D> { /* private fields */ }

Handles subscriptions and assembles incoming frames into transfers

Implementations

impl<C, D> CanReceiver<C, D>where C: Clock, D: ReceiveDriver<C>,

pub fn new(id: CanNodeId, mtu: Mtu) -> Self

Creates a receiver

id: The ID of this node. This is used to filter incoming service requests and responses.

pub fn new_anonymous(mtu: Mtu) -> Self

Creates an anonymous receiver

An anonymous receiver cannot receive service requests or responses.

pub fn set_id(&mut self, id: Option<CanNodeId>)

Updates the identifier of this node

This can be used after a node ID is identified to make this receiver capable of handling service transfers.

pub fn transfer_count(&self) -> u64

Returns the number of transfers successfully received

pub fn error_count(&self) -> u64

Returns the number of transfers that could not be received correctly

Errors include failure to allocate memory (when handling incoming frames only), missing frames, and malformed frames.

Trait Implementations

impl<C: Debug + Clock, D: Debug> Debug for CanReceiver<C, D>where C::Instant: Debug,

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

Formats the value using the given formatter.

impl<C, D> Receiver<C> for CanReceiver<C, D>where C: Clock, D: ReceiveDriver<C>,

fn subscribe_message( &mut self, subject: SubjectId, payload_size_max: usize, timeout: <<C as Clock>::Instant as Instant>::Duration, driver: &mut Self::Driver ) -> Result<(), Self::Error>

Subscribes to messages on a subject

This will enable incoming transfers from all nodes on the specified subject ID.

subject: The subject ID to subscribe to

payload_size_max: The maximum number of payload bytes expected on this subject (longer transfers will be dropped)

timeout: The maximum time between the first and last frames in a transfer (transfers that do not finish within this time will be dropped)

If all transfers fit into one frame, the timeout has no meaning and may be zero.

fn unsubscribe_message(&mut self, subject: SubjectId, driver: &mut Self::Driver)

Unsubscribes from messages on a subject

fn subscribe_request( &mut self, service: ServiceId, payload_size_max: usize, timeout: <<C as Clock>::Instant as Instant>::Duration, driver: &mut Self::Driver ) -> Result<(), ServiceSubscribeError<Self::Error>>

Subscribes to requests for a service

This will enable incoming service request transfers from all nodes on the specified service ID.

service: The service ID to subscribe to

payload_size_max: The maximum number of payload bytes expected on this subject (longer transfers will be dropped)

timeout: The maximum time between the first and last frames in a transfer (transfers that do not finish within this time will be dropped)

If all transfers fit into one frame, the timeout has no meaning and may be zero.

This function returns an error if memory allocation fails or if this node is anonymous.

fn unsubscribe_request(&mut self, service: ServiceId, driver: &mut Self::Driver)

Unsubscribes from requests for a service

fn subscribe_response( &mut self, service: ServiceId, payload_size_max: usize, timeout: <<C as Clock>::Instant as Instant>::Duration, driver: &mut Self::Driver ) -> Result<(), ServiceSubscribeError<Self::Error>>

Subscribes to responses for a service

This will enable incoming service response transfers from all nodes on the specified service ID.

service: The service ID to subscribe to

payload_size_max: The maximum number of payload bytes expected on this subject (longer transfers will be dropped)

timeout: The maximum time between the first and last frames in a transfer (transfers that do not finish within this time will be dropped)

If all transfers fit into one frame, the timeout has no meaning and may be zero.

This function returns an error if memory allocation fails or if this node is anonymous.

fn unsubscribe_response( &mut self, service: ServiceId, driver: &mut Self::Driver )

Unsubscribes from responses for a service

type Transport = CanTransport

The transport that this transmitter works with

type Driver = D

The driver type that this transmitter uses to receive frames

type Error = Error<<D as ReceiveDriver<C>>::Error>

An error type

fn receive( &mut self, clock: &mut C, driver: &mut Self::Driver ) -> Result<Option<Transfer<Vec<u8>, C::Instant, Self::Transport>>, Self::Error>

Checks for incoming frames and processes them, possibly returning a transfer