mbtoolcli 0.3.1__py3-none-any.whl

modbus_slave_sim/registers.py

@@ -0,0 +1,288 @@
+"""
+Modbus register data structures and management.
+
+This module defines the register types used in Modbus protocol:
+- Coils (1-bit, read/write)
+- Discrete Inputs (1-bit, read-only)
+- Input Registers (16-bit, read-only)
+- Holding Registers (16-bit, read/write)
+"""
+
+import json
+from typing import Any, Dict, List, Optional
+
+from .colors import c, BOLD, DIM, RED, GREEN, GREEN_BOLD, RED_BOLD, CYAN, CYAN_BOLD, MAGENTA, WHITE_BOLD
+
+
+class BaseRegister:
+    """Base class for all Modbus register types."""
+
+    def __init__(self, address: int, value: Any = 0, description: str = ""):
+        """
+        Initialize a register.
+
+        Args:
+            address: Register address (0-65535)
+            value: Initial value
+            description: Human-readable description
+        """
+        self.address = address
+        self.value = value
+        self.description = description
+        self._simulation_enabled = False
+        self._simulation_config: Dict[str, Any] = {}
+
+    @property
+    def simulation_enabled(self) -> bool:
+        """Check if simulation is enabled for this register."""
+        return self._simulation_enabled
+
+    @simulation_enabled.setter
+    def simulation_enabled(self, enabled: bool):
+        """Enable or disable simulation for this register."""
+        self._simulation_enabled = enabled
+
+    @property
+    def simulation_config(self) -> Dict[str, Any]:
+        """Get simulation configuration."""
+        return self._simulation_config
+
+    @simulation_config.setter
+    def simulation_config(self, config: Dict[str, Any]):
+        """Set simulation configuration."""
+        self._simulation_config = config
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(address={self.address}, value={self.value})"
+
+
+class CoilRegister(BaseRegister):
+    """
+    Coil register (1-bit, read/write).
+    
+    Address range: 0-65535
+    Function codes: 1 (Read), 5 (Write Single), 15 (Write Multiple)
+    """
+
+    def __init__(self, address: int, value: bool = False, description: str = ""):
+        super().__init__(address, value, description)
+
+    @property
+    def value(self) -> bool:
+        return self._value
+
+    @value.setter
+    def value(self, val: bool):
+        self._value = bool(val)
+
+
+class DiscreteInputRegister(BaseRegister):
+    """
+    Discrete Input register (1-bit, read-only).
+    
+    Address range: 0-65535
+    Function codes: 2 (Read)
+    """
+
+    def __init__(self, address: int, value: bool = False, description: str = ""):
+        super().__init__(address, value, description)
+
+    @property
+    def value(self) -> bool:
+        return self._value
+
+    @value.setter
+    def value(self, val: bool):
+        self._value = bool(val)
+
+
+class InputRegister(BaseRegister):
+    """
+    Input Register (16-bit, read-only).
+    
+    Address range: 0-65535
+    Function codes: 4 (Read)
+    """
+
+    def __init__(self, address: int, value: int = 0, description: str = ""):
+        super().__init__(address, value, description)
+
+    @property
+    def value(self) -> int:
+        return self._value
+
+    @value.setter
+    def value(self, val: int):
+        self._value = int(val) & 0xFFFF
+
+
+class HoldingRegister(BaseRegister):
+    """
+    Holding Register (16-bit, read/write).
+    
+    Address range: 0-65535
+    Function codes: 3 (Read), 6 (Write Single), 16 (Write Multiple)
+    """
+
+    def __init__(self, address: int, value: int = 0, description: str = ""):
+        super().__init__(address, value, description)
+
+    @property
+    def value(self) -> int:
+        return self._value
+
+    @value.setter
+    def value(self, val: int):
+        self._value = int(val) & 0xFFFF
+
+
+class ModbusRegisterMap:
+    """
+    Container for all Modbus registers.
+    
+    Manages coils, discrete inputs, input registers, and holding registers.
+    """
+
+    def __init__(self):
+        self.coils: Dict[int, CoilRegister] = {}
+        self.discrete_inputs: Dict[int, DiscreteInputRegister] = {}
+        self.input_registers: Dict[int, InputRegister] = {}
+        self.holding_registers: Dict[int, HoldingRegister] = {}
+
+    def add_coil(self, address: int, value: bool = False, description: str = ""):
+        """Add a coil register."""
+        self.coils[address] = CoilRegister(address, value, description)
+
+    def add_discrete_input(self, address: int, value: bool = False, description: str = ""):
+        """Add a discrete input register."""
+        self.discrete_inputs[address] = DiscreteInputRegister(address, value, description)
+
+    def add_input_register(self, address: int, value: int = 0, description: str = ""):
+        """Add an input register."""
+        self.input_registers[address] = InputRegister(address, value, description)
+
+    def add_holding_register(self, address: int, value: int = 0, description: str = ""):
+        """Add a holding register."""
+        self.holding_registers[address] = HoldingRegister(address, value, description)
+
+    def get_coil(self, address: int) -> Optional[CoilRegister]:
+        """Get a coil by address."""
+        return self.coils.get(address)
+
+    def get_discrete_input(self, address: int) -> Optional[DiscreteInputRegister]:
+        """Get a discrete input by address."""
+        return self.discrete_inputs.get(address)
+
+    def get_input_register(self, address: int) -> Optional[InputRegister]:
+        """Get an input register by address."""
+        return self.input_registers.get(address)
+
+    def get_holding_register(self, address: int) -> Optional[HoldingRegister]:
+        """Get a holding register by address."""
+        return self.holding_registers.get(address)
+
+    def get_all_registers(self) -> List[BaseRegister]:
+        """Get all registers as a flat list."""
+        registers = []
+        registers.extend(self.coils.values())
+        registers.extend(self.discrete_inputs.values())
+        registers.extend(self.input_registers.values())
+        registers.extend(self.holding_registers.values())
+        return registers
+
+    def get_simulated_registers(self) -> List[BaseRegister]:
+        """Get all registers with simulation enabled."""
+        return [r for r in self.get_all_registers() if r.simulation_enabled]
+
+    def load_from_dict(self, data: Dict[str, list]):
+        """Load register map from a dictionary (parsed from JSON).
+
+        Expected format:
+        {
+            "coils": [{"address": 0, "value": false, "description": "..."}, ...],
+            "discrete_inputs": [...],
+            "input_registers": [{"address": 0, "value": 0, "description": "..."}, ...],
+            "holding_registers": [...]
+        }
+        """
+        for entry in data.get("coils", []):
+            self.add_coil(entry["address"], entry.get("value", False), entry.get("description", ""))
+        for entry in data.get("discrete_inputs", []):
+            self.add_discrete_input(entry["address"], entry.get("value", False), entry.get("description", ""))
+        for entry in data.get("input_registers", []):
+            self.add_input_register(entry["address"], entry.get("value", 0), entry.get("description", ""))
+        for entry in data.get("holding_registers", []):
+            self.add_holding_register(entry["address"], entry.get("value", 0), entry.get("description", ""))
+
+    @classmethod
+    def load_from_json(cls, filepath: str) -> "ModbusRegisterMap":
+        """Load register map from a JSON file.
+
+        Args:
+            filepath: Path to JSON file
+
+        Returns:
+            New ModbusRegisterMap instance with loaded data
+        """
+        with open(filepath, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        register_map = cls()
+        register_map.load_from_dict(data)
+        return register_map
+
+    def create_default_map(self):
+        """Create a default register map with sample data."""
+        # Coils (0-7)
+        for i in range(8):
+            self.add_coil(i, value=(i % 2 == 0), description=f"Coil {i}")
+
+        # Discrete Inputs (0-7)
+        for i in range(8):
+            self.add_discrete_input(i, value=(i % 2 == 1), description=f"Discrete Input {i}")
+
+        # Input Registers (0-9) - Read-only simulated values
+        self.add_input_register(0, 1234, "Temperature")
+        self.add_input_register(1, 5678, "Pressure")
+        self.add_input_register(2, 9012, "Flow Rate")
+        self.add_input_register(3, 3456, "Level")
+        self.add_input_register(4, 7890, "Speed")
+        self.add_input_register(5, 1111, "Counter A")
+        self.add_input_register(6, 2222, "Counter B")
+        self.add_input_register(7, 3333, "Status Word")
+        self.add_input_register(8, 4444, "Error Code")
+        self.add_input_register(9, 5555, "System Time")
+
+        # Holding Registers (0-9) - Read/Write configuration values
+        self.add_holding_register(0, 100, "Setpoint 1")
+        self.add_holding_register(1, 200, "Setpoint 2")
+        self.add_holding_register(2, 300, "Gain")
+        self.add_holding_register(3, 400, "Integral Time")
+        self.add_holding_register(4, 500, "Derivative Time")
+        self.add_holding_register(5, 600, "Output Limit High")
+        self.add_holding_register(6, 700, "Output Limit Low")
+        self.add_holding_register(7, 800, "Alarm Setpoint 1")
+        self.add_holding_register(8, 900, "Alarm Setpoint 2")
+        self.add_holding_register(9, 1000, "Control Mode")
+
+    def print_status(self):
+        """Print the current status of all registers."""
+        print(f"\n{c('=== Register Status ===', CYAN_BOLD)}")
+
+        print(f"\n{c('Coils (Read/Write):', WHITE_BOLD)}")
+        for addr, coil in sorted(self.coils.items()):
+            state = c("ON ", GREEN_BOLD) if coil.value else c("OFF", RED_BOLD)
+            print(f"  [{c(str(addr).rjust(5), MAGENTA)}] = {state} - {c(coil.description, DIM)}")
+
+        print(f"\n{c('Discrete Inputs (Read-Only):', WHITE_BOLD)}")
+        for addr, di in sorted(self.discrete_inputs.items()):
+            state = c("ON ", GREEN_BOLD) if di.value else c("OFF", RED_BOLD)
+            print(f"  [{c(str(addr).rjust(5), MAGENTA)}] = {state} - {c(di.description, DIM)}")
+
+        print(f"\n{c('Input Registers (Read-Only):', WHITE_BOLD)}")
+        for addr, ir in sorted(self.input_registers.items()):
+            print(f"  [{c(str(addr).rjust(5), MAGENTA)}] = {c(str(ir.value).rjust(5), CYAN_BOLD)} - {c(ir.description, DIM)}")
+
+        print(f"\n{c('Holding Registers (Read/Write):', WHITE_BOLD)}")
+        for addr, hr in sorted(self.holding_registers.items()):
+            print(f"  [{c(str(addr).rjust(5), MAGENTA)}] = {c(str(hr.value).rjust(5), CYAN_BOLD)} - {c(hr.description, DIM)}")
+        print(f"{c('========================', CYAN_BOLD)}\n")

modbus_slave_sim/rtu_server.py

@@ -0,0 +1,158 @@
+"""
+Modbus RTU/ASCII Server implementation.
+
+This module provides a Modbus serial slave server that handles
+serial communication using the Modbus RTU or ASCII protocol.
+"""
+
+import logging
+from typing import Optional
+
+from pymodbus.datastore import (
+    ModbusSequentialDataBlock,
+    ModbusSlaveContext,
+    ModbusServerContext,
+)
+from pymodbus.device import ModbusDeviceIdentification
+from pymodbus.server import StartSerialServer
+from pymodbus.framer import Framer
+
+from .registers import ModbusRegisterMap
+
+logger = logging.getLogger(__name__)
+
+
+class ModbusSerialServer:
+    """Modbus Serial Slave Server (RTU or ASCII)."""
+
+    def __init__(
+        self,
+        register_map: ModbusRegisterMap,
+        port: str = "/dev/ttyUSB0",
+        baudrate: int = 9600,
+        parity: str = "N",
+        stopbits: int = 1,
+        bytesize: int = 8,
+        timeout: float = 1.0,
+        slave_id: int = 1,
+        framer: str = "rtu",
+        inter_char_delay: Optional[float] = None,
+    ):
+        self.register_map = register_map
+        self.port = port
+        self.baudrate = baudrate
+        self.parity = parity
+        self.stopbits = stopbits
+        self.bytesize = bytesize
+        self.timeout = timeout
+        self.slave_id = slave_id
+        self.framer = framer
+        self.inter_char_delay = inter_char_delay
+        self._server = None
+        self._slave_context = None
+
+    def _create_data_blocks(self):
+        """Create Modbus data blocks from register map."""
+        max_coil_addr = max(self.register_map.coils.keys()) + 1 if self.register_map.coils else 10
+        coil_values = [False] * (max_coil_addr + 1)
+        for addr, coil in self.register_map.coils.items():
+            coil_values[addr] = coil.value
+        coil_block = ModbusSequentialDataBlock(1, coil_values)
+
+        max_di_addr = max(self.register_map.discrete_inputs.keys()) + 1 if self.register_map.discrete_inputs else 10
+        di_values = [False] * (max_di_addr + 1)
+        for addr, di in self.register_map.discrete_inputs.items():
+            di_values[addr] = di.value
+        di_block = ModbusSequentialDataBlock(1, di_values)
+
+        max_hr_addr = max(self.register_map.holding_registers.keys()) + 1 if self.register_map.holding_registers else 10
+        hr_values = [0] * (max_hr_addr + 1)
+        for addr, hr in self.register_map.holding_registers.items():
+            hr_values[addr] = hr.value
+        hr_block = ModbusSequentialDataBlock(1, hr_values)
+
+        max_ir_addr = max(self.register_map.input_registers.keys()) + 1 if self.register_map.input_registers else 10
+        ir_values = [0] * (max_ir_addr + 1)
+        for addr, ir in self.register_map.input_registers.items():
+            ir_values[addr] = ir.value
+        ir_block = ModbusSequentialDataBlock(1, ir_values)
+
+        return coil_block, di_block, hr_block, ir_block
+
+    def _create_device_identification(self) -> ModbusDeviceIdentification:
+        identification = ModbusDeviceIdentification()
+        identification.VendorName = "Modbus Slave Simulator"
+        identification.ProductCode = "MBS-001"
+        identification.VendorUrl = "https://github.com/yourusername/modbus-slave-sim"
+        identification.ProductName = "Modbus Slave Sim"
+        identification.ModelName = "Virtual Slave Device"
+        identification.MajorMinorRevision = "1.0.0"
+        return identification
+
+    def start(self):
+        """Start the Modbus serial server."""
+        coil_block, di_block, hr_block, ir_block = self._create_data_blocks()
+
+        self._slave_context = ModbusSlaveContext(
+            co=coil_block, di=di_block, hr=hr_block, ir=ir_block,
+        )
+        server_context = ModbusServerContext(
+            slaves=self._slave_context, single=True,
+        )
+
+        identification = self._create_device_identification()
+
+        framer_map = {"rtu": Framer.RTU, "ascii": Framer.ASCII}
+        pymodbus_framer = framer_map.get(self.framer, Framer.RTU)
+        protocol = "ASCII" if self.framer == "ascii" else "RTU"
+        logger.info(f"Starting Modbus {protocol} server on {self.port}")
+        logger.info(f"Baudrate: {self.baudrate}, Parity: {self.parity}, Stopbits: {self.stopbits}")
+        logger.info(f"Slave ID: {self.slave_id}")
+
+        try:
+            kwargs = dict(
+                context=server_context,
+                identity=identification,
+                port=self.port,
+                framer=pymodbus_framer,
+                baudrate=self.baudrate,
+                parity=self.parity,
+                stopbits=self.stopbits,
+                bytesize=self.bytesize,
+                timeout=self.timeout,
+            )
+            if self.inter_char_delay is not None:
+                kwargs["inter_char_delay"] = self.inter_char_delay
+            self._server = StartSerialServer(**kwargs)
+        except Exception as e:
+            logger.error(f"Failed to start {protocol} server: {e}")
+            raise
+
+    def stop(self):
+        if self._server:
+            self._server.shutdown()
+            self._server = None
+            logger.info("Modbus serial server stopped")
+
+    def set_register(self, fc, address, value):
+        if self._slave_context:
+            self._slave_context.setValues(fc, address, [value])
+
+    def set_registers(self, fc, address, values):
+        if self._slave_context:
+            self._slave_context.setValues(fc, address, values)
+
+    def update_data_blocks(self):
+        if not self._slave_context:
+            return
+        for addr, coil in self.register_map.coils.items():
+            self._slave_context.setValues(0x01, addr, [coil.value])
+        for addr, di in self.register_map.discrete_inputs.items():
+            self._slave_context.setValues(0x02, addr, [di.value])
+        for addr, hr in self.register_map.holding_registers.items():
+            self._slave_context.setValues(0x03, addr, [hr.value])
+        for addr, ir in self.register_map.input_registers.items():
+            self._slave_context.setValues(0x04, addr, [ir.value])
+
+    def is_running(self) -> bool:
+        return self._server is not None