async_labjack

async_labjack is a pure rust async library to communicate with LabJack T-series devices. It is completely standalone and does not require LJM.

It differentiates itself from LJM and other available labjack crates in the rust ecosystem in the following ways:

• Pure rust. This is not an FFI binding to LJM. Instead it uses the direct modbus TCP interface of the LabJack.

• Does not require LJM installed on your system. As long as you can establish a tcp connection to your LabJack, you can use this library to work with your LabJack.

• Asynchronous.

• Strongly-typed. All registers (tags) that are available on the LabJack have types and read/write specifications in this library. The rust compiler will prevent issues where, for example, you may be attempting to read a write-only register or get a floating point value from a u32 register. This will prevent issues at compile time, rather than waiting to get back errors from the LabJack response at runtime.

• All labjack registers and error codes are defined as constants in this library. See all_tags and errors. When a labjack error occurs, all functions in this library will attempt to return the descriptive error from the LAST_ERR_DETAIL register, which you can match on via the LabjackErrorCode enum.

• TCP-only. This library does not support USB connections to the LabJack.

Example

Many complete examples, including for streaming, can be found in the examples directory.

use async_labjack::client::LabjackClient;
use async_labjack::{TEST, TEST_FLOAT32, TEST_INT32};

// Change to the address of your labjack
let socket_addr = "192.168.42.100:502".parse().unwrap();

let client = &mut LabjackClient::connect_with_timeout(socket_addr, Duration::from_millis(3000))
    .await
    .unwrap();

// Read a single LabJack tag.
// Ensure the test value is always 0x00112233
let value = TEST.read(client).await.unwrap();
assert_eq!(value, 0x00112233);

// Read and write multiple tags at once.
// This is done in a single modbus function call, and writes occur before reads,
// so you can write to tags and immediately get back the newly written values.
let results = client
  .read_write_tags(
      // The tags to read
      &[
          TEST_FLOAT32.into(),
          TEST_INT32.into(),
      ],
      // The tags to write to
      &[
          TEST_FLOAT32.into(),
          TEST_INT32.into(),
      ],
      // The values to write to the tags
      &[
          HydratedTagValue::F32(-98765.43),
          HydratedTagValue::I32(-987654),
      ],
  )
  .await
  .unwrap();

let float32_val: f32 = (&results[0]).try_into().unwrap();
assert_eq!(float32_val, -98765.43);

let int32_val: i32 = (&results[1]).try_into().unwrap();
assert_eq!(int32_val, -987654);

client.disconnect().await.unwrap();

Dev Pre-requisites

To use the faster linker specified in .cargo/config.toml, install lld:

Windows

cargo install -f cargo-binutils
rustup component add llvm-tools-preview

Linux

# Ubuntu
sudo apt-get install lld clang
# Arch
sudo pacman -S lld clang

MacOS

brew install llvm

Installation

Cargo

• Install the rust toolchain in order to have cargo installed by following this guide.
• run cargo install async_labjack

License

Licensed under

• MIT license (LICENSE or http://opensource.org/licenses/MIT)

Contribution

See CONTRIBUTING.md.

Alternative Crates

• ljmrs: A rust crate with FFI bindings to LJM, with an API that matches closely with the original LJM API.

• ljm: A rust crate with FFI bindings to LJM, with a goal of being more idiomatic to Rust and ergonomic for users when compared to ljmrs.