modsim 0.5.2__tar.gz → 1.0.1__tar.gz

{modsim-0.5.2 → modsim-1.0.1}/PKG-INFO

@@ -1,26 +1,24 @@
 Metadata-Version: 2.1
 Name: modsim
-Version: 0.5.2
+Version: 1.0.1
 Summary: A Simple Modbus TCP Device Simulator used for modpoll tool
-Home-page: https://github.com/gavinying/modsim
+Home-page: https://github.com/top-maker/modsim
 Author: Ying Shaodong
 Author-email: helloysd@gmail.com
-Requires-Python: >=3.8.2,<4.0
+Requires-Python: >=3.10,<4.0
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: pymodbus (>=3.6.9,<3.7.0)
-Project-URL: Documentation, https://gavinying.github.io/modsim/
-Project-URL: Repository, https://github.com/gavinying/modsim
+Requires-Dist: pymodbus (>=3.16.1,<3.17.0)
+Project-URL: Documentation, https://top-maker.github.io/modsim/
+Project-URL: Repository, https://github.com/top-maker/modsim
 Description-Content-Type: text/markdown
 
 # ModSim - A Simple Modbus TCP Device Simulator
 
-*modsim* is a simple Modbus TCP device simulator deployed at `modsim.topmaker.net:502`.
-It works as a remote Modbus-TCP (virtual) device, which has already been populated with all 4 types of registers, i.e.
+*modsim* is a Modbus device simulator that can run locally or in a container. A public simulator is available at `modsim.topmaker.net:502` for quick testing.
+Its default datastore contains all four Modbus tables:
 - Coil Type
 - Discrete input Type
 - Input register Type
