Struct DeviceDiscovery 

pub struct DeviceDiscovery { /* private fields */ }

Discovers Enpose tracker devices on the local network.

On every call to Self::discover the API sends discovery requests to every directed-broadcast address of every up, non-loopback IPv4 interface on the host (e.g. 192.168.10.255 on a host with enp1s0 192.168.10.10/24), plus the limited-broadcast address 255.255.255.255. This reaches the cluster network on multi-NIC hosts where the kernel’s default route would otherwise send the limited broadcast out the wrong interface (typically the wifi default route, leaving the cluster ethernet unreachable).

A single instance can be reused for many discovery rounds; the API holds no persistent network state between calls.

Implementations

impl DeviceDiscovery

pub fn new() -> Self

Create a new DeviceDiscovery that, on each Self::discover call, broadcasts to every directed-broadcast on the host plus 255.255.255.255 — all on BROADCAST_PORT.

Examples found in repository

example/example.rs (line 21)

fn main() -> std::io::Result<()> {
    let devices = DeviceDiscovery::new().discover()?;

    if devices.is_empty() {
        println!("No Enpose devices found on the local network.");
        return Ok(());
    }

    println!("Found {} device(s):", devices.len());
    for device in &devices {
        let status = if device.compatible {
            "compatible"
        } else {
            "INCOMPATIBLE (protocol version mismatch)"
        };
        println!("  - {} (serial {}): {}", device.ip, device.serial, status);
    }

    // Pick the first compatible device to stream from.
    let Some(device) = devices.iter().find(|d| d.compatible) else {
        println!("No compatible device to stream poses from.");
        return Ok(());
    };

    println!("\nStreaming poses from {} for {:?}...", device.ip, STREAM_DURATION);

    // Threaded mode: a background thread receives and buffers poses, so none
    // are missed regardless of how often we poll below.
    let mut stream = PoseStream::from_device(device, true)?;

    let start = Instant::now();
    while start.elapsed() < STREAM_DURATION {
        // Blocking receive: waits up to 3 s for a pose update, so no manual
        // polling delay is needed.
        for pose in stream.receive_pose_updates(true)? {
            println!(
                "  t={:>10}us marker {:>3}: pos=({:+.4}, {:+.4}, {:+.4}) rmse={:.4} sensors={}",
                pose.timestamp,
                pose.marker_id,
                pose.x,
                pose.y,
                pose.z,
                pose.position_rmse,
                pose.sensors,
            );
        }
    }

    // `stream` is dropped here, which disconnects from the device.
    Ok(())
}

pub fn discover(&self) -> Result<Vec<DeviceInfo>>

Broadcast discovery requests and collect replies.

Sends the discovery request to BROADCAST_PORT up to three times, 150 ms apart, and listens on the same socket for PKT_TYPE_PEER_INFO replies. Resending guards against a dropped request or reply on a lossy segment. Only the elected primary of a cluster replies, so a cluster contributes one entry; multiple clusters on the same L2 segment each contribute one. Replies are de-duplicated by serial.

Timing: returns 50 ms after the last reply (whichever cluster replies last), or — if nothing replies — only at the hard 500 ms cap, having retransmitted the request in the meantime.

Errors

Returns an io::Error only for unrecoverable socket failures (bind, send, or unexpected recv errors). A normal “no devices found” outcome returns Ok(vec![]).

Examples found in repository

example/example.rs (line 21)

fn main() -> std::io::Result<()> {
    let devices = DeviceDiscovery::new().discover()?;

    if devices.is_empty() {
        println!("No Enpose devices found on the local network.");
        return Ok(());
    }

    println!("Found {} device(s):", devices.len());
    for device in &devices {
        let status = if device.compatible {
            "compatible"
        } else {
            "INCOMPATIBLE (protocol version mismatch)"
        };
        println!("  - {} (serial {}): {}", device.ip, device.serial, status);
    }

    // Pick the first compatible device to stream from.
    let Some(device) = devices.iter().find(|d| d.compatible) else {
        println!("No compatible device to stream poses from.");
        return Ok(());
    };

    println!("\nStreaming poses from {} for {:?}...", device.ip, STREAM_DURATION);

    // Threaded mode: a background thread receives and buffers poses, so none
    // are missed regardless of how often we poll below.
    let mut stream = PoseStream::from_device(device, true)?;

    let start = Instant::now();
    while start.elapsed() < STREAM_DURATION {
        // Blocking receive: waits up to 3 s for a pose update, so no manual
        // polling delay is needed.
        for pose in stream.receive_pose_updates(true)? {
            println!(
                "  t={:>10}us marker {:>3}: pos=({:+.4}, {:+.4}, {:+.4}) rmse={:.4} sensors={}",
                pose.timestamp,
                pose.marker_id,
                pose.x,
                pose.y,
                pose.z,
                pose.position_rmse,
                pose.sensors,
            );
        }
    }

    // `stream` is dropped here, which disconnects from the device.
    Ok(())
}

Trait Implementations

impl Default for DeviceDiscovery

fn default() -> Self

Returns the “default value” for a type.