Struct canadensis::node::BasicNode

pub struct BasicNode<N>where
    N: Node,{ /* private fields */ }

A node that provides all basic application-layer functionality

This node performs the following functions:

• Sending a uavcan.node.Heartbeat every second
• Responding to uavcan.node.GetInfo requests
• Sending a uavcan.node.port.List message every 10 seconds

A BasicNode uses up two publisher slots in the underlying node.

The underlying node type N is usually a CoreNode.

Implementations

impl<N> BasicNode<N>where N: Node,

pub fn new( node: N, node_info: GetInfoResponse ) -> Result<Self, NodeError<StartSendError<<N::Transmitter as Transmitter<N::Clock>>::Error>, <N::Receiver as Receiver<N::Clock>>::Error>>

Creates a new basic node

• node: The underlying node (this is usually a CoreNode)
• node_info: The information that should be returned when handling node information requests

pub fn run_per_second_tasks( &mut self ) -> Result<(), <N::Transmitter as Transmitter<N::Clock>>::Error>

This function must be called once per second to send heartbeat and port list messages

pub fn set_mode(&mut self, mode: Mode)

Sets the operating mode that will be reported in the heartbeat messages

pub fn set_health(&mut self, health: Health)

Sets the health status that will be reported in the heartbeat messages

pub fn set_status_code(&mut self, status: u8)

Sets the vendor-specific status code that will be reported in the heartbeat messages

pub fn node(&self) -> &N

Returns a reference to the enclosed node

pub fn node_mut(&mut self) -> &mut N

Returns a mutable reference to the enclosed node

Trait Implementations

impl<N> Node for BasicNode<N>where N: Node,

type Clock = <N as Node>::Clock

The clock that this node uses

type Instant = <N as Node>::Instant

The instant that this node’s clock produces

type Transport = <N as Node>::Transport

The transport that this node uses

type Transmitter = <N as Node>::Transmitter

The transmitter that this node uses

type Receiver = <N as Node>::Receiver

The receiver that this node uses

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

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

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

Starts publishing messages on subject

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

Stops publishing messages on a subject

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

Publishes a message

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

Publishes a message with the loopback flag set to true

fn start_sending_requests<T>( &mut self, service: ServiceId, receive_timeout: <<N::Clock as Clock>::Instant as Instant>::Duration, response_payload_size_max: usize, priority: <Self::Transport as Transport>::Priority ) -> Result<ServiceToken<T>, StartSendError<<N::Receiver as Receiver<N::Clock>>::Error>>where T: Request,

Sets up to send requests for a service

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

Stops sending requests for a service

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

Sends a service request to another node

fn send_request_loopback<T>( &mut self, token: &ServiceToken<T>, payload: &T, destination: <Self::Transport as Transport>::NodeId ) -> Result<<Self::Transport as Transport>::TransferId, <Self::Transmitter as Transmitter<Self::Clock>>::Error>where T: 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: <<N::Clock as Clock>::Instant as Instant>::Duration ) -> Result<(), <N::Receiver as Receiver<N::Clock>>::Error>

Subscribes to messages on a topic

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

Subscribes to requests for a service

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

Responds to a service request

fn flush( &mut self ) -> Result<(), <N::Transmitter as Transmitter<N::Clock>>::Error>

Attempts to flush all outgoing frames

fn clock(&self) -> &Self::Clock

Returns a reference to the enclosed clock

fn clock_mut(&mut self) -> &mut Self::Clock

Returns a mutable reference to the enclosed clock

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

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

Returns the identifier of this node