Crate voltage_modbus

Voltage Modbus - High-Performance Modbus TCP/RTU/ASCII Library

Author: Evan Liu evan.liu@voltageenergy.com
Version: 0.2.0
License: MIT

A comprehensive, high-performance Modbus TCP/RTU/ASCII implementation in pure Rust designed for industrial automation, IoT applications, and smart grid systems.

Features

• 🚀 High Performance: Async/await support with Tokio for maximum throughput
• 🔧 Complete Protocol Support: Modbus TCP, RTU, and ASCII protocols
• 🛡️ Memory Safe: Pure Rust implementation with zero unsafe code
• ⚡ Zero-Copy Operations: Optimized for minimal memory allocations
• 🔄 Concurrent Processing: Multi-client server support
• 📊 Built-in Monitoring: Comprehensive statistics and metrics
• 🏭 Production Ready: Extensive testing and error handling

Supported Function Codes

Code	Function	Client	Server
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	✅	✅

Quick Start

Client Example

use voltage_modbus::{ModbusTcpClient, ModbusClient, ModbusResult};
use std::time::Duration;
 
#[tokio::main]
async fn main() -> ModbusResult<()> {
    // Connect to Modbus TCP server
    let mut client = ModbusTcpClient::with_timeout("127.0.0.1:502", Duration::from_secs(5)).await?;
     
    // Read holding registers
    let values = client.read_holding_registers(1, 0, 10).await?;
    println!("Read registers: {:?}", values);
     
    // Write single register
    client.write_single_register(1, 100, 0x1234).await?;
     
    client.close().await?;
    Ok(())
}

Server Example

use voltage_modbus::{ModbusTcpServer, ModbusTcpServerConfig, ModbusServer, ModbusRegisterBank};
use std::sync::Arc;
use std::time::Duration;
 
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create server configuration
    let config = ModbusTcpServerConfig {
        bind_address: "127.0.0.1:502".parse().unwrap(),
        max_connections: 50,
        request_timeout: Duration::from_secs(30),
        register_bank: Some(Arc::new(ModbusRegisterBank::new())),
    };
     
    // Start server
    let mut server = ModbusTcpServer::with_config(config)?;
    server.start().await?;
     
    // Server is now running...
    Ok(())
}

Architecture

┌─────────────────┐    ┌─────────────────┐
│   Application   │    │   Application   │
└─────────────────┘    └─────────────────┘
         │                       │
┌─────────────────┐    ┌─────────────────┐
│  Modbus Client  │    │  Modbus Server  │
└─────────────────┘    └─────────────────┘
         │                       │
┌─────────────────┐    ┌─────────────────┐
│   Protocol      │    │ Register Bank   │
│   (TCP/RTU)     │    │   (Storage)     │
└─────────────────┘    └─────────────────┘
         │                       │
┌─────────────────┐    ┌─────────────────┐
│   Transport     │◄──►│   Transport     │
│   (Async I/O)   │    │   (Async I/O)   │
└─────────────────┘    └─────────────────┘

Re-exports

pub use error::ModbusError;

pub use error::ModbusResult;

pub use protocol::ModbusRequest;

pub use protocol::ModbusResponse;

pub use protocol::ModbusFunction;

pub use transport::ModbusTransport;

pub use transport::TcpTransport;

pub use transport::RtuTransport;

pub use transport::AsciiTransport;

pub use transport::TransportStats;

pub use client::ModbusClient;

pub use client::ModbusTcpClient;

pub use server::ModbusServer;

pub use server::ModbusTcpServer;

pub use server::ModbusTcpServerConfig;

pub use server::ServerStats;

pub use register_bank::ModbusRegisterBank;

pub use register_bank::RegisterBankStats;

pub use utils::PerformanceMetrics;

pub use utils::OperationTimer;

Modules

client

Modbus client implementations

error

Core error types and result handling

protocol

Modbus protocol definitions and message handling

register_bank

Thread-safe register storage for server applications

server

Modbus server implementations

transport

Network transport layer for TCP and RTU communication

utils

Utility functions and performance monitoring

Constants

DEFAULT_TCP_PORT

Modbus TCP default port

DEFAULT_TIMEOUT_MS

Default timeout for operations (5 seconds)

MAX_COILS_PER_REQUEST

Maximum number of coils that can be read/written in a single request

MAX_REGISTERS_PER_REQUEST

Maximum number of registers that can be read/written in a single request

MAX_RTU_FRAME_SIZE

Maximum Modbus RTU frame size

MAX_TCP_FRAME_SIZE

Maximum Modbus TCP frame size (MBAP header + PDU)

VERSION

Library version

Functions

info

Get library information