mbtoolcli 0.3.1__py3-none-any.whl

modbus_slave_sim/simulation.py

@@ -0,0 +1,318 @@
+"""
+Simulation engine for dynamic register value generation.
+
+This module provides different simulation types for generating dynamic
+values in Modbus registers:
+- Sine wave
+- Linear increment/decrement
+- Random values
+- Constant value
+- Counter
+"""
+
+import math
+import random
+import threading
+import time
+from enum import Enum
+from typing import Any, Callable, Dict, List, Optional
+
+from .registers import BaseRegister, ModbusRegisterMap
+from .colors import c, RED_BOLD
+
+
+class SimulationType(Enum):
+    """Available simulation types."""
+    CONSTANT = "constant"
+    SINE = "sine"
+    LINEAR = "linear"
+    RANDOM = "random"
+    COUNTER = "counter"
+
+
+class SimulationConfig:
+    """Configuration for a single register simulation."""
+
+    def __init__(
+        self,
+        sim_type: SimulationType,
+        min_value: float = 0,
+        max_value: float = 10000,
+        amplitude: float = 1000,
+        frequency: float = 0.1,
+        offset: float = 5000,
+        step: float = 1,
+        is_signed: bool = False,
+    ):
+        """
+        Initialize simulation configuration.
+
+        Args:
+            sim_type: Type of simulation
+            min_value: Minimum value (for random, linear wrapping)
+            max_value: Maximum value (for random, linear wrapping)
+            amplitude: Amplitude for sine wave
+            frequency: Frequency in Hz for sine wave
+            offset: Offset (center) for sine wave
+            step: Step size for linear and counter
+            is_signed: Whether values should be treated as signed
+        """
+        self.sim_type = sim_type
+        self.min_value = min_value
+        self.max_value = max_value
+        self.amplitude = amplitude
+        self.frequency = frequency
+        self.offset = offset
+        self.step = step
+        self.is_signed = is_signed
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "sim_type": self.sim_type.value,
+            "min_value": self.min_value,
+            "max_value": self.max_value,
+            "amplitude": self.amplitude,
+            "frequency": self.frequency,
+            "offset": self.offset,
+            "step": self.step,
+            "is_signed": self.is_signed,
+        }
+
+
+class SimulationEngine:
+    """
+    Engine for simulating dynamic values in Modbus registers.
+    
+    Runs in a background thread and updates register values based on
+    their simulation configuration.
+    """
+
+    def __init__(self, register_map: ModbusRegisterMap):
+        """
+        Initialize the simulation engine.
+
+        Args:
+            register_map: The register map to simulate values for
+        """
+        self.register_map = register_map
+        self._running = False
+        self._thread: Optional[threading.Thread] = None
+        self._interval = 0.1  # Update interval in seconds (100ms)
+        self._start_time = time.time()
+        self._counters: Dict[int, float] = {}
+
+    @property
+    def interval(self) -> float:
+        """Get the update interval."""
+        return self._interval
+
+    @interval.setter
+    def interval(self, seconds: float):
+        """Set the update interval."""
+        self._interval = max(0.01, seconds)  # Minimum 10ms
+
+    def configure_simulation(
+        self,
+        address: int,
+        reg_type: str,
+        config: SimulationConfig,
+    ):
+        """
+        Configure simulation for a specific register.
+
+        Args:
+            address: Register address
+            reg_type: Register type ('coils', 'discrete_inputs', 'input_registers', 'holding_registers')
+            config: Simulation configuration
+        """
+        register = self._get_register(address, reg_type)
+        if register:
+            register.simulation_enabled = True
+            register.simulation_config = config.to_dict()
+            self._counters[address] = 0.0
+
+    def remove_simulation(self, address: int, reg_type: str):
+        """Remove simulation from a register."""
+        register = self._get_register(address, reg_type)
+        if register:
+            register.simulation_enabled = False
+            register.simulation_config = {}
+            self._counters.pop(address, None)
+
+    def _get_register(self, address: int, reg_type: str) -> Optional[BaseRegister]:
+        """Get register by type and address."""
+        reg_map = {
+            "coils": self.register_map.coils,
+            "discrete_inputs": self.register_map.discrete_inputs,
+            "input_registers": self.register_map.input_registers,
+            "holding_registers": self.register_map.holding_registers,
+        }
+        return reg_map.get(reg_type, {}).get(address)
+
+    def _calculate_value(
+        self,
+        config: SimulationConfig,
+        address: int,
+        current_time: float,
+    ) -> Any:
+        """
+        Calculate the next value based on simulation type.
+
+        Args:
+            config: Simulation configuration
+            address: Register address
+            current_time: Current timestamp
+
+        Returns:
+            Calculated value
+        """
+        elapsed = current_time - self._start_time
+
+        if config.sim_type == SimulationType.SINE:
+            # Sine wave: offset + amplitude * sin(2π * frequency * time)
+            value = config.offset + config.amplitude * math.sin(
+                2 * math.pi * config.frequency * elapsed
+            )
+            return int(value) & 0xFFFF
+
+        elif config.sim_type == SimulationType.LINEAR:
+            # Linear increment with wrapping
+            counter = self._counters.get(address, 0.0)
+            counter += config.step
+            if counter > config.max_value:
+                counter = config.min_value
+            self._counters[address] = counter
+            return int(counter) & 0xFFFF
+
+        elif config.sim_type == SimulationType.RANDOM:
+            # Random value within range
+            value = random.randint(int(config.min_value), int(config.max_value))
+            return value & 0xFFFF
+
+        elif config.sim_type == SimulationType.COUNTER:
+            # Monotonically increasing counter
+            counter = self._counters.get(address, 0.0)
+            counter += config.step
+            if counter > 65535:
+                counter = config.min_value
+            self._counters[address] = counter
+            return int(counter) & 0xFFFF
+
+        elif config.sim_type == SimulationType.CONSTANT:
+            # Constant value (no change)
+            return int(config.offset) & 0xFFFF
+
+        return 0
+
+    def _update_registers(self):
+        """Update all simulated registers with new values."""
+        current_time = time.time()
+
+        for register in self.register_map.get_simulated_registers():
+            try:
+                config_dict = register.simulation_config
+                if not config_dict:
+                    continue
+
+                config = SimulationConfig(
+                    sim_type=SimulationType(config_dict.get("sim_type", "constant")),
+                    min_value=config_dict.get("min_value", 0),
+                    max_value=config_dict.get("max_value", 10000),
+                    amplitude=config_dict.get("amplitude", 1000),
+                    frequency=config_dict.get("frequency", 0.1),
+                    offset=config_dict.get("offset", 5000),
+                    step=config_dict.get("step", 1),
+                    is_signed=config_dict.get("is_signed", False),
+                )
+
+                new_value = self._calculate_value(config, register.address, current_time)
+                register.value = new_value
+
+            except Exception as e:
+                print(c(f"Simulation error for register {register.address}: {e}", RED_BOLD))
+
+    def _simulation_loop(self):
+        """Main simulation loop running in background thread."""
+        while self._running:
+            self._update_registers()
+            time.sleep(self._interval)
+
+    def start(self):
+        """Start the simulation engine."""
+        if self._running:
+            return
+
+        self._running = True
+        self._start_time = time.time()
+        self._thread = threading.Thread(
+            target=self._simulation_loop,
+            daemon=True,
+            name="SimulationEngine"
+        )
+        self._thread.start()
+
+    def stop(self):
+        """Stop the simulation engine."""
+        self._running = False
+        if self._thread:
+            self._thread.join(timeout=2.0)
+            self._thread = None
+
+    def is_running(self) -> bool:
+        """Check if the simulation engine is running."""
+        return self._running
+
+    def setup_default_simulations(self):
+        """
+        Set up default simulations for demonstration purposes.
+        
+        Configures:
+        - Input Registers 0-4: Sine waves with different frequencies
+        - Input Register 5-6: Counter
+        - Holding Register 9: Linear increment
+        """
+        # Input registers: sine waves
+        for i in range(5):
+            self.configure_simulation(
+                i, "input_registers",
+                SimulationConfig(
+                    sim_type=SimulationType.SINE,
+                    amplitude=2000 + i * 500,
+                    frequency=0.05 + i * 0.02,
+                    offset=5000 + i * 1000,
+                )
+            )
+
+        # Input registers: counters
+        for i in range(5, 7):
+            self.configure_simulation(
+                i, "input_registers",
+                SimulationConfig(
+                    sim_type=SimulationType.COUNTER,
+                    step=1,
+                )
+            )
+
+        # Holding register 9: linear increment
+        self.configure_simulation(
+            9, "holding_registers",
+            SimulationConfig(
+                sim_type=SimulationType.LINEAR,
+                min_value=0,
+                max_value=1000,
+                step=10,
+            )
+        )
+
+    def get_simulation_status(self) -> List[Dict[str, Any]]:
+        """Get status of all simulated registers."""
+        status = []
+        for register in self.register_map.get_simulated_registers():
+            status.append({
+                "address": register.address,
+                "value": register.value,
+                "description": register.description,
+                "config": register.simulation_config,
+            })
+        return status

