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::Instant>>::Error>, <N::Receiver as Receiver<N::Instant>>::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::Instant>>::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::Clock

The clock that this node uses

type Instant = N::Instant

The instant that this node’s clock produces

type Transport = N::Transport

The transport that this node uses

type Transmitter = N::Transmitter

The transmitter that this node uses

type Receiver = N::Receiver

The receiver that this node uses

fn receive<H>(
    &mut self,
    handler: &mut H
) -> Result<(), <N::Receiver as Receiver<N::Instant>>::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::Instant>>::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::Instant>>::Error> where
    T: Message + Serialize, 

Publishes a message

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::Instant>>::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::Instant>>::Error> where
    T: Request + Serialize, 

Sends a service request to another node

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::Instant>>::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::Instant>>::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::Instant>>::Error> where
    T: Response + Serialize, 

Responds to a service request

fn flush(
    &mut self
) -> Result<(), <N::Transmitter as Transmitter<N::Instant>>::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