Struct PoseStream 

pub struct PoseStream { /* private fields */ }

A live pose stream from one Enpose tracker device.

Dropping a PoseStream automatically disconnects it (see PoseStream::disconnect).

Implementations

impl PoseStream

pub fn from_ip(ip: IpAddr, create_thread: bool) -> Result<Self>

Connect a pose stream to the device at ip.

ip must be IPv4 — the Enpose API is IPv4-only. An IPv6 address is rejected with io::ErrorKind::Unsupported.

When create_thread is true, spawns the background receiver thread described in the module docs.

Errors

Returns an io::Error if ip is not IPv4, or if the connection to the device cannot be established.

pub fn from_device(device: &DeviceInfo, create_thread: bool) -> Result<Self>

Connect a pose stream to a device discovered via crate::DeviceDiscovery.

Convenience wrapper around Self::from_ip using DeviceInfo::ip.

Examples found in repository

example/example.rs (line 48)

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 receive_pose_updates(&mut self, block: bool) -> Result<Vec<MarkerPose>>

Return the marker poses received from the stream.

When block is false, returns all poses that have arrived since the previous call, or an empty vector if none have — it never waits. When block is true, it waits for a pose update and returns the poses gathered so far; the wait is bounded by a 3-second timeout, so a blocking call still returns an empty vector if no update arrives within that window.

Call it repeatedly to keep receiving updates. In threaded mode the poses are those gathered by the background thread.

Errors

Returns an io::Error only for an unrecoverable communication failure. In threaded mode this never returns an error.

Examples found in repository

example/example.rs (line 54)

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 disconnect(&mut self)

Disconnect the stream, closing the connection to the device.

Idempotent, and called automatically when the PoseStream is dropped, so you only need to call it explicitly to disconnect early.

Trait Implementations

impl Drop for PoseStream

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.