Struct canadensis::node::CoreNode

pub struct CoreNode<C, T, U, TR, D, const P: usize, const R: usize>where
    C: Clock,
    U: Receiver<C>,
    T: Transmitter<C>,{ /* private fields */ }

Basic Cyphal node functionality

Type parameters:

• C: The clock used to get the current time
• T: The transmitter used to send transfers
• U: The receiver used to receive transfers
• TR: The transfer ID tracker used to manage transfer IDs for outgoing transfers
• D: The driver used to send and receive frames
• P: The maximum number of topics that can be published This must be greater than 0, or the code will fail to compile. It also must be a power of two, or the software may behave incorrectly.
• R: The maximum number of services for which requests can be sent This must be greater than 0, or the code will fail to compile. It also must be a power of two, or the software may behave incorrectly.

Implementations

impl<C, T, U, N, TR, D, const P: usize, const R: usize> CoreNode<C, T, U, TR, D, P, R>where C: Clock, N: Transport, U: Receiver<C, Transport = N, Driver = D>, T: Transmitter<C, Transport = N, Driver = D>, TR: TransferIdTracker<N>,

pub fn new( clock: C, node_id: <T::Transport as Transport>::NodeId, transmitter: T, receiver: U, driver: D ) -> Self

Creates a node

• clock: A clock to use for frame deadlines and timeouts
• node_id: The ID of this node
• transmitter: A transport transmitter
• receiver: A transport receiver
• driver: A driver compatible with receiver and transmitter

pub fn driver(&self) -> &D

Returns a reference to the enclosed driver

pub fn driver_mut(&mut self) -> &mut D

Returns a mutable reference to the enclosed driver

Trait Implementations

impl<C, T, U, TR: Debug, D: Debug, const P: usize, const R: usize> Debug for CoreNode<C, T, U, TR, D, P, R>where C: Clock + Debug, U: Receiver<C> + Debug, T: Transmitter<C> + Debug, T::Transport: Debug,

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

Formats the value using the given formatter.

impl<C, T, U, N, TR, D, const P: usize, const R: usize> Node for CoreNode<C, T, U, TR, D, P, R>where C: Clock, N: Transport, T: Transmitter<C, Transport = N, Driver = D>, U: Receiver<C, Transport = N, Driver = D>, TR: TransferIdTracker<N>,

fn start_sending_requests<M>( &mut self, service: ServiceId, receive_timeout: <C::Instant as Instant>::Duration, response_payload_size_max: usize, priority: N::Priority ) -> Result<ServiceToken<M>, StartSendError<U::Error>>where M: Request,

Sets up to send requests for a service

This also subscribes to the corresponding responses.

fn clock(&self) -> &C

Returns a reference to the enclosed clock

fn clock_mut(&mut self) -> &mut C

Returns a mutable reference to the enclosed clock

fn node_id(&self) -> <Self::Transport as Transport>::NodeId

Returns the identifier of this node

type Clock = C

The clock that this node uses

type Instant = <C as Clock>::Instant

The instant that this node’s clock produces

type Transport = N

The transport that this node uses

type Transmitter = T

The transmitter that this node uses

type Receiver = U

The receiver that this node uses

fn receive<H>(&mut self, handler: &mut H) -> Result<(), U::Error>where H: TransferHandler<Self::Instant, Self::Transport>,

Receives any available incoming frames and attempts ot reassemble them into a transfer

fn start_publishing<M>( &mut self, subject: SubjectId, timeout: <C::Instant as Instant>::Duration, priority: N::Priority ) -> Result<PublishToken<M>, StartSendError<T::Error>>where M: Message,

Starts publishing messages on subject

fn stop_publishing<M>(&mut self, token: PublishToken<M>)where M: Message,

Stops publishing messages on a subject

fn publish<M>( &mut self, token: &PublishToken<M>, payload: &M ) -> Result<(), T::Error>where M: Message + Serialize,

Publishes a message

fn publish_loopback<M>( &mut self, token: &PublishToken<M>, payload: &M ) -> Result<(), T::Error>where M: Message + Serialize,

Publishes a message with the loopback flag set to true

fn stop_sending_requests<M>(&mut self, token: ServiceToken<M>)where M: Request,

Stops sending requests for a service

fn send_request<M>( &mut self, token: &ServiceToken<M>, payload: &M, destination: N::NodeId ) -> Result<N::TransferId, T::Error>where M: Request + Serialize,

Sends a service request to another node

fn send_request_loopback<M>( &mut self, token: &ServiceToken<M>, payload: &M, destination: <Self::Transport as Transport>::NodeId ) -> Result<<Self::Transport as Transport>::TransferId, <Self::Transmitter as Transmitter<Self::Clock>>::Error>where M: Request + Serialize,

Sends a service request to another node, with the loopback flag set to true

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

Subscribes to messages on a topic

fn subscribe_request( &mut self, service: ServiceId, payload_size_max: usize, timeout: <C::Instant as Instant>::Duration ) -> Result<(), U::Error>

Subscribes to requests for a service

fn send_response<M>( &mut self, token: ResponseToken<Self::Transport>, timeout: <C::Instant as Instant>::Duration, payload: &M ) -> Result<(), T::Error>where M: Response + Serialize,

Responds to a service request

fn flush(&mut self) -> Result<(), T::Error>

Attempts to flush all outgoing frames

fn transmitter(&self) -> &Self::Transmitter

Returns a reference to the transport transmitter

fn transmitter_mut(&mut self) -> &mut Self::Transmitter

Returns a mutable reference to the transport transmitter

fn receiver(&self) -> &Self::Receiver

Returns a reference to the transport receiver

fn receiver_mut(&mut self) -> &mut Self::Receiver

Returns a mutable reference to the transport receiver