modbus_slave_sim/tcp_server.py

@@ -0,0 +1,178 @@
+"""
+Modbus TCP Server implementation.
+
+This module provides a Modbus TCP slave server that handles
+incoming TCP connections and processes Modbus requests.
+Supports standard Modbus TCP (default) as well as RTU/ASCII
+over TCP for virtual serial port simulation.
+"""
+
+import logging
+import threading
+from typing import Optional
+
+from pymodbus.datastore import (
+    ModbusSequentialDataBlock,
+    ModbusSlaveContext,
+    ModbusServerContext,
+)
+from pymodbus.device import ModbusDeviceIdentification
+from pymodbus.server import StartTcpServer
+from pymodbus.framer import Framer
+
+from .registers import ModbusRegisterMap
+
+logger = logging.getLogger(__name__)
+
+
+class ModbusTCPServer:
+    """
+    Modbus TCP Slave Server.
+
+    Provides a Modbus TCP server that simulates a slave device with
+    configurable registers and optional simulation.
+    """
+
+    def __init__(
+        self,
+        register_map: ModbusRegisterMap,
+        host: str = "0.0.0.0",
+        port: int = 502,
+        slave_id: int = 1,
+        framer: str = "tcp",
+    ):
+        self.register_map = register_map
+        self.host = host
+        self.port = port
+        self.slave_id = slave_id
+        self.framer = framer
+        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 TCP server in a background thread."""
+        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()
+
+        protocol_name = self._get_protocol_name()
+        logger.info(f"Starting Modbus {protocol_name} server on {self.host}:{self.port}")
+        logger.info(f"Slave ID: {self.slave_id}")
+
+        framer_map = {
+            "tcp": Framer.SOCKET,
+            "rtu": Framer.RTU,
+            "ascii": Framer.ASCII,
+            "rtu-tcp": Framer.RTU,
+            "ascii-tcp": Framer.ASCII,
+        }
+        pymodbus_framer = framer_map.get(self.framer, Framer.RTU)
+
+        def _run_server():
+            try:
+                self._server = StartTcpServer(
+                    context=server_context,
+                    identity=identification,
+                    address=(self.host, self.port),
+                    framer=pymodbus_framer,
+                )
+            except Exception as e:
+                logger.error(f"Failed to start TCP server: {e}")
+                raise
+
+        self._thread = threading.Thread(target=_run_server, daemon=True, name="ModbusTCPServer")
+        self._thread.start()
+
+    def _get_protocol_name(self) -> str:
+        names = {"tcp": "TCP", "rtu": "RTU (Serial)", "ascii": "ASCII (Serial)",
+                 "rtu-tcp": "RTU over TCP", "ascii-tcp": "ASCII over TCP"}
+        return names.get(self.framer, self.framer)
+
+    def stop(self):
+        if self._server:
+            self._server.shutdown()
+            self._server = None
+            logger.info("Modbus TCP server stopped")
+
+    def set_register(self, fc, address, value):
+        """Set a register value via the slave context.
+
+        Args:
+            fc: Function code (3=HR, 4=IR, 1=CO, 2=DI)
+            address: Register address
+            value: New value
+        """
+        if self._slave_context:
+            self._slave_context.setValues(fc, address, [value])
+
+    def set_registers(self, fc, address, values):
+        """Set multiple register values via the slave context.
+
+        Args:
+            fc: Function code (3=HR, 4=IR, 1=CO, 2=DI)
+            address: Starting register address
+            values: List of new values
+        """
+        if self._slave_context:
+            self._slave_context.setValues(fc, address, values)
+
+    def update_data_blocks(self):
+        """Update server data blocks from register map."""
+        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