Crate mabi_modbus 

trap-sim-modbus

Modbus TCP/RTU simulator for the TRAP protocol simulator.

This crate provides:

• Modbus TCP server implementation
• Modbus RTU simulation (serial)
• Register storage (coils, discrete inputs, holding registers, input registers)
• Multiple device simulation
• Extensible handler architecture
• Connection pooling and metrics

Architecture

TCP Server Architecture

┌─────────────────────────────────────────────────────────────┐
│                    ModbusTcpServerV2                         │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────────┐  │
│  │ TcpListener  │──│ConnectionPool│──│  HandlerRegistry │  │
│  └──────────────┘  └──────────────┘  └──────────────────┘  │
│                                              │               │
│                        ┌─────────────────────┴───────────┐  │
│                        │     FunctionHandler Trait       │  │
│                        │  FC01  FC02  FC03  ...  Custom  │  │
│                        └─────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

RTU Server Architecture

┌─────────────────────────────────────────────────────────────┐
│                     ModbusRtuServer                          │
│  ┌──────────────────┐  ┌────────────────┐                   │
│  │ TransportManager │──│ HandlerRegistry│                   │
│  └────────┬─────────┘  └────────────────┘                   │
│           │                                                  │
│  ┌────────┴─────────────────────────────────┐               │
│  │           Transport Trait                 │               │
│  │  VirtualSerial  │  TcpBridge  │  Channel │               │
│  └──────────────────────────────────────────┘               │
│                           │                                  │
│           ┌───────────────┴───────────────────┐             │
│           │          RtuCodec                  │             │
│           │  Frame Detection │ CRC Validation │             │
│           └────────────────────────────────────┘             │
└─────────────────────────────────────────────────────────────┘

TCP Server Example

use mabi_modbus::{ModbusTcpServerV2, tcp::ServerConfigV2};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ServerConfigV2::default();
    let server = ModbusTcpServerV2::new(config);
    server.run().await?;
    Ok(())
}

RTU Server Example

use mabi_modbus::rtu::{ModbusRtuServer, RtuServerConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = RtuServerConfig::default()
        .with_unit_ids(vec![1, 2, 3])
        .with_broadcast(true);

    let server = ModbusRtuServer::new(config);
    server.run().await?;
    Ok(())
}

Custom Handlers

You can implement custom function handlers by implementing the FunctionHandler trait:

use mabi_modbus::handler::{FunctionHandler, HandlerContext, ExceptionCode};

pub struct MyCustomHandler;

impl FunctionHandler for MyCustomHandler {
    fn function_code(&self) -> u8 { 0x42 }

    fn handle(&self, pdu: &[u8], ctx: &HandlerContext) -> Result<Vec<u8>, ExceptionCode> {
        // Custom implementation
        Ok(vec![0x42, 0x00])
    }

    fn name(&self) -> &'static str { "My Custom Handler" }
}

Re-exports

pub use config::ModbusDeviceConfig;

pub use config::ModbusServerConfig;

pub use device::ModbusDevice;

pub use error::ModbusError;

pub use error::ModbusResult;

pub use register::RegisterStore;

pub use register::RegisterType;

pub use server::ModbusTcpServer;

pub use tcp::ModbusTcpServerV2;

pub use registers::AddressRange;

pub use registers::DefaultValue;

pub use registers::InitializationMode;

pub use registers::RegisterRangeConfig;

pub use registers::RegisterStoreConfig;

pub use registers::SparseRegisterStore;

pub use registers::CallbackManager;

pub use registers::CallbackPriority;

pub use registers::ReadCallback;

pub use registers::ReadCallbackFn;

pub use registers::WriteCallback;

pub use registers::WriteCallbackFn;

pub use registers::RegisterValue;

pub use rtu::ModbusRtuServer;

pub use rtu::RtuCodec;

pub use rtu::RtuFrame;

pub use rtu::RtuServerConfig;

pub use rtu::RtuTiming;

pub use rtu::SerialConfig;

