Crate tokio_modbus [−] [src]

A pure Rust Modbus library based on tokio.

Modbus is based on a master/slave model. To avoid confusions with the tokio terminology the master is called client and the slave is called server in this 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:

[dependencies]
tokio-modbus = "*"

If you like to use Modbus TCP only:

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

If you like to use Modbus RTU only:

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

Examples

TCP client

extern crate futures;
extern crate tokio_core;
extern crate tokio_modbus;

use tokio_core::reactor::Core;
use futures::future::Future;
use tokio_modbus::*;

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

    let task = Client::connect_tcp(&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

extern crate tokio_modbus;
use tokio_modbus::*;

pub fn main() {
    let addr = "192.168.0.222:502".parse().unwrap();
    let mut client = SyncClient::connect_tcp(&addr).unwrap();
    let data = client.read_input_registers(0x1000, 7).unwrap();
    println!("Response is '{:?}'", data);
}

RTU client

extern crate futures;
extern crate tokio_core;
extern crate tokio_modbus;
extern crate tokio_serial;

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

pub fn main() {
    let mut core = Core::new().unwrap();
    let handle = core.handle();
    let tty_path = "/dev/ttyUSB0";
    let server_addr = 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

Structs

Client	A async modbus client implementation.
Server	A multithreaded Modbus server.
SyncClient	A sync modbus client implementation.

Enums

Request	A request represents a message from the client (master) to the server (slave).
Response	The data of a successfull request.

Traits

ModbusClient	A transport independent asynchronous client trait.
SyncModbusClient	A transport independent synchronous client trait.