Struct canadensis::node::CoreNode

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

Basic UAVCAN 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::Instant, Transport = N, Driver = D>,
    T: Transmitter<C::Instant, 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: Debug, T: Debug, U: Debug, TR: Debug, D: Debug, const P: usize, const R: usize> Debug for CoreNode<C, T, U, TR, D, P, R> where
    C: Clock,
    U: Receiver<C::Instant>,
    T: Transmitter<C::Instant>,
    T::Transport: Debug,
    C::Instant: Debug,
    C::Instant: 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 as Clock>::Instant, Transport = N, Driver = D>,
    U: Receiver<<C as Clock>::Instant, 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 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 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