Crate tokio_modbus
source ·Expand description
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
A async modbus client implementation.
A multithreaded Modbus server.
A sync modbus client implementation.
Enums
A request represents a message from the client (master) to the server (slave).
The data of a successfull request.
Traits
A transport independent asynchronous client trait.
A transport independent synchronous client trait.