tokio-modbus

A tokio-based modbus library.

Features

pure Rust library
async (non-blocking)
sync (blocking)
Modbus TCP
Modbus RTU
Client & Server
Open Source (MIT/Apache-2.0)

Installation

Add this to your Cargo.toml:

toml [dependencies] tokio-modbus = "*"

If you like to use Modbus TCP only:

toml [dependencies] tokio-modbus = { version = "*", default-features = false, features = ["tcp"] }

If you like to use Modbus RTU only:

toml [dependencies] tokio-modbus = { version = "*", default-features = false, features = ["rtu"] }

Examples

TCP client

```rust extern crate futures; extern crate tokiocore; extern crate tokiomodbus;

use tokiocore::reactor::Core; use futures::future::Future; use tokiomodbus::{Client, TcpClient};

pub fn main() { let mut core = Core::new().unwrap(); let handle = core.handle(); let addr = "192.168.0.222:502".parse().unwrap();

let task = TcpClient::connect(&addr, &handle).and_then(|client| {
    client
        .read_input_registers(0x1000, 7)
        .and_then(move |data| {
            println!("Response is '{:?}'", data);
            Ok(())
        })
});
core.run(task).unwrap();

} ```

Sync TCP client

```rust extern crate tokiomodbus; use tokiomodbus::*;

pub fn main() { let addr = "192.168.0.222:502".parse().unwrap(); let client = SyncClient::connecttcp(&addr).unwrap(); let buff = client.readinput_registers(0x1000, 7).unwrap(); println!("Response is '{:?}'", buff); } ```

RTU client

```rust extern crate futures; extern crate tokiocore; extern crate tokiomodbus; extern crate tokio_serial;

use tokiocore::reactor::Core; use futures::future::Future; use tokioserial::{BaudRate, Serial, SerialPortSettings}; use tokio_modbus::*;

pub fn main() { let mut core = Core::new().unwrap(); let handle = core.handle(); let ttypath = "/dev/ttyUSB0"; let serveraddr = 0x01;

let mut settings = SerialPortSettings::default();
settings.baud_rate = BaudRate::Baud19200;
let mut port = Serial::from_path(tty_path, &settings, &handle).unwrap();
port.set_exclusive(false).unwrap();

let task = Client::connect_rtu(port, server_addr, &handle).and_then(|client| {
    println!("Reading a sensor value");
    client
        .read_holding_registers(0x082B, 2)
        .and_then(move |res| {
            println!("Sensor value is: {:?}", res);
            Ok(())
        })
});

core.run(task).unwrap();

} ```

More examples can be found in the examples folder.

Protocol-Specification

License

MIT/Apache-2.0