@@ -89,8 +87,21 @@ To verify it, you can test by [modpoll](https://github.com/gavinying/modpoll) to
 modpoll \
   --tcp localhost \
   --tcp-port 5020 \
-  --config https://raw.githubusercontent.com/gavinying/modpoll/master/examples/modsim.csv
+  --config https://raw.githubusercontent.com/gavinying/modpoll/main/examples/modsim.csv
 ```
 
-> **_Note_**: add `sudo` before `docker run` command if you want to use the Modbus TCP standard port `502`.
+To expose the standard Modbus TCP port on the host, use `docker run -p 502:5020 topmaker/modsim:latest`. Your system may require permission to bind port 502.
+
+## Local server behavior
+
+Run the simulator without Docker with `python -m modsim --comm tcp --port 5020`. The default server exposes the four Modbus tables with the sample data shown above. Coil and holding-register writes are supported; discrete inputs and input registers are read-only. Requests outside an initialized address range return a Modbus exception. The server handles SIGINT and SIGTERM by stopping its listener so the port can be reused after shutdown.
+
+The default TCP simulator uses one sequential datastore shared by all Unit IDs.
+The CLI currently supports only `--store sequential`; `--slaves` and `--context`
+are not implemented and are rejected. TCP and UDP use the socket framer, TLS uses
+the TLS framer, and serial accepts RTU or ASCII framing. Serial requires a suitable local device and is not covered by the local protocol regression suite. TLS uses `examples/certificates/pymodbus.crt` and `pymodbus.key` relative to the working directory. A local test covers a self-signed server certificate and a verified client connection; the server does not authenticate client certificates.
+
+UDP mode (`--comm udp`) listens on the loopback address and has local read and
+shutdown coverage. TCP and UDP report a startup error if the requested port is
+already in use.
 

{modsim-0.5.2 → modsim-1.0.1}/README.md

@@ -1,7 +1,7 @@
 # ModSim - A Simple Modbus TCP Device Simulator
 
-*modsim* is a simple Modbus TCP device simulator deployed at `modsim.topmaker.net:502`.
-It works as a remote Modbus-TCP (virtual) device, which has already been populated with all 4 types of registers, i.e.
+*modsim* is a Modbus device simulator that can run locally or in a container. A public simulator is available at `modsim.topmaker.net:502` for quick testing.
+Its default datastore contains all four Modbus tables:
 - Coil Type
 - Discrete input Type
 - Input register Type
@@ -70,7 +70,20 @@ To verify it, you can test by [modpoll](https://github.com/gavinying/modpoll) to
 modpoll \
   --tcp localhost \
   --tcp-port 5020 \
-  --config https://raw.githubusercontent.com/gavinying/modpoll/master/examples/modsim.csv
+  --config https://raw.githubusercontent.com/gavinying/modpoll/main/examples/modsim.csv
 ```
 
-> **_Note_**: add `sudo` before `docker run` command if you want to use the Modbus TCP standard port `502`.
+To expose the standard Modbus TCP port on the host, use `docker run -p 502:5020 topmaker/modsim:latest`. Your system may require permission to bind port 502.
+
+## Local server behavior
+
+Run the simulator without Docker with `python -m modsim --comm tcp --port 5020`. The default server exposes the four Modbus tables with the sample data shown above. Coil and holding-register writes are supported; discrete inputs and input registers are read-only. Requests outside an initialized address range return a Modbus exception. The server handles SIGINT and SIGTERM by stopping its listener so the port can be reused after shutdown.
+
+The default TCP simulator uses one sequential datastore shared by all Unit IDs.
+The CLI currently supports only `--store sequential`; `--slaves` and `--context`
+are not implemented and are rejected. TCP and UDP use the socket framer, TLS uses
+the TLS framer, and serial accepts RTU or ASCII framing. Serial requires a suitable local device and is not covered by the local protocol regression suite. TLS uses `examples/certificates/pymodbus.crt` and `pymodbus.key` relative to the working directory. A local test covers a self-signed server certificate and a verified client connection; the server does not authenticate client certificates.
+
+UDP mode (`--comm udp`) listens on the loopback address and has local read and
+shutdown coverage. TCP and UDP report a startup error if the requested port is
+already in use.

modsim-1.0.1/modsim/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.1"

modsim-1.0.1/modsim/compat.py

@@ -0,0 +1,131 @@
+"""Compatibility layer for PyModbus API changes.
+
+This module provides backward-compatible wrappers for APIs that changed
+between PyModbus 3.6.9 and 3.16.1.
+"""
+
+import struct
+from typing import List
+
+
+class Endian:
+    """Compatibility class for endianness constants removed in PyModbus 3.16.1."""
+
+    BIG = "big"
+    LITTLE = "little"
+
+
+class BinaryPayloadBuilder:
+    """Compatibility wrapper for PyModbus BinaryPayloadBuilder.
+
+    This class was removed in PyModbus 3.9.0+ but is needed for backward
+    compatibility with existing datastore initialization code.
+    """
+
+    def __init__(self, byteorder: str = "big", wordorder: str = "big") -> None:
+        """Initialize the builder.
+
+        Args:
+            byteorder: Either "big" or "little" for byte order
+            wordorder: Either "big" or "little" for word order (register order)
+        """
+        self.byteorder = byteorder
+        self.wordorder = wordorder
+        self._bits: List[bool] = []
+        self._registers: List[int] = []
+
+    def add_bits(self, bits: List[bool]) -> "BinaryPayloadBuilder":
+        """Add a list of bits to the payload.
+
+        Args:
+            bits: List of boolean values
+
+        Returns:
+            Self for chaining
+        """
+        self._bits.extend(bits)
+        return self
+
+    def add_16bit_uint(self, value: int) -> "BinaryPayloadBuilder":
+        """Add a 16-bit unsigned integer."""
+        self._registers.append(value & 0xFFFF)
+        return self
+
+    def add_16bit_int(self, value: int) -> "BinaryPayloadBuilder":
+        """Add a 16-bit signed integer."""
+        # Convert negative to unsigned representation (two's complement)
+        if value < 0:
+            value = (1 << 16) + value
+        self._registers.append(value & 0xFFFF)
+        return self
+
+    def add_32bit_uint(self, value: int) -> "BinaryPayloadBuilder":
+        """Add a 32-bit unsigned integer (uses 2 registers)."""
+        if self.wordorder == "big":
+            self._registers.append((value >> 16) & 0xFFFF)
+            self._registers.append(value & 0xFFFF)
+        else:
+            self._registers.append(value & 0xFFFF)
+            self._registers.append((value >> 16) & 0xFFFF)
+        return self
+
+    def add_32bit_int(self, value: int) -> "BinaryPayloadBuilder":
+        """Add a 32-bit signed integer (uses 2 registers)."""
+        # Convert to unsigned if negative
+        if value < 0:
+            value = (1 << 32) + value
+        return self.add_32bit_uint(value)
+
+    def add_32bit_float(self, value: float) -> "BinaryPayloadBuilder":
+        """Add a 32-bit float (uses 2 registers)."""
+        fmt = ">f"  # big-endian float
+        packed = struct.pack(fmt, value)
+        value_int = struct.unpack(">I", packed)[0]
+        return self.add_32bit_uint(value_int)
+
+    def add_64bit_uint(self, value: int) -> "BinaryPayloadBuilder":
+        """Add a 64-bit unsigned integer (uses 4 registers)."""
+        if self.wordorder == "big":
+            self._registers.append((value >> 48) & 0xFFFF)
+            self._registers.append((value >> 32) & 0xFFFF)
+            self._registers.append((value >> 16) & 0xFFFF)
+            self._registers.append(value & 0xFFFF)
+        else:
+            self._registers.append(value & 0xFFFF)
+            self._registers.append((value >> 16) & 0xFFFF)
+            self._registers.append((value >> 32) & 0xFFFF)
+            self._registers.append((value >> 48) & 0xFFFF)
+        return self
+
+    def add_64bit_int(self, value: int) -> "BinaryPayloadBuilder":
+        """Add a 64-bit signed integer (uses 4 registers)."""
+        # Convert to unsigned if negative
+        if value < 0:
+            value = (1 << 64) + value
+        return self.add_64bit_uint(value)
+
+    def add_64bit_float(self, value: float) -> "BinaryPayloadBuilder":
+        """Add a 64-bit float (uses 4 registers)."""
+        packed = struct.pack(">d", value)
+        value_int = struct.unpack(">Q", packed)[0]
+        return self.add_64bit_uint(value_int)
+
+    def add_string(self, value: str) -> "BinaryPayloadBuilder":
+        """Add a string (encoded as UTF-8)."""
+        encoded = value.encode("utf-8")
+        # Pad to even number of bytes
+        if len(encoded) % 2:
+            encoded += b"\x00"
+        # Convert bytes to registers (2 bytes per register)
+        for i in range(0, len(encoded), 2):
+            reg_value = (encoded[i] << 8) | encoded[i + 1]
+            self._registers.append(reg_value)
+        return self
+
+    def to_coils(self) -> List[bool]:
+        """Return the bits as a list of booleans."""
+        return self._bits
+
+    def to_registers(self) -> List[int]:
+        """Return the registers as a list of integers."""
+        return self._registers

modsim-1.0.1/modsim/main.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""Modbus simulator server and process lifecycle."""
+
+import os
+import ssl
+import asyncio
+import signal
+import logging
+from contextlib import suppress
+from typing import Any
+
+from pymodbus.datastore import (
+    ModbusDeviceContext,
+    ModbusSequentialDataBlock,
+    ModbusServerContext,
+)
+from pymodbus.pdu.device import ModbusDeviceIdentification
+from pymodbus.server import (
+    StartAsyncSerialServer,
+    ModbusTcpServer,
+    ModbusTlsServer,
+    ModbusUdpServer,
+    ServerAsyncStop,
+)
+
+from . import __version__
+from .compat import BinaryPayloadBuilder, Endian
+from .utils import get_commandline, get_utc_time, get_logger
+
+_logger = logging.getLogger(__name__)
+
+
+def setup_server(args: Any) -> Any:
+    """Run server setup."""
+    # The datastores only respond to the addresses that are initialized
+    # If you initialize a DataBlock to addresses of 0x00 to 0xFF, a request to
+    # 0x100 will respond with an invalid address exception.
+    # This is because many devices exhibit this kind of behavior (but not all)
+    if not args.context:
+        _logger.info("Create datastore")
+        # build your payload
+        co_builder = BinaryPayloadBuilder(byteorder=Endian.BIG, wordorder=Endian.BIG)
+        # address=0, bytes=3
+        for _ in range(3):
+            # The bits within each byte are big-endian
+            # The coils status (from the first position) = [1,0,1,0,0,0,0,1]
+            co_builder.add_bits([True, False, True, False, False, False, False, True])
+
+        hr_builder = BinaryPayloadBuilder(byteorder=Endian.BIG, wordorder=Endian.BIG)
+        # address=0, bytes=8
+        hr_builder.add_16bit_uint(1)
+        hr_builder.add_16bit_uint(2)
+        hr_builder.add_16bit_uint(3)
+        hr_builder.add_16bit_uint(4)
+        # address=8, bytes=8
+        hr_builder.add_16bit_int(-1)
+        hr_builder.add_16bit_int(-2)
+        hr_builder.add_16bit_int(-3)
+        hr_builder.add_16bit_int(-4)
+        # address=16, bytes=8
+        hr_builder.add_32bit_uint(12345678)
+        hr_builder.add_32bit_uint(12345678)
+        # address=24, bytes=8
+        hr_builder.add_32bit_int(-12345678)
+        hr_builder.add_32bit_int(-12345678)
+        # address=32, bytes=8
+        hr_builder.add_32bit_float(12.34)
+        hr_builder.add_32bit_float(-12.34)
+        # address=40, bytes=8
+        hr_builder.add_64bit_uint(12345678900)
+        # address=48, bytes=8
+        hr_builder.add_64bit_int(-12345678900)
+        # address=56, bytes=16
+        hr_builder.add_64bit_float(123.45)
+        hr_builder.add_64bit_float(-123.45)
+        # address=72, bytes=?
+        hr_builder.add_string("this is a string")
+
+        # use that payload in the data store
+        co_values = co_builder.to_coils()
+        hr_values = hr_builder.to_registers()
+        # Note: In PyModbus 3.16.1+, ModbusSequentialDataBlock uses address - 1 internally
+        # to convert to SimData. To maintain address ranges, we use address + 1 here.
+        # This maps Modbus addresses the same way as zero_mode=True did in older versions.
+        device_context = ModbusDeviceContext(
+            co=ModbusSequentialDataBlock(1, co_values),
+            di=ModbusSequentialDataBlock(10001, co_values),
+            ir=ModbusSequentialDataBlock(30001, hr_values),
+            hr=ModbusSequentialDataBlock(40001, hr_values),
+        )
+        args.context = ModbusServerContext(devices=device_context, single=True)
+
+    # initialize the server information
+    # If you don't set this or any fields, they are defaulted to empty strings.
+    args.identity = ModbusDeviceIdentification(
+        info_name={
+            "VendorName": "Pymodbus",
+            "ProductCode": "PM",
+            "VendorUrl": "https://github.com/riptideio/pymodbus/",
+            "ProductName": "Pymodbus Server",
+            "ModelName": "Pymodbus Server",
+        }
+    )
+    return args
+
+
+async def run_async_server(args: Any) -> Any:
+    """Run server."""
+    txt = f"Start ASYNC server, listening on {args.port} - {args.comm}"
+    _logger.info(txt)
+    server: Any
+    if args.comm == "tcp":
+        address: tuple[str, int] = ("", args.port)
+        server = ModbusTcpServer(
+            context=args.context,
+            identity=args.identity,
+            address=address,
+            framer=args.framer,
+        )
+        try:
+            if not await server.listen():
+                raise OSError(
+                    "Could not start Modbus TCP listener on port %s" % args.port
+                )
+            await server.serving
+        finally:
+            await server.shutdown()
+        return server
+    elif args.comm == "udp":
+        address = ("127.0.0.1", args.port)
+        server = ModbusUdpServer(
+            context=args.context,
+            identity=args.identity,
+            address=address,
+            framer=args.framer,
+        )
+        try:
+            if not await server.listen():
+                raise OSError(
+                    "Could not start Modbus UDP listener on port %s" % args.port
+                )
+            await server.serving
+        finally:
+            await server.shutdown()
+        return server
+    elif args.comm == "serial":
+        await StartAsyncSerialServer(
+            context=args.context,
+            identity=args.identity,
+            port=args.port,
+            framer=args.framer,
+        )
+        return None
+    elif args.comm == "tls":
+        address = ("", args.port)
+        cwd = os.getcwd().split("/")[-1]
+        if cwd == "examples":
+            path = "."
+        elif cwd == "test":
+            path = "../examples"
+        else:
+            path = "examples"
+
+        # Create SSL context from cert and key files
+        sslctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+        sslctx.load_cert_chain(
+            certfile=f"{path}/certificates/pymodbus.crt",
+            keyfile=f"{path}/certificates/pymodbus.key",
+        )
+
+        server = ModbusTlsServer(
+            context=args.context,
+            identity=args.identity,
+            address=address,
+            framer=args.framer,
+            sslctx=sslctx,
+        )
+        try:
+            if not await server.listen():
+                raise OSError(
+                    "Could not start Modbus TLS listener on port %s" % args.port
+                )
+            await server.serving
+        finally:
+            await server.shutdown()
+        return server
+    raise ValueError(f"Unknown communication type: {args.comm}")
+
+
+def app() -> None:
+    args = get_commandline()
+    global _logger
+    _logger = get_logger(args.log)
+    _logger.info(
+        f"Starting modsim v{__version__} at {get_utc_time().strftime('%Y-%m-%d %H:%M:%S')} UTC"
+    )
+
+    run_args = setup_server(args)
+    asyncio.run(_run_server_with_signals(run_args), debug=True)
+
+    _logger.info("exiting.")
+
+
+async def _run_server_with_signals(args: Any) -> None:
+    """Run the server and close its listener when the process is signaled."""
+    loop = asyncio.get_running_loop()
+    server_task = asyncio.create_task(run_async_server(args))
+    stop_requested = False
+
+    async def stop_server() -> None:
+        for _ in range(100):
+            if server_task.done():
+                return
+            try:
+                await ServerAsyncStop()
+                return
+            except (AttributeError, RuntimeError):
+                await asyncio.sleep(0.01)
+
+    def request_stop() -> None:
+        nonlocal stop_requested
+        if not stop_requested:
+            stop_requested = True
+            if args.comm in ("tcp", "udp", "tls"):
+                server_task.cancel()
+            else:
+                loop.create_task(stop_server())
+
+    installed_signals = []
+    for signum in (signal.SIGINT, signal.SIGTERM):
+        try:
+            loop.add_signal_handler(signum, request_stop)
+            installed_signals.append(signum)
+        except (NotImplementedError, RuntimeError):
+            pass
+
+    try:
+        await server_task
+    except asyncio.CancelledError:
+        if not stop_requested:
+            raise
+    finally:
+        for signum in installed_signals:
+            loop.remove_signal_handler(signum)
+        if not server_task.done():
+            server_task.cancel()
+            with suppress(asyncio.CancelledError):
+                await server_task
+
+
+if __name__ == "__main__":
+    app()

{modsim-0.5.2 → modsim-1.0.1}/modsim/utils.py

@@ -3,19 +3,13 @@
 import argparse
 import logging.config
 from datetime import datetime, timezone
-from typing import Any, Optional, Dict
-from pymodbus.transaction import (
-    ModbusAsciiFramer,
-    ModbusBinaryFramer,
-    ModbusRtuFramer,
-    ModbusSocketFramer,
-    ModbusTlsFramer,
+from typing import Any, Dict
+from pymodbus.framer import (
+    FramerType,
 )
 
 from . import __version__
 
-# global
-args: Optional[argparse.Namespace] = None
 config: Dict[str, Any] = {}
 
 
@@ -35,7 +29,7 @@ def get_parser() -> argparse.ArgumentParser:
     )
     parser.add_argument(
         "--framer",
-        choices=["ascii", "binary", "rtu", "socket", "tls"],
+        choices=["ascii", "rtu", "socket", "tls"],
         help="set framer, default depends on --comm",
         type=str,
     )
@@ -74,7 +68,25 @@ def get_parser() -> argparse.ArgumentParser:
 
 
 def get_commandline() -> argparse.Namespace:
-    args = get_parser().parse_args()
+    parser = get_parser()
+    args = parser.parse_args()
+
+    if args.store != "sequential":
+        parser.error("only --store sequential is supported")
+    if args.slaves != 0:
+        parser.error(
+            "--slaves is not supported; the default datastore is shared by all unit IDs"
+        )
+    if args.context is not None:
+        parser.error("--context is not supported from the command line")
+    allowed_framers = {
+        "tcp": {"socket"},
+        "udp": {"socket"},
+        "serial": {"rtu", "ascii"},
+        "tls": {"tls"},
+    }
+    if args.framer and args.framer not in allowed_framers[args.comm]:
+        parser.error("framer %s is not supported for %s" % (args.framer, args.comm))
 
     # set defaults
     comm_defaults: Dict[str, list] = {
@@ -84,26 +96,29 @@ def get_commandline() -> argparse.Namespace:
         "tls": ["tls", 5020],
     }
     framers: Dict[str, Any] = {
-        "ascii": ModbusAsciiFramer,
-        "binary": ModbusBinaryFramer,
-        "rtu": ModbusRtuFramer,
-        "socket": ModbusSocketFramer,
-        "tls": ModbusTlsFramer,
+        "ascii": FramerType.ASCII,
+        "rtu": FramerType.RTU,
+        "socket": FramerType.SOCKET,
+        "tls": FramerType.TLS,
     }
     args.framer = framers[args.framer or comm_defaults[args.comm][0]]
     args.port = args.port or comm_defaults[args.comm][1]
     if args.comm != "serial" and args.port:
-        args.port = int(args.port)
+        try:
+            args.port = int(args.port)
+        except ValueError:
+            parser.error("port must be an integer between 1 and 65535")
+        if not 1 <= args.port <= 65535:
+            parser.error("port must be an integer between 1 and 65535")
     return args
 
 
-def get_logger() -> logging.Logger:
+def get_logger(level: str = "info") -> logging.Logger:
     if config and config.get("logging"):
         logging.config.dictConfig(config["logging"])
     else:
-        print("no config file found, load default settings.")
         logging.basicConfig(
-            level=get_commandline().log.upper(),
+            level=level.upper(),
             format="%(asctime)s | %(levelname).1s | %(processName)s | %(name)s | %(message)s",
         )
     logger = logging.getLogger(__name__)

{modsim-0.5.2 → modsim-1.0.1}/pyproject.toml

@@ -1,16 +1,16 @@
 [tool.poetry]
 name = "modsim"
-version = "v0.5.2"
+version = "1.0.1"
 description = "A Simple Modbus TCP Device Simulator used for modpoll tool"
 authors = ["Ying Shaodong <helloysd@gmail.com>"]
-repository = "https://github.com/gavinying/modsim"
-documentation = "https://gavinying.github.io/modsim/"
+repository = "https://github.com/top-maker/modsim"
+documentation = "https://top-maker.github.io/modsim/"
 readme = "README.md"
 packages = [{ include = "modsim" }]
 
 [tool.poetry.dependencies]
-python = ">=3.8.2,<4.0"
-pymodbus = "~3.6.9"
+python = ">=3.10,<4.0"
+pymodbus = "~3.16.1"
 
 [tool.poetry.group.dev.dependencies]
 pre-commit = "^3.5.0"
@@ -23,6 +23,9 @@ tox = "^4.16.0"
 mkdocs = "^1.6.0"
 mkdocs-material = "^9.5.28"
 mkdocstrings = {extras = ["python"], version = "^0.25.1"}
+mkdocs-autorefs = ">=1.2,<1.4"
+markdown = ">=3.7,<3.8"
+pymdown-extensions = ">=10.11,<11"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]
@@ -40,6 +43,7 @@ show_error_codes = true
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+markers = ["integration: local protocol integration test"]
 
 [tool.poetry.scripts]
 modsim = "modsim.main:app"

modsim-0.5.2/modsim/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.5.2"

modsim-0.5.2/modsim/main.py

@@ -1,234 +0,0 @@
-#!/usr/bin/env python3
-"""Pymodbus asynchronous Server Example.
-An example of a multi threaded asynchronous server.
-usage: server_async.py [-h] [--comm {tcp,udp,serial,tls}]
-                       [--framer {ascii,binary,rtu,socket,tls}]
-                       [--log {critical,error,warning,info,debug}]
-                       [--port PORT] [--store {sequential,sparse,factory,none}]
-                       [--slaves SLAVES]
-Command line options for examples
-options:
-  -h, --help            show this help message and exit
-  --comm {tcp,udp,serial,tls}
-                        "serial", "tcp", "udp" or "tls"
-  --framer {ascii,binary,rtu,socket,tls}
-                        "ascii", "binary", "rtu", "socket" or "tls"
-  --log {critical,error,warning,info,debug}
-                        "critical", "error", "warning", "info" or "debug"
-  --port PORT           the port to use
-  --store {sequential,sparse,factory,none}
-                        "sequential", "sparse", "factory" or "none"
-  --slaves SLAVES       number of slaves to respond to
-The corresponding client can be started as:
-    python3 client_sync.py
-"""
-
-import os
-import asyncio
-from typing import Any
-
-from pymodbus.constants import Endian
-from pymodbus.datastore import (
-    ModbusSequentialDataBlock,
-    ModbusServerContext,
-    ModbusSlaveContext,
-)
-from pymodbus.device import ModbusDeviceIdentification
-from pymodbus.payload import BinaryPayloadBuilder
-from pymodbus.server import (
-    StartAsyncSerialServer,
-    StartAsyncTcpServer,
-    StartAsyncTlsServer,
-    StartAsyncUdpServer,
-)
-
-from . import __version__
-from .utils import get_commandline, get_utc_time, get_logger
-
-_logger = get_logger()
-
-
-def setup_server(args: Any) -> Any:
-    """Run server setup."""
-    # The datastores only respond to the addresses that are initialized
-    # If you initialize a DataBlock to addresses of 0x00 to 0xFF, a request to
-    # 0x100 will respond with an invalid address exception.
-    # This is because many devices exhibit this kind of behavior (but not all)
-    if not args.context:
-        _logger.info("Create datastore")
-        # ----------------------------------------------------------------------- #
-        # build your payload
-        # ----------------------------------------------------------------------- #
-        co_builder = BinaryPayloadBuilder(byteorder=Endian.BIG, wordorder=Endian.BIG)
-        # address=0, bytes=3
-        for i in range(3):
-            # The bits within each byte are big-endian
-            # The coils status (from the first position) = [1,0,1,0,0,0,0,1]
-            co_builder.add_bits([True, False, False, False, False, True, False, True])
-
-        hr_builder = BinaryPayloadBuilder(byteorder=Endian.BIG, wordorder=Endian.BIG)
-        # address=0, bytes=8
-        hr_builder.add_16bit_uint(1)
-        hr_builder.add_16bit_uint(2)
-        hr_builder.add_16bit_uint(3)
-        hr_builder.add_16bit_uint(4)
-        # address=8, bytes=8
-        hr_builder.add_16bit_int(-1)
-        hr_builder.add_16bit_int(-2)
-        hr_builder.add_16bit_int(-3)
-        hr_builder.add_16bit_int(-4)
-        # address=16, bytes=8
-        hr_builder.add_32bit_uint(12345678)
-        hr_builder.add_32bit_uint(12345678)
-        # address=24, bytes=8
-        hr_builder.add_32bit_int(-12345678)
-        hr_builder.add_32bit_int(-12345678)
-        # address=32, bytes=8
-        hr_builder.add_32bit_float(12.34)
-        hr_builder.add_32bit_float(-12.34)
-        # address=40, bytes=8
-        hr_builder.add_64bit_uint(12345678900)
-        # address=48, bytes=8
-        hr_builder.add_64bit_int(-12345678900)
-        # address=56, bytes=16
-        hr_builder.add_64bit_float(123.45)
-        hr_builder.add_64bit_float(-123.45)
-        # address=72, bytes=?
-        hr_builder.add_string("this is a string")
-
-        # ----------------------------------------------------------------------- #
-        # use that payload in the data store
-        # ----------------------------------------------------------------------- #
-        # Here we use the same reference block for each underlying store.
-        # ----------------------------------------------------------------------- #
-        co_values = co_builder.to_coils()
-        hr_values = hr_builder.to_registers()
-        store = ModbusSlaveContext(
-            co=ModbusSequentialDataBlock(0, co_values),
-            di=ModbusSequentialDataBlock(10000, co_values),
-            ir=ModbusSequentialDataBlock(30000, hr_values),
-            hr=ModbusSequentialDataBlock(40000, hr_values),
-            zero_mode=True,
-        )
-        args.context = ModbusServerContext(slaves=store, single=True)
-
-    # ----------------------------------------------------------------------- #
-    # initialize the server information
-    # ----------------------------------------------------------------------- #
-    # If you don't set this or any fields, they are defaulted to empty strings.
-    # ----------------------------------------------------------------------- #
-    args.identity = ModbusDeviceIdentification(
-        info_name={
-            "VendorName": "Pymodbus",
-            "ProductCode": "PM",
-            "VendorUrl": "https://github.com/riptideio/pymodbus/",
-            "ProductName": "Pymodbus Server",
-            "ModelName": "Pymodbus Server",
-        }
-    )
-    return args
-
-
-async def run_async_server(args: Any) -> Any:
-    """Run server."""
-    txt = f"Start ASYNC server, listening on {args.port} - {args.comm}"
-    _logger.info(txt)
-    if args.comm == "tcp":
-        address = ("", args.port) if args.port else None
-        server = await StartAsyncTcpServer(
-            context=args.context,  # Data storage
-            identity=args.identity,  # server identify
-            # TBD host=
-            # TBD port=
-            address=address,  # listen address
-            # custom_functions=[],  # allow custom handling
-            framer=args.framer,  # The framer strategy to use
-            # ignore_missing_slaves=True,  # ignore request to a missing slave
-            # broadcast_enable=False,  # treat slave_id 0 as broadcast address,
-            # timeout=1,  # waiting time for request to complete
-            # TBD strict=True,  # use strict timing, t1.5 for Modbus RTU
-        )
-    elif args.comm == "udp":
-        address = ("127.0.0.1", args.port) if args.port else None
-        server = await StartAsyncUdpServer(
-            context=args.context,  # Data storage
-            identity=args.identity,  # server identify
-            address=address,  # listen address
-            # custom_functions=[],  # allow custom handling
-            framer=args.framer,  # The framer strategy to use
-            # handler=None,  # handler for each session
-            # ignore_missing_slaves=True,  # ignore request to a missing slave
-            # broadcast_enable=False,  # treat unit_id 0 as broadcast address,
-            # timeout=1,  # waiting time for request to complete
-            # TBD strict=True,  # use strict timing, t1.5 for Modbus RTU
-            # defer_start=False,  # Only define server do not activate
-        )
-    elif args.comm == "serial":
-        # socat -d -d PTY,link=/tmp/ptyp0,raw,echo=0,ispeed=9600
-        #             PTY,link=/tmp/ttyp0,raw,echo=0,ospeed=9600
-        server = await StartAsyncSerialServer(
-            context=args.context,  # Data storage
-            identity=args.identity,  # server identify
-            # timeout=1,  # waiting time for request to complete
-            port=args.port,  # serial port
-            # custom_functions=[],  # allow custom handling
-            framer=args.framer,  # The framer strategy to use
-            # handler=None,  # handler for each session
-            # stopbits=1,  # The number of stop bits to use
-            # bytesize=8,  # The bytesize of the serial messages
-            # parity="N",  # Which kind of parity to use
-            # baudrate=9600,  # The baud rate to use for the serial device
-            # handle_local_echo=False,  # Handle local echo of the USB-to-RS485 adaptor
-            # ignore_missing_slaves=True,  # ignore request to a missing slave
-            # broadcast_enable=False,  # treat unit_id 0 as broadcast address,
-            # strict=True,  # use strict timing, t1.5 for Modbus RTU
-            # defer_start=False,  # Only define server do not activate
-        )
-    elif args.comm == "tls":
-        address = ("", args.port) if args.port else None
-        cwd = os.getcwd().split("/")[-1]
-        if cwd == "examples":
-            path = "."
-        elif cwd == "test":
-            path = "../examples"
-        else:
-            path = "examples"
-        server = await StartAsyncTlsServer(
-            context=args.context,  # Data storage
-            host="localhost",  # define tcp address where to connect to.
-            # port=port,  # on which port
-            identity=args.identity,  # server identify
-            # custom_functions=[],  # allow custom handling
-            address=address,  # listen address
-            framer=args.framer,  # The framer strategy to use
-            # handler=None,  # handler for each session
-            allow_reuse_address=True,  # allow the reuse of an address
-            # The cert file path for TLS (used if sslctx is None)
-            certfile=f"{path}/certificates/pymodbus.crt",
-            # sslctx=sslctx,  # The SSLContext to use for TLS (default None and auto create)
-            # The key file path for TLS (used if sslctx is None)
-            keyfile=f"{path}/certificates/pymodbus.key",
-            # password="none",  # The password for for decrypting the private key file
-            # reqclicert=False,  # Force the sever request client"s certificate
-            # ignore_missing_slaves=True,  # ignore request to a missing slave
-            # broadcast_enable=False,  # treat unit_id 0 as broadcast address,
-            # timeout=1,  # waiting time for request to complete
-            # TBD strict=True,  # use strict timing, t1.5 for Modbus RTU
-            defer_start=False,  # Only define server do not activate
-        )
-    return server
-
-
-def app() -> None:
-    _logger.info(
-        f"Starting modsim v{__version__} at {get_utc_time().strftime('%Y-%m-%d %H:%M:%S')} UTC"
-    )
-
-    run_args = setup_server(get_commandline())
-    asyncio.run(run_async_server(run_args), debug=True)
-
-    _logger.info("exiting.")
-
-
-if __name__ == "__main__":
-    app()