mbtoolcli 0.3.1__py3-none-any.whl

modbus_slave_sim/cli.py

@@ -0,0 +1,903 @@
+#!/usr/bin/env python3
+"""
+Modbus Tool - A comprehensive Modbus Master/Slave testing tool.
+
+A combined Modbus testing tool supporting both Master and Slave modes.
+Similar to modpoll + diagslave, this tool allows you to:
+- Act as a Master to read/write Modbus devices
+- Act as a Slave to simulate Modbus devices
+
+Usage:
+    mbtool [mode] [options]
+
+Examples:
+    # Master mode - read 10 holding registers
+    mbtool --master -a 1 -c 10 -r 0
+
+    # Slave mode - start TCP server
+    mbtool --slave -p 502
+
+    # Master mode - write float value
+    mbtool --master --write -t float -a 1 -r 0 -v 3.14
+"""
+
+import argparse
+import csv
+import logging
+import signal
+import sys
+import time
+from typing import Optional
+
+from pymodbus.framer import Framer  # noqa: F401 - used by rtu_server
+
+from . import __version__
+from .registers import ModbusRegisterMap
+from .simulation import SimulationEngine, SimulationType
+from .tcp_server import ModbusTCPServer
+from .rtu_server import ModbusSerialServer
+from .master import ModbusMaster
+from .datatypes import DataType, ByteOrder, parse_data_type, parse_byte_order, format_value
+from .colors import (
+    c, RST, BOLD, DIM, RED, RED_BOLD, GREEN, GREEN_BOLD,
+    YELLOW, YELLOW_BOLD, CYAN, CYAN_BOLD, MAGENTA, MAGENTA_BOLD, WHITE_BOLD,
+)
+
+
+def setup_logging(verbose: bool = False):
+    """Configure logging based on verbosity level."""
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+
+def enable_debug_frame():
+    """Enable raw Modbus frame logging via pymodbus debug loggers."""
+    for name in ["pymodbus", "pymodbus.client", "pymodbus.server",
+                  "pymodbus.transport", "pymodbus.framer", "pymodbus.logging"]:
+        logging.getLogger(name).setLevel(logging.DEBUG)
+    logging.getLogger("pymodbus").addHandler(logging.StreamHandler())
+    print(c("Raw frame debug logging enabled", DIM))
+
+
+def parse_alarm(expr: str) -> dict:
+    """Parse alarm expression like '0>100' or 'addr>threshold'."""
+    import re
+    m = re.match(r"(\d+)\s*(>|>=|<|<=|==|!=)\s*(-?\d+\.?\d*)", expr)
+    if not m:
+        print(c(f"Error: Invalid alarm expression '{expr}'. Format: ADDR>VALUE (e.g. 0>100)", RED_BOLD))
+        sys.exit(1)
+    addr = int(m.group(1))
+    op = m.group(2)
+    val_str = m.group(3)
+    return {"addr": addr, "op": op, "value": float(val_str) if "." in val_str else int(val_str)}
+
+
+def parse_args(args=None):
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Modbus Tool - A comprehensive Modbus Master/Slave testing tool",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=f"""
+{c('Usage Examples:', BOLD)}
+{c('─'*60, DIM)}
+
+  {c('SLAVE MODE', CYAN_BOLD)}
+    %(prog)s --slave                           Start TCP server on port 502
+    %(prog)s --slave -p 5020                   Start TCP on port 5020
+    %(prog)s --slave --simulate                Enable default simulation
+    %(prog)s --slave -m rtu -p COM3            Start RTU server on COM3
+    %(prog)s --slave -m ascii -p COM3           Start ASCII server on COM3
+    %(prog)s --slave --register-map dev.json    Load custom register map
+
+  {c('MASTER MODE - Read', CYAN_BOLD)}
+    %(prog)s --master -a 1 -r 0 -c 10          Read 10 holding registers (FC03)
+    %(prog)s --master -a 1 -r 0 -c 5 -t float  Read 5 float values (2 regs each)
+    %(prog)s --master -a 1 -r 0 -c 10 -t hex   Read in hex format
+    %(prog)s --master -f 1 -a 1 -r 0 -c 8     Read 8 coils (FC01)
+    %(prog)s --master -f 2 -a 1 -r 0 -c 8     Read 8 discrete inputs (FC02)
+    %(prog)s --master -f 4 -a 1 -r 0 -c 5     Read 5 input registers (FC04)
+
+  {c('MASTER MODE - Write', CYAN_BOLD)}
+    %(prog)s --master --write -a 1 -r 0 -v 100           Write 100 to register
+    %(prog)s --master --write -t float -a 1 -r 0 -v 3.14 Write float value
+    %(prog)s --master --write -a 0 -v "100,200,300"      Batch write 3 values
+    %(prog)s --master --write-coil -r 0 --coil-state 1   Write coil ON (FC05)
+
+  {c('MASTER MODE - Poll', CYAN_BOLD)}
+    %(prog)s --master --poll -a 1 -r 0 -c 5 -i 2         Poll every 2s
+    %(prog)s --master --poll -i 1 -n 10                  Poll 10 times then stop
+    %(prog)s --master --poll --alarm "0>100"              Alarm on threshold
+    %(prog)s --master --poll --output data.csv            Log results to CSV
+
+  {c('ADVANCED', CYAN_BOLD)}
+    %(prog)s --master -t float32 --byte-order CDBA        Use word-swap byte order
+    %(prog)s --master --debug-frame                       Show raw Modbus frames
+    %(prog)s --scan -H 192.168.1.100 -p 502              Scan slave IDs 1-247
+
+{c('Examples with output:', BOLD)}
+{c('─'*60, DIM)}
+
+  # Read 10 holding registers (simplest read command)
+  %(prog)s --master -a 1 -r 0 -c 10
+  Output:
+    Reading 10 register(s) from address 0...
+    Results (10 values):
+      [0] = 100
+      [1] = 200
+      ...
+
+  # Continuous monitor with CSV logging and alarm
+  %(prog)s --master --poll -a 1 -r 0 -c 5 -t int16 -i 1 --output log.csv --alarm "0>1000"
+  Output:
+    Polling register 0, count=5, type=int16
+    Interval: 1.0s, Iterations: infinite
+    Output: log.csv
+    Alarm: register[0] > 1000
+    Press Ctrl+C to stop
+
+    [1] 150   !!! ALARM: register[0] > 1000 (current: 150) !!!
+    [2] 45
+    ...
+
+{c('Function Codes:', BOLD)}
+  1  Read Coils              FC01   Read/write boolean coils
+  2  Read Discrete Inputs    FC02   Read-only boolean inputs
+  3  Read Holding Registers  FC03   Read/write 16-bit registers (default)
+  4  Read Input Registers    FC04   Read-only 16-bit registers
+
+{c('Data Types:', BOLD)}
+  int16    Signed 16-bit integer   1 register    Range: -32768 to 32767
+  uint16   Unsigned 16-bit integer 1 register    Range: 0 to 65535
+  int32    Signed 32-bit integer   2 registers   Range: -2^31 to 2^31-1
+  uint32   Unsigned 32-bit integer 2 registers   Range: 0 to 2^32-1
+  float    32-bit IEEE 754 float   2 registers   ~7 decimal digits precision
+  hex      Hexadecimal view        1+ registers  e.g. 0xABCD
+
+{c('Byte Order Options (for 32-bit types):', BOLD)}
+  ABCD    Big-Endian (standard)     Reg0=High, Reg1=Low
+  CDBA    Word swap (Siemens)       Reg0=Low, Reg1=High
+  BADC    Byte swap                 Bytes swapped within each register
+  DCBA    Little-Endian             Full little-endian
+
+{c('More info:', DIM)}
+  Documentation: https://github.com/yourusername/modbus-tool#readme
+  Report issues: https://github.com/yourusername/modbus-tool/issues
+""",
+    )
+
+    # ── Mode selection ──
+    mode_group = parser.add_mutually_exclusive_group()
+    mode_group.add_argument(
+        "--master",
+        action="store_true",
+        help="作为主站(客户端)读写从站设备",
+    )
+    mode_group.add_argument(
+        "--slave",
+        action="store_true",
+        help="作为从站(服务端)模拟一个 Modbus 设备",
+    )
+    mode_group.add_argument(
+        "--scan",
+        action="store_true",
+        help="扫描模式：探测 1-247 号从站 ID，发现网络中活动的设备",
+    )
+    mode_group.add_argument(
+        "--gui",
+        action="store_true",
+        help="启动 Web 图形界面(GUI)，在浏览器中操作所有功能",
+    )
+
+    # ── Connection options ──
+    conn = parser.add_argument_group("Connection Options (连接选项)")
+    conn.add_argument(
+        "-m", "--mode",
+        metavar="PROTOCOL",
+        choices=["tcp", "rtu", "ascii", "rtu-tcp", "ascii-tcp"],
+        default="tcp",
+        help="通信协议：tcp=Modbus TCP标准协议, rtu=串口RTU(需真实串口), ascii=串口ASCII(需真实串口),\n"
+             "                         rtu-tcp=RTU over TCP(虚拟串口, 无需物理串口),\n"
+             "                         ascii-tcp=ASCII over TCP(虚拟串口, 无需物理串口)  (默认: tcp)",
+    )
+    conn.add_argument(
+        "-H", "--host",
+        metavar="IP",
+        default="127.0.0.1",
+        help="TCP 模式下目标主机的 IP 地址  (默认: 127.0.0.1)",
+    )
+    conn.add_argument(
+        "-p", "--port",
+        metavar="PORT/PATH",
+        type=str,
+        default="502",
+        help="TCP 端口号(如 502) 或串口设备路径(如 COM3, /dev/ttyUSB0)。\n"
+             "                          TCP 模式填端口号，RTU/ASCII 模式填串口路径  (默认: 502)",
+    )
+    conn.add_argument(
+        "-a", "--slave-id",
+        metavar="ID",
+        type=str,
+        default="1",
+        help="从站设备 ID 号(1-247)。单个: 1, 多个逗号分隔: 1,2,3  (默认: 1)",
+    )
+    conn.add_argument(
+        "--timeout",
+        metavar="SEC",
+        type=float,
+        default=3.0,
+        help="等待从站响应的超时时长(秒)，超时视为通信失败  (默认: 3.0)",
+    )
+
+    # ── Serial options ──
+    serial = parser.add_argument_group("Serial Port Options (串口参数, RTU/ASCII 模式)")
+    serial.add_argument(
+        "-b", "--baudrate",
+        metavar="RATE",
+        type=int,
+        default=9600,
+        help="串口波特率：300, 600, 1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200  (默认: 9600)",
+    )
+    serial.add_argument(
+        "--parity",
+        metavar="P",
+        choices=["N", "E", "O"],
+        default="N",
+        help="串口校验位：N=无校验, E=偶校验, O=奇校验  (默认: N)",
+    )
+    serial.add_argument(
+        "--stopbits",
+        metavar="BITS",
+        type=int,
+        choices=[1, 2],
+        default=1,
+        help="停止位个数：1 或 2  (默认: 1)",
+    )
+    serial.add_argument(
+        "--bytesize",
+        metavar="BITS",
+        type=int,
+        choices=[7, 8],
+        default=8,
+        help="每字节数据位：7 或 8  (默认: 8)",
+    )
+    serial.add_argument(
+        "--inter-char-delay",
+        metavar="SEC",
+        type=float,
+        default=None,
+        help="RTU 模式下字符间额外延迟(秒)，用于解决部分设备的通信时序问题",
+    )
+
+    # ── Master read options ──
+    rd = parser.add_argument_group("Master Read Options (主站读取参数)")
+    rd.add_argument(
+        "-r", "--register",
+        metavar="ADDR",
+        type=int,
+        default=0,
+        help="要读取的起始寄存器/线圈地址编号  (默认: 0)",
+    )
+    rd.add_argument(
+        "-c", "--count",
+        metavar="N",
+        type=int,
+        default=1,
+        help="连续读取的寄存器/线圈/离散输入的数量  (默认: 1)",
+    )
+    rd.add_argument(
+        "-t", "--data-type",
+        metavar="TYPE",
+        type=str,
+        default="int16",
+        help="寄存器数值的解释格式：int16, uint16, int32, uint32, float, hex\n"
+             "                         int16=有符号16位整数, uint16=无符号16位整数,\n"
+             "                         int32=有符号32位(占2寄存器), float=32位浮点数(占2寄存器),\n"
+             "                         hex=十六进制显示  (默认: int16)",
+    )
+    rd.add_argument(
+        "-f", "--function-code",
+        metavar="FC",
+        type=int,
+        choices=[1, 2, 3, 4],
+        default=3,
+        help="Modbus 功能码：\n"
+             "                         1=读线圈(FC01, 布尔值, 可读写)\n"
+             "                         2=读离散输入(FC02, 布尔值, 只读)\n"
+             "                         3=读保持寄存器(FC03, 16位值, 可读写) ←默认\n"
+             "                         4=读输入寄存器(FC04, 16位值, 只读)",
+    )
+    rd.add_argument(
+        "--hex",
+        action="store_true",
+        help="同时以十六进制(0xABCD)格式显示数值",
+    )
+    rd.add_argument(
+        "--byte-order",
+        metavar="ORDER",
+        type=str,
+        default="ABCD",
+        help="32位数据(int32/uint32/float)的字节排列顺序：\n"
+             "                         ABCD=标准大端序(寄存器0=高16位, 1=低16位)\n"
+             "                         CDBA=西门子字交换(寄存器0=低16位, 1=高16位)\n"
+             "                         BADC=字节交换\n"
+             "                         DCBA=小端序(完整小端)  (默认: ABCD)",
+    )
+
+    # ── Master write options ──
+    wr = parser.add_argument_group("Master Write Options (主站写入参数)")
+    wr.add_argument(
+        "--write",
+        action="store_true",
+        help="写入寄存器模式，配合 --value 指定要写入的值。\n"
+             "                         示例：--write -r 0 --value 100  写入单值\n"
+             "                         示例：--write -r 0 --value \"100,200,300\"  批量写入",
+    )
+    wr.add_argument(
+        "--write-coil",
+        action="store_true",
+        help="写入线圈模式(FC05)，配合 --coil-state 指定 ON/OFF",
+    )
+    wr.add_argument(
+        "--coil-state",
+        metavar="0/1",
+        type=int,
+        choices=[0, 1],
+        default=1,
+        help="线圈目标状态：0=断开(OFF), 1=闭合(ON)  (默认: 1)",
+    )
+    wr.add_argument(
+        "--value",
+        "-v",
+        metavar="VAL",
+        type=str,
+        help="要写入的值：\n"
+             "                         单个值如 \"100\" 或 \"3.14\"\n"
+             "                         批量值用逗号分隔如 \"100,200,300\" 会依次写入连续地址",
+    )
+
+    # ── Poll options ──
+    pl = parser.add_argument_group("Polling Options (轮询参数)")
+    pl.add_argument(
+        "--poll", "--continuous",
+        action="store_true",
+        help="连续轮询模式：按固定间隔反复读取寄存器值，按 Ctrl+C 停止",
+    )
+    pl.add_argument(
+        "-i", "--interval",
+        metavar="SEC",
+        type=float,
+        default=1.0,
+        help="轮询的时间间隔(秒)。设为 0.5 表示每秒读 2 次  (默认: 1.0)",
+    )
+    pl.add_argument(
+        "-n", "--iterations",
+        metavar="N",
+        type=int,
+        default=0,
+        help="轮询总次数，达到后自动停止。0 表示无限轮询直到 Ctrl+C  (默认: 0)",
+    )
+    pl.add_argument(
+        "--alarm",
+        metavar="EXPR",
+        type=str,
+        default=None,
+        help="数值越限告警。格式：寄存器号>阈值（如 0>1000 表示寄存器0超过1000时告警）\n"
+             "                         支持的运算符: >, <, >=, <=, ==, !=\n"
+             "                         示例: '0>100'  '2<=50'  '1==0'",
+    )
+    pl.add_argument(
+        "--output", "-o",
+        metavar="FILE",
+        type=str,
+        default=None,
+        help="将轮询或读取结果导出到 CSV 文件，方便后用 Excel 分析",
+    )
+
+    # ── Slave options ──
+    sv = parser.add_argument_group("Slave Server Options (从站服务器参数)")
+    sv.add_argument(
+        "--register-map",
+        metavar="FILE.json",
+        type=str,
+        default=None,
+        help="从 JSON 文件加载自定义寄存器表，代替默认的寄存器映射。\n"
+             "                         文件格式见 README.md 中的 JSON 示例",
+    )
+    sv.add_argument(
+        "--simulate",
+        action="store_true",
+        help="启动动态数值模拟(正弦波、计数器、线性斜坡等)，让从站数据不断变化",
+    )
+    sv.add_argument(
+        "--sim-interval",
+        metavar="SEC",
+        type=float,
+        default=0.1,
+        help="模拟值的更新间隔(秒)，越小变化越平滑  (默认: 0.1)",
+    )
+    sv.add_argument(
+        "--status",
+        action="store_true",
+        help="查看当前所有寄存器的数值和状态，查看后立即退出",
+    )
+
+    # ── Display options ──
+    disp = parser.add_argument_group("Display / Debug Options (显示与调试)")
+    disp.add_argument(
+        "--gui-port",
+        type=int,
+        default=8080,
+        help="Web GUI 的端口号  (默认: 8080)",
+    )
+    disp.add_argument(
+        "-V", "--verbose",
+        action="store_true",
+        help="显示详细的调试日志信息",
+    )
+    disp.add_argument(
+        "--debug-frame",
+        action="store_true",
+        help="启用 Modbus 协议原始帧日志，显示收发的十六进制报文",
+    )
+    disp.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+
+    # RTU port as positional argument (hidden, for backward compatibility)
+    parser.add_argument(
+        "port_positional",
+        nargs="?",
+        default=None,
+        help=argparse.SUPPRESS,
+    )
+
+    return parser.parse_args(args)
+
+
+def resolve_port(args):
+    """Resolve port argument."""
+    port = args.port
+    is_serial = args.mode in ("rtu", "ascii")
+    if args.port_positional is not None:
+        try:
+            port = int(args.port_positional)
+        except ValueError:
+            if is_serial:
+                port = args.port_positional
+    else:
+        try:
+            port = int(args.port)
+        except ValueError:
+            if is_serial:
+                pass  # serial port path
+            else:
+                port = 502  # fallback for TCP
+    return port
+
+
+def parse_slave_ids(raw: str) -> list[int]:
+    """Parse slave ID string. Returns list of ints."""
+    raw = raw.strip()
+    if "," in raw:
+        return [int(x.strip()) for x in raw.split(",")]
+    return [int(raw)]
+
+
+def run_scan_mode(args):
+    """Run the tool in Scan mode."""
+    port = resolve_port(args)
+
+    master = ModbusMaster(
+        host=args.host,
+        port=int(port) if isinstance(port, (int, str)) and str(port).isdigit() else 502,
+        mode=args.mode,
+        slave_id=1,
+        timeout=args.timeout,
+        baudrate=args.baudrate,
+        parity=args.parity,
+        stopbits=args.stopbits,
+        bytesize=args.bytesize,
+    )
+
+    addr_str = f"{args.mode.upper()} {args.host}:{port}"
+    print(f"\n{c('Scanning', YELLOW)} {c(addr_str, CYAN_BOLD)} {c('for active slave devices...', YELLOW)}")
+
+    if args.mode == "tcp":
+        port_num = int(port)
+        print(f"  {c('Range:', DIM)} Slave ID 1-247")
+        print(f"  {c('Target:', DIM)} {args.host}:{port_num}")
+    else:
+        print(f"  {c('Range:', DIM)} Slave ID 1-247")
+        print(f"  {c('Target:', DIM)} {port}")
+
+    if not master.connect():
+        print(c("Failed to connect!", RED_BOLD))
+        sys.exit(1)
+
+    print()
+    found = master.scan_slaves(start=1, end=247, timeout_per=min(args.timeout, 0.5))
+    master.disconnect()
+
+    print()
+    if found:
+        print(f"  {c('Found', GREEN_BOLD)} {c(str(len(found)), CYAN_BOLD)} {c('active slave(s):', GREEN)} {c(', '.join(str(s) for s in found), CYAN_BOLD)}")
+    else:
+        print(f"  {c('No active slaves found.', YELLOW)}")
+
+
+def run_master_mode(args):
+    """Run the tool in Master mode."""
+    logger = logging.getLogger(__name__)
+    byte_order = parse_byte_order(args.byte_order)
+
+    # Handle port argument compatibility
+    port = resolve_port(args)
+
+    # Create master client
+    master = ModbusMaster(
+        host=args.host,
+        port=int(port) if isinstance(port, (int, str)) and str(port).isdigit() else port,
+        mode=args.mode,
+        slave_id=parse_slave_ids(args.slave_id)[0],
+        timeout=args.timeout,
+        baudrate=args.baudrate,
+        parity=args.parity,
+        stopbits=args.stopbits,
+        bytesize=args.bytesize,
+    )
+
+    # Connect
+    addr_str = f"{args.mode.upper()} {args.host}:{port}"
+    print(f"\n{c('Connecting to', YELLOW)} {c(addr_str, CYAN_BOLD)}...")
+    if not master.connect():
+        print(c("Failed to connect!", RED_BOLD))
+        sys.exit(1)
+
+    print(f"{c('Connected!', GREEN_BOLD)}\n")
+
+    try:
+        # Parse data type
+        data_type = parse_data_type(args.data_type)
+
+        if args.write_coil:
+            # Write coil mode
+            if args.register is None:
+                print(c("Error: -r/--register is required for coil write", RED_BOLD))
+                sys.exit(1)
+            value = bool(args.coil_state)
+            print(f"{c('Writing coil', YELLOW)} {c(str(args.register), CYAN_BOLD)} {c('=', YELLOW)} {c(str(value), CYAN_BOLD)}...")
+            success = master.write_single_coil(args.register, value)
+            if success:
+                print(c("Coil write successful!", GREEN_BOLD))
+            else:
+                print(c("Coil write failed!", RED_BOLD))
+                sys.exit(1)
+
+        elif args.write:
+            # Write mode
+            if args.value is None:
+                print(c("Error: --value is required for write operations", RED_BOLD))
+                sys.exit(1)
+
+            # Support batch write: comma-separated values
+            raw_values = [v.strip() for v in args.value.split(",")]
+            batch_mode = len(raw_values) > 1
+
+            parsed_values = []
+            for raw_val in raw_values:
+                try:
+                    if data_type in (DataType.FLOAT32,):
+                        parsed_values.append(float(raw_val))
+                    else:
+                        parsed_values.append(int(raw_val))
+                except ValueError:
+                    print(f"{c('Error:', RED_BOLD)} {c(f'Invalid value \'{raw_val}\' for type {args.data_type}', RED)}")
+                    sys.exit(1)
+
+            if batch_mode:
+                # Write multiple registers in sequence
+                print(f"{c('Batch writing', YELLOW)} {c(str(len(parsed_values)), CYAN_BOLD)} {c('value(s) starting at register', YELLOW)} {c(str(args.register), CYAN_BOLD)}...")
+                all_ok = True
+                for i, val in enumerate(parsed_values):
+                    regs_per = DATA_TYPE_REGISTERS.get(data_type, 1)
+                    ok = master.write_converted(args.register + i * regs_per, val, data_type, byte_order=byte_order)
+                    if ok:
+                        print(f"  [{c(str(i), MAGENTA)}] = {c(str(val), CYAN_BOLD)} {c('OK', GREEN_BOLD)}")
+                    else:
+                        print(f"  [{c(str(i), MAGENTA)}] = {c(str(val), CYAN_BOLD)} {c('FAILED', RED_BOLD)}")
+                        all_ok = False
+                if all_ok:
+                    print(c("Batch write successful!", GREEN_BOLD))
+                else:
+                    print(c("Some writes failed!", RED_BOLD))
+                    sys.exit(1)
+            else:
+                # Single value write
+                value = parsed_values[0]
+                print(f"{c('Writing', YELLOW)} {c(str(value), CYAN_BOLD)} {c('to register', YELLOW)} {c(str(args.register), CYAN_BOLD)}...")
+                success = master.write_converted(args.register, value, data_type, byte_order=byte_order)
+                if success:
+                    print(c("Write successful!", GREEN_BOLD))
+                else:
+                    print(c("Write failed!", RED_BOLD))
+                    sys.exit(1)
+
+        elif args.poll:
+            # Polling mode
+            print(f"{c('Polling register', YELLOW)} {c(str(args.register), CYAN_BOLD)}, "
+                  f"{c('count', YELLOW)}={c(str(args.count), CYAN_BOLD)}, "
+                  f"{c('type', YELLOW)}={c(args.data_type, CYAN_BOLD)}")
+            print(f"{c('Interval', YELLOW)}: {c(f'{args.interval}s', CYAN_BOLD)}, "
+                  f"{c('Iterations', YELLOW)}: {c(str(args.iterations or 'infinite'), CYAN_BOLD)}")
+            if byte_order != ByteOrder.ABCD:
+                print(f"{c('Byte Order', YELLOW)}: {c(byte_order.value, CYAN_BOLD)}")
+            if args.output:
+                print(f"{c('Output', YELLOW)}: {c(args.output, CYAN_BOLD)}")
+            print(f"{c('Press Ctrl+C to stop', DIM)}\n")
+
+            # Parse alarm if specified
+            alarm = None
+            if args.alarm:
+                alarm = parse_alarm(args.alarm)
+                print(f"  {c('Alarm:', YELLOW)} register[{alarm['addr']}] {alarm['op']} {alarm['value']}\n")
+
+            from .datatypes import DATA_TYPE_REGISTERS
+            master.poll(
+                address=args.register,
+                count=args.count,
+                data_type=data_type,
+                function_code=args.function_code,
+                interval=args.interval,
+                iterations=args.iterations,
+                hex_format=args.hex,
+                byte_order=byte_order,
+                alarm=alarm,
+                output_file=args.output,
+            )
+
+        else:
+            # Read mode
+            print(f"{c('Reading', YELLOW)} {c(str(args.count), CYAN_BOLD)} {c('register(s) from address', YELLOW)} {c(str(args.register), CYAN_BOLD)}...")
+
+            value = master.read_and_convert(
+                address=args.register,
+                count=args.count,
+                data_type=data_type,
+                function_code=args.function_code,
+                byte_order=byte_order,
+            )
+
+            if value is not None:
+                # Export to CSV if requested
+                if args.output:
+                    with open(args.output, "w", newline="") as f:
+                        writer = csv.writer(f)
+                        writer.writerow(["address", "value"])
+                        if isinstance(value, list):
+                            for i, v in enumerate(value):
+                                writer.writerow([args.register + i, v])
+                        else:
+                            writer.writerow([args.register, value])
+                    print(f"\n{c('Results exported to', DIM)} {c(args.output, CYAN_BOLD)}")
+
+                if isinstance(value, list):
+                    print(f"\n{c(f'Results ({len(value)} values):', BOLD)}")
+                    for i, v in enumerate(value):
+                        formatted = format_value(v, data_type, args.hex)
+                        print(f"  [{c(str(args.register + i), MAGENTA)}] = {c(formatted, CYAN_BOLD)}")
+                else:
+                    formatted = format_value(value, data_type, args.hex)
+                    print(f"\n{c('Result:', BOLD)} {c(formatted, CYAN_BOLD)}")
+            else:
+                print(f"\n{c('Read failed!', RED_BOLD)}")
+                sys.exit(1)
+
+    finally:
+        master.disconnect()
+
+
+def run_slave_mode(args):
+    """Run the tool in Slave mode."""
+    logger = logging.getLogger(__name__)
+
+    # Handle port argument compatibility
+    port = resolve_port(args)
+
+    # Create register map
+    if args.register_map:
+        try:
+            register_map = ModbusRegisterMap.load_from_json(args.register_map)
+            print(f"{c('Loaded register map from', DIM)} {c(args.register_map, CYAN_BOLD)}")
+        except Exception as e:
+            print(f"{c('Error loading register map:', RED_BOLD)} {c(str(e), RED)}")
+            sys.exit(1)
+    else:
+        register_map = ModbusRegisterMap()
+        register_map.create_default_map()
+
+    # Show status and exit
+    if args.status:
+        register_map.print_status()
+        sys.exit(0)
+
+    # Create and start server
+    server = None
+    simulation_engine = None
+
+    try:
+        if args.mode == "tcp":
+            server = ModbusTCPServer(
+                register_map=register_map,
+                host=args.host,
+                port=int(port),
+                slave_id=parse_slave_ids(args.slave_id)[0],
+            )
+            logger.info(f"Starting Modbus TCP server on {args.host}:{port}")
+        elif args.mode == "rtu-tcp":
+            server = ModbusTCPServer(
+                register_map=register_map,
+                host=args.host,
+                port=int(port),
+                slave_id=parse_slave_ids(args.slave_id)[0],
+                framer="rtu-tcp",
+            )
+            logger.info(f"Starting Modbus RTU over TCP server on {args.host}:{port}")
+        elif args.mode == "ascii-tcp":
+            server = ModbusTCPServer(
+                register_map=register_map,
+                host=args.host,
+                port=int(port),
+                slave_id=parse_slave_ids(args.slave_id)[0],
+                framer="ascii-tcp",
+            )
+            logger.info(f"Starting Modbus ASCII over TCP server on {args.host}:{port}")
+        else:
+            framer = "rtu" if args.mode == "rtu" else "ascii"
+            protocol_name = "ASCII" if args.mode == "ascii" else "RTU"
+            server = ModbusSerialServer(
+                register_map=register_map,
+                port=str(port),
+                baudrate=args.baudrate,
+                parity=args.parity,
+                stopbits=args.stopbits,
+                bytesize=args.bytesize,
+                timeout=args.timeout,
+                slave_id=parse_slave_ids(args.slave_id)[0],
+                framer=framer,
+                inter_char_delay=args.inter_char_delay,
+            )
+            logger.info(f"Starting Modbus {protocol_name} server on {port}")
+
+        # Setup simulation if requested
+        if args.simulate:
+            simulation_engine = SimulationEngine(register_map)
+            simulation_engine.interval = args.sim_interval
+            simulation_engine.setup_default_simulations()
+            logger.info("Simulation enabled with default patterns")
+
+        # Start the server
+        server.start()
+
+        # Start simulation engine if enabled
+        if simulation_engine:
+            simulation_engine.start()
+
+        # Print status
+        sim_label = c("Enabled", GREEN_BOLD) if args.simulate else c("Disabled", DIM)
+
+        # Determine protocol display name
+        proto_display = {
+            "tcp": "TCP",
+            "rtu": "RTU (Serial)",
+            "ascii": "ASCII (Serial)",
+            "rtu-tcp": "RTU over TCP",
+            "ascii-tcp": "ASCII over TCP",
+        }.get(args.mode, args.mode.upper())
+
+        is_real_serial = args.mode in ("rtu", "ascii")
+        is_tcp_mode = args.mode in ("tcp", "rtu-tcp", "ascii-tcp")
+
+        print(f"\n{c('='*60, DIM)}")
+        print(f"{c('Modbus Slave Server Status:', CYAN_BOLD)}")
+        print(f"  {c('Protocol:', WHITE_BOLD)}  {c(proto_display, YELLOW_BOLD)}")
+        if is_tcp_mode:
+            print(f"  {c('Address:', WHITE_BOLD)}   {c(f'{args.host}:{port}', YELLOW_BOLD)}")
+        else:
+            print(f"  {c('Port:', WHITE_BOLD)}      {c(str(port), YELLOW_BOLD)}")
+            print(f"  {c('Baudrate:', WHITE_BOLD)}  {c(str(args.baudrate), YELLOW_BOLD)}")
+            print(f"  {c('Parity:', WHITE_BOLD)}    {c(args.parity, YELLOW_BOLD)}")
+            print(f"  {c('Stopbits:', WHITE_BOLD)}  {c(str(args.stopbits), YELLOW_BOLD)}")
+        print(f"  {c('Slave ID:', WHITE_BOLD)}  {c(args.slave_id, YELLOW_BOLD)}")
+        if args.register_map:
+            print(f"  {c('Reg Map:', WHITE_BOLD)}  {c(args.register_map, YELLOW_BOLD)}")
+        print(f"  {c('Simulation:', WHITE_BOLD)} {sim_label}")
+        print(f"{c('='*60, DIM)}\n")
+
+        print(f"{c('Server is running.', GREEN_BOLD)} {c('Press Ctrl+C to stop.', DIM)}\n")
+
+        # Setup signal handlers
+        def signal_handler(signum, frame):
+            print(f"\n\n{c('Shutting down server...', YELLOW_BOLD)}")
+            raise KeyboardInterrupt
+
+        signal.signal(signal.SIGINT, signal_handler)
+        signal.signal(signal.SIGTERM, signal_handler)
+
+        # Keep running until interrupted
+        import math
+        _start = time.time()
+        while True:
+            if simulation_engine and simulation_engine.is_running():
+                elapsed = time.time() - _start
+                # Holding registers 0-1: Lasheng encoder (sine wave)
+                enc_val = int(500000 + 300000 * math.sin(2 * math.pi * 0.05 * elapsed))
+                server.set_registers(0x03, 0, [(enc_val >> 16) & 0xFFFF, enc_val & 0xFFFF])
+                # Input registers 0-1: LingGuang distance (sine wave)
+                dist_val = int(150000000 + 100000000 * math.sin(2 * math.pi * 0.03 * elapsed))
+                server.set_registers(0x04, 0, [(dist_val >> 16) & 0xFFFF, dist_val & 0xFFFF])
+                # Holding registers 61-63: Qingjiao Roll/Pitch/Yaw
+                roll_val = int(3000 * math.sin(2 * math.pi * 0.02 * elapsed))
+                pitch_val = int(2000 * math.sin(2 * math.pi * 0.025 * elapsed + 1))
+                yaw_val = int(1000 * math.sin(2 * math.pi * 0.015 * elapsed + 2))
+                server.set_registers(0x03, 61, [roll_val & 0xFFFF, pitch_val & 0xFFFF, yaw_val & 0xFFFF])
+            time.sleep(0.2)
+
+    except KeyboardInterrupt:
+        print(f"\n\n{c('Stopping server...', YELLOW_BOLD)}")
+    except Exception as e:
+        logger.error(f"Server error: {e}")
+        sys.exit(1)
+    finally:
+        # Cleanup
+        if simulation_engine:
+            simulation_engine.stop()
+        if server:
+            server.stop()
+        print(c("Server stopped.", DIM))
+
+
+def main(args=None):
+    """Main entry point for the Modbus Tool."""
+    parsed = parse_args(args)
+    setup_logging(parsed.verbose)
+
+    # Launch Web GUI mode
+    if parsed.gui:
+        from .gui_server import run_gui
+        run_gui(host="127.0.0.1", port=parsed.gui_port)
+        return
+
+    if not (parsed.scan or parsed.master or parsed.slave):
+        print(c("Error: 请指定运行模式 --master, --slave, --scan 或 --gui", RED_BOLD))
+        print(c("提示：运行 --help 查看帮助", DIM))
+        sys.exit(1)
+
+    # Enable debug frame logging if requested
+    if parsed.debug_frame:
+        enable_debug_frame()
+
+    # Print banner
+    ver = f"v{__version__}"
+    print(f"""
+{c('╔══════════════════════════════════════════════════════════════╗', CYAN_BOLD)}
+{c('║', CYAN_BOLD)}               {c(f'Modbus Tool {ver}', GREEN_BOLD)}{c(f'{" "*(25-len(ver))}║', CYAN_BOLD)}
+{c('║', CYAN_BOLD)}          {c('Master + Slave Testing Tool Combined', YELLOW_BOLD)}{c('         ║', CYAN_BOLD)}
+{c('╚══════════════════════════════════════════════════════════════╝', CYAN_BOLD)}
+    """)
+
+    if parsed.scan:
+        run_scan_mode(parsed)
+    elif parsed.master:
+        run_master_mode(parsed)
+    else:
+        run_slave_mode(parsed)
+
+
+if __name__ == "__main__":
+    main()