Struct MeshCore 

pub struct MeshCore { /* private fields */ }

MeshCore client for communicating with MeshCore devices

Implementations

impl MeshCore

pub async fn ble_discover(scan_duration: Duration) -> Result<Vec<String>>

Find MeshCore radios on BTLE upto the time specified by scan_duration and return their names

pub async fn ble_connect(name: &str) -> Result<MeshCore>

This method connects to a MeshCore radio by BTLE device name

impl MeshCore

pub async fn serial(port: &str, baud_rate: u32) -> Result<MeshCore>

Create a MeshCore client connected via serial port

impl MeshCore

pub async fn tcp(host: &str, port: u16) -> Result<MeshCore>

Create a MeshCore client connected via TCP

impl MeshCore

pub async fn is_connected(&self) -> bool

Check if connected

pub fn commands(&self) -> &Arc<Mutex<CommandHandler>>

Get the command handler

pub async fn contacts(&self) -> HashMap<String, Contact>

Get cached contacts

pub async fn self_info(&self) -> Option<SelfInfo>

Get cached self-info

pub async fn device_time(&self) -> Option<u32>

Get cached device time

pub async fn contacts_dirty(&self) -> bool

Check if the contact cache is dirty

pub async fn get_contact_by_name(&self, name: &str) -> Option<Contact>

Get contact by name

pub async fn get_contact_by_prefix(&self, prefix: &[u8]) -> Option<Contact>

Get contact by public key prefix

pub async fn ensure_contacts(&self) -> Result<()>

Ensure contacts are loaded

pub async fn subscribe<F>( &self, event_type: EventType, filters: HashMap<String, String>, callback: F, ) -> Subscription

where F: Fn(MeshCoreEvent) + Send + Sync + 'static,

Subscribe to events

pub async fn wait_for_event( &self, event_type: Option<EventType>, filters: HashMap<String, String>, timeout: Duration, ) -> Option<MeshCoreEvent>

Wait for an event, either matching a specific EventType or all

pub async fn start_auto_message_fetching(&self)

Start auto-fetching messages when MESSAGES_WAITING is received

pub async fn stop_auto_message_fetching(&self)

Stop auto-fetching messages

pub async fn disconnect(&self) -> Result<()>

Disconnect from the device

pub async fn set_default_timeout(&self, timeout: Duration)

Set default timeout

pub fn dispatcher(&self) -> &Arc<EventDispatcher>

Get the event dispatcher

pub fn reader(&self) -> &Arc<MessageReader>

Get the message reader

pub fn event_stream(&self) -> impl Stream<Item = MeshCoreEvent> + Unpin

Create a stream of all events

Returns a stream that yields all events emitted by the device. Use StreamExt methods to filter or process events.

Example

use futures::StreamExt;

let mut stream = meshcore.event_stream();
while let Some(event) = stream.next().await {
    println!("Received: {:?}", event.event_type);
}

pub fn event_stream_filtered( &self, event_type: EventType, ) -> impl Stream<Item = MeshCoreEvent> + Unpin

Create a filtered stream of events by type

Returns a stream that yields only events matching the specified type.

Example

use futures::StreamExt;
use meshcore_rs::EventType;

let mut stream = meshcore.event_stream_filtered(EventType::ContactMsgRecv);
while let Some(event) = stream.next().await {
    println!("Message received: {:?}", event.payload);
}