Struct MeshRadio 

pub struct MeshRadio<R> { /* private fields */ }

A node on a LoRa mesh: a radio, the node’s address, and the rules it keeps.

Build it around a configured radio, connect to start listening, then send and receive as over any other pamoja transport.

Implementations

impl<R: LoraRadio> MeshRadio<R>

pub fn new(radio: R, node: u32, duty_cycle_permille: u32) -> MeshRadio<R>

Builds a node around a radio that is already configured.

Frames start with [Frame::DEFAULT_HOP_LIMIT] hops, and the node relays what it hears.

Arguments

• radio - the radio, tuned to the channel the mesh uses.
• node - this node’s address, which every frame it sends carries as its source.
• duty_cycle_permille - the region’s duty-cycle limit in parts per thousand, such as 10 for 1%, or 1000 where the region sets none.

Returns

The node, not yet connected.

pub fn with_hop_limit(self, hop_limit: u8) -> MeshRadio<R>

Returns the node with another hop limit for the frames it sends.

Arguments

• hop_limit - how many relays a frame may take; 0 keeps it to the nodes in range.

Returns

The node.

pub fn without_relaying(self) -> MeshRadio<R>

Returns the node with relaying off, so it only sends and receives its own traffic.

Returns

The node.

pub fn node(&self) -> u32

Returns this node’s address.

Returns

The address frames carry as their source.

pub fn is_connected(&self) -> bool

Reports whether the node is connected and listening.

Returns

true after connect.

pub fn duty_cycle(&self) -> &DutyCycle

Returns the duty-cycle guard, to see how long the radio must still stay silent.

Returns

The guard, whose clock is microseconds since the node was built.

pub fn radio(&self) -> &R

Returns the radio.

Returns

A reference to the radio.

pub fn radio_mut(&mut self) -> &mut R

Returns the radio, to reach what the transport does not cover.

Returns

A mutable reference to the radio.

pub fn release(self) -> R

Gives back the radio.

Returns

The radio.

Trait Implementations

impl<R: LoraRadio + Send> Receive for MeshRadio<R>

async fn recv(&mut self) -> Result<Option<Message>>

Awaits the next message whose topic a subscription matches.

A frame relayed on the way is sent before the message is handed up, and a message already taken off the air waits in the node if the call is dropped meanwhile, so nothing received is lost to a cancellation.

Returns

The next message; the air never ends, so never None.

Errors

Returns [Error::Closed] before connect, and [Error::Transport] if the radio fails.

impl<R: LoraRadio + Send> Transport for MeshRadio<R>

async fn connect(&mut self) -> Result<()>

Establishes the connection to the broker, peer, or bus.

async fn send(&mut self, topic: &str, payload: &[u8]) -> Result<()>

Publishes a payload to a topic.

async fn subscribe(&mut self, topic: &str) -> Result<()>

Subscribes to a topic so that matching payloads are routed to this transport.

fn send_text( &mut self, topic: &str, text: &str, ) -> impl Future<Output = Result<(), Error>> + Send

Publishes text to a topic: words, or a number written out.