Medius - Rust LibraryConnection

Connecting

Open, find, and release the port

The medius crate is the Rust client and Device is the handle. Opening one finds the box, runs the handshake, and starts the background threads in one call.

See also: choosing a port, threading, keepalive & teardown, and the box handshake.

Open a device

Auto-detect, or a path you already have
fn Device::open(path: impl AsRef<Path>) -> Result<Device>

Blocks

fn Device::find() -> Result<Device>

Blocks

fn find_medius() -> Vec<PortInfo>

No round-trip

open and find block on the handshake. Auto-detect matches on USB identity (vid 0x1A86, pid 0x55D3), the WCH CH343 bridge in every box.

FUNCTIONS
FunctionDescription
openOpens a serial path you already have (Linux /dev/ttyACM0, Windows COM3).
findOpens the first matching port, or returns Error::NotFound.
find_mediusLists every match as a PortInfo without opening one.
EXAMPLE
use medius::Device;

// auto-detect the box:
let dev = Device::find()?;

// or, open a path you already know:
let dev = Device::open("/dev/ttyACM0")?;

Zero config

No settings struct, just three read-only values

Nothing to configure. Two read-only defaults bound the QUERY wait and the keepalive timer.

ConstantValue
DEFAULT_QUERY_TIMEOUT1 s
DEFAULT_KEEPALIVE_CADENCE500 ms
PROTO_VER5

PROTO_VER is the control protocol version this build speaks. A box reporting anything else is refused at the handshake.

EXAMPLE
use medius::{DEFAULT_QUERY_TIMEOUT, DEFAULT_KEEPALIVE_CADENCE, PROTO_VER};

println!("query timeout:     {:?}", DEFAULT_QUERY_TIMEOUT);   // 1s
println!("keepalive cadence: {:?}", DEFAULT_KEEPALIVE_CADENCE); // 500ms
println!("speaks protocol:   {}", PROTO_VER);                   // 5

Async device

The same link, with awaitable queries
fn AsyncDevice::open(path: impl AsRef<Path>) -> Result<AsyncDevice>

Blocks

fn AsyncDevice::find() -> Result<AsyncDevice>

Blocks

fn into_async(self) -> AsyncDevice

No round-trip

fn into_inner(self) -> Device

No round-trip

Behind the async feature, AsyncDevice turns the reply-reading queries into futures; the fire-and-forget calls stay synchronous. Construct one with AsyncDevice::find, open by path, or into_async.

cargo add medius --features async
EXAMPLE
use futures::executor::block_on;
use medius::AsyncDevice;

// discover and open directly as async:
let dev = AsyncDevice::find()?;
let version = block_on(dev.query_version())?; // awaits the reply
dev.move_rel(10, 0)?;                          // fire-and-forget, stays sync

// or open a path you already have:
let dev = AsyncDevice::open("/dev/ttyACM0")?;