fn scale(&self, target: impl Into<LockTarget>, direction: Direction, scale: u8) -> Result<()>

Fire-and-forget

A delta picks up one fixed-direction scale and one relative one, multiplied, so a block in either zeroes the product. With and Against need a live bearing; see set_bearing. A momentary usage carries one bit, so any scale under 100 locks it.

use medius::{Device, Axis, Direction};

let device = Device::find()?;
device.scale(Axis::X, Direction::Against, 40)?;  // 40% of movement opposing the injection
device.scale(Axis::X, Direction::With, 130)?;    // 130% of movement along it
device.scale(Axis::Y, Direction::Negative, 60)?; // 60% of upward movement, always

fn lock(&self, target: impl Into<LockTarget>, direction: Direction) -> Result<()>

Fire-and-forget

scale at LOCK_SCALE_BLOCK. LockTarget picks the input and Direction picks the sign or edge, also spelled Direction::PRESS and Direction::RELEASE.

A lock holds until you unlock it. The box also clears every lock on control-PC silence, on reset, on inter-chip link loss, and when the real device detaches. See the native LOCK command for the wire layout.

use medius::{Device, Axis, Button, Key, MediaKey, Direction};

let device = Device::find()?;
device.lock(Axis::X, Direction::Both)?;           // freeze horizontal motion
device.lock(Button::Left, Direction::Positive)?;  // block left-click press
device.lock(Key::LEFT_GUI, Direction::Both)?;     // block the GUI/Windows key
device.lock(MediaKey::PLAY_PAUSE, Direction::Both)?; // media has no edges
device.move_rel(50, 0)?;                          // injection still moves X

fn unlock(&self, target: impl Into<LockTarget>, direction: Direction) -> Result<()>

Fire-and-forget

scale at LOCK_SCALE_PASS: the same target and direction, back to passing untouched. Direction::Both clears every direction of the target, the bearing-relative pair included, so an unlock never leaves the relative pair still weighing.

use medius::{Device, Axis, Direction};

let device = Device::find()?;
device.unlock(Axis::X, Direction::Both)?;   // X passes untouched again

fn lock_axis(&self, axis: Axis, direction: Direction) -> Result<()>

fn unlock_axis(&self, axis: Axis, direction: Direction) -> Result<()>

fn scale_axis(&self, axis: Axis, direction: Direction, scale: u8) -> Result<()>

Fire-and-forget

Convenience for lock / unlock / scale with an Axis, where the direction is a sign.

use medius::{Device, Axis, Direction};

let device = Device::find()?;
device.lock_axis(Axis::Wheel, Direction::Positive)?; // block scroll up, keep scroll down
device.unlock_axis(Axis::Wheel, Direction::Positive)?;

fn lock_all(&self, what: Blanket, direction: Direction) -> Result<()>

fn unlock_all(&self, what: Blanket, direction: Direction) -> Result<()>

fn scale_all(&self, what: Blanket, direction: Direction, scale: u8) -> Result<()>

Fire-and-forget

Weigh an entire input group at once with a Blanket (Aim, Wheel, Buttons, Keys, or Media). direction reaches every member the same way it reaches one, so Keys takes an edge and Media, having none, sends Both.

Blanket::Aim is how you address X and Y together in BearingMode::Vector, where the box reads X and Y as one thing.

use medius::{Device, Blanket, Direction};

let device = Device::find()?;
device.lock_all(Blanket::Keys, Direction::Both)?;        // every key, both edges
device.lock_all(Blanket::Keys, Direction::Positive)?;    // press edges only: a held key still releases
device.unlock_all(Blanket::Keys, Direction::Both)?;
device.scale_all(Blanket::Aim, Direction::Against, 40)?; // 40% of motion opposing the injection, X and Y

AsyncDevice keeps every lock call synchronous (scale, lock/unlock, scale_axis, and scale_all with their lock and unlock pairs) since they expect no reply; query_locks is a future like the other queries.

use futures::executor::block_on;
use medius::{AsyncDevice, Axis, Direction};

let device = AsyncDevice::open("/dev/ttyACM0")?;
device.lock(Axis::Y, Direction::Both)?;       // sync, no await
let locks = block_on(device.query_locks())?;  // query awaits