pub use rtu::VirtualSerial;

pub use rtu::VirtualSerialConfig;

pub use types::RegisterConverter;

pub use types::RegisterDataType;

pub use types::TypedValue;

pub use types::WordOrder;

pub use unit::BroadcastMode;

pub use unit::MultiUnitManager;

pub use unit::UnitConfig;

pub use unit::UnitInfo;

pub use unit::UnitManagerConfig;

pub use testing::PerformanceValidator;

pub use testing::PerformanceConfig;

pub use testing::PerformanceTarget;

pub use testing::ValidationResult;

pub use testing::MemoryProfiler;

pub use testing::MemorySnapshot;

pub use testing::MemoryReport;

pub use testing::AllocationTracker;

pub use testing::LoadGenerator;

pub use testing::LoadConfig;

pub use testing::LoadPattern;

pub use testing::ConnectionSimulator;

pub use testing::TestReport;

pub use testing::TestMetrics;

pub use testing::TestSummary;

pub use fault_injection::FaultAction;

pub use fault_injection::FaultPipeline;

pub use fault_injection::ModbusFault;

pub use fault_injection::ModbusFaultContext;

pub use fault_injection::TransportKind;

pub use fault_injection::FaultInjectionConfig;

pub use fault_injection::FaultConfig;

pub use fault_injection::FaultType;

pub use fault_injection::FaultTarget;

pub use fault_injection::FaultStats;

pub use fault_injection::FaultStatsSnapshot;

pub use fault_injection::CrcCorruptionFault;

pub use fault_injection::WrongUnitIdFault;

pub use fault_injection::WrongFunctionCodeFault;

pub use fault_injection::WrongTransactionIdFault;

pub use fault_injection::TruncatedResponseFault;

pub use fault_injection::ExtraDataFault;

pub use fault_injection::DelayedResponseFault;

pub use fault_injection::NoResponseFault;

pub use fault_injection::ExceptionInjectionFault;

pub use fault_injection::PartialFrameFault;

pub use fault_injection::connection_disruption::ConnectionDisruptionConfig;

pub use fault_injection::connection_disruption::ConnectionDisruptionState;

pub use fault_injection::connection_disruption::DisruptionAction;

pub use fault_injection::rtu_timing::RtuTimingFaultConfig;

pub use fault_injection::rtu_timing::InterCharGapConfig;

pub use fault_injection::rtu_timing::GapPosition;

pub use fault_injection::rtu_timing::BusCollisionConfig;

pub use fault_injection::rtu_timing::CollisionMode;

pub use fault_injection::rtu_timing::ByteJitterConfig;

pub use fault_injection::rtu_timing::TimingPlan;

pub use fault_injection::rtu_timing::TimingSegment;

pub use runtime::RuntimeConfigManager;

pub use runtime::RuntimeState;

pub use runtime::ConfigUpdate;

pub use runtime::ConfigEvent;

pub use runtime::UpdateCategory;

pub use runtime::ConnectionLimits;

pub use runtime::TimeoutConfig;

pub use runtime::AccessControl;

pub use runtime::AddressRange as RuntimeAddressRange;

pub use runtime::FeatureFlags;

pub use runtime::UpdateBuilder;

pub use runtime::UpdateRecord;

pub use runtime::UpdateAuditLog;

pub use runtime::StateDiff;

pub use runtime::FieldChange;

Modules

config

Modbus configuration types.

device

Modbus device implementation.

error

Modbus error types.

fault_injection

Modbus-specific fault injection framework.

handler

Modbus function code handlers.

register

Modbus register storage.

registers

High-performance register storage for large-scale Modbus simulation.

rtu

Modbus RTU simulation module.

runtime

Runtime configuration management for Modbus simulator.

scalability

Scalability Module for High-Volume Processing

server

Modbus TCP server implementation.

tcp

Modbus TCP server components.

testing

Testing utilities and performance validation framework.

types

Data types and byte order support for Modbus register conversions.

unit

Multi-Unit Management for Modbus Simulation.