Voltage Modbus

High-performance Modbus TCP/RTU library for Rust, designed for industrial automation and IoT applications.

Features

Async/await with Tokio
Modbus TCP and RTU protocols
Zero unsafe code
Generic client architecture (TCP/RTU share application logic)

Installation

cargo add voltage_modbus

For RTU (serial) support:

voltage_modbus = { version = "0.4", features = ["rtu"] }

Quick Start

TCP Client

use voltage_modbus::{ModbusTcpClient, ModbusClient, ModbusResult};
use std::time::Duration;

#[tokio::main]
async fn main() -> ModbusResult<()> {
    let mut client = ModbusTcpClient::from_address("127.0.0.1:502", Duration::from_secs(5)).await?;

    // Read holding registers
    let values = client.read_03(1, 0, 10).await?;
    println!("Registers: {:?}", values);

    // Write single register
    client.write_06(1, 100, 0x1234).await?;

    client.close().await?;
    Ok(())
}

RTU Client

use voltage_modbus::{ModbusRtuClient, ModbusClient, ModbusResult};
use std::time::Duration;

#[tokio::main]
async fn main() -> ModbusResult<()> {
    // Simple: default 8N1 configuration
    let mut client = ModbusRtuClient::new("/dev/ttyUSB0", 9600)?;

    // Or with full configuration (data bits, stop bits, parity, timeout)
    let mut client = ModbusRtuClient::with_config_and_logging(
        "/dev/ttyUSB0",
        9600,
        tokio_serial::DataBits::Eight,
        tokio_serial::StopBits::One,
        tokio_serial::Parity::Even,  // Even parity
        Duration::from_secs(1),
        None,
    )?;

    let coils = client.read_01(1, 0, 8).await?;
    println!("Coils: {:?}", coils);

    client.close().await?;
    Ok(())
}

Supported Function Codes

Code	Function	Status
0x01	Read Coils	✅
0x02	Read Discrete Inputs	✅
0x03	Read Holding Registers	✅
0x04	Read Input Registers	✅
0x05	Write Single Coil	✅
0x06	Write Single Register	✅
0x0F	Write Multiple Coils	✅
0x10	Write Multiple Registers	✅

Architecture

┌─────────────────────────────────────────────────┐
│              Application Layer                  │
│  ┌─────────────────┐    ┌─────────────────┐     │
│  │ ModbusTcpClient │    │ ModbusRtuClient │     │
│  └────────┬────────┘    └────────┬────────┘     │
│           └──────────┬───────────┘              │
│           ┌──────────┴───────────┐              │
│           │ GenericModbusClient  │              │
│           │  (Shared PDU Logic)  │              │
│           └──────────────────────┘              │
└─────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────┐
│               Transport Layer                   │
│  ┌─────────────────┐    ┌─────────────────┐     │
│  │  TcpTransport   │    │  RtuTransport   │     │
│  └─────────────────┘    └─────────────────┘     │
└─────────────────────────────────────────────────┘

TCP and RTU share identical PDU (Protocol Data Unit), differing only in transport framing.

Documentation

License

MIT License - see LICENSE for details.

voltage_modbus 0.4.9