mbtoolcli 0.3.1__py3-none-any.whl

modbus_slave_sim/colors.py

@@ -0,0 +1,57 @@
+"""
+ANSI color utilities for terminal output.
+
+Automatically disables colors when output is not a TTY (e.g., piped output).
+"""
+
+import sys
+import os
+
+
+def _supports_color() -> bool:
+    """Check if the terminal supports ANSI colors."""
+    if os.getenv("NO_COLOR") or os.getenv("ANSI_COLORS_DISABLED"):
+        return False
+    if not hasattr(sys.stdout, "isatty") or not sys.stdout.isatty():
+        return False
+    if sys.platform == "win32":
+        # Enable ANSI on Windows 10+
+        try:
+            import ctypes
+            kernel32 = ctypes.windll.kernel32
+            kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
+        except Exception:
+            return False
+    return True
+
+
+_ENABLED = _supports_color()
+
+# Reset
+RST = "\033[0m" if _ENABLED else ""
+
+# Regular colors
+RED = "\033[31m" if _ENABLED else ""
+GREEN = "\033[32m" if _ENABLED else ""
+YELLOW = "\033[33m" if _ENABLED else ""
+BLUE = "\033[34m" if _ENABLED else ""
+MAGENTA = "\033[35m" if _ENABLED else ""
+CYAN = "\033[36m" if _ENABLED else ""
+WHITE = "\033[37m" if _ENABLED else ""
+DIM = "\033[2m" if _ENABLED else ""
+
+# Bold
+BOLD = "\033[1m" if _ENABLED else ""
+RED_BOLD = "\033[1;31m" if _ENABLED else ""
+GREEN_BOLD = "\033[1;32m" if _ENABLED else ""
+YELLOW_BOLD = "\033[1;33m" if _ENABLED else ""
+CYAN_BOLD = "\033[1;36m" if _ENABLED else ""
+MAGENTA_BOLD = "\033[1;35m" if _ENABLED else ""
+WHITE_BOLD = "\033[1;37m" if _ENABLED else ""
+
+
+def c(text: str, color: str) -> str:
+    """Wrap text with color and reset."""
+    if not _ENABLED or not color:
+        return text
+    return f"{color}{text}{RST}"

modbus_slave_sim/datatypes.py

@@ -0,0 +1,386 @@
+"""
+Data type conversion utilities for Modbus register values.
+
+Supports common data types used in industrial automation:
+- int16/uint16: 16-bit integer (1 register)
+- int32/uint32: 32-bit integer (2 registers)
+- float32: 32-bit IEEE 754 float (2 registers)
+- hex: Hexadecimal display
+
+Supports byte order variants for 32-bit types:
+- ABCD: Big-Endian (standard, default)
+- CDBA: Word swap (common in Siemens)
+- BADC: Byte swap
+- DCBA: Little-Endian
+"""
+
+import struct
+from enum import Enum
+from typing import List, Optional, Tuple, Union
+
+
+class DataType(Enum):
+    """Supported data types for Modbus registers."""
+    INT16 = "int16"
+    UINT16 = "uint16"
+    INT32 = "int32"
+    UINT32 = "uint32"
+    FLOAT32 = "float"
+    HEX = "hex"
+
+
+class ByteOrder(Enum):
+    """Byte order for multi-register (32-bit) values.
+    
+    ABCD = standard Big-Endian (register0=high, register1=low)
+    CDBA = word swap (register0=low, register1=high)
+    BADC = byte swap within words
+    DCBA = full Little-Endian
+    """
+    ABCD = "ABCD"
+    CDBA = "CDBA"
+    BADC = "BADC"
+    DCBA = "DCBA"
+
+
+DEFAULT_BYTE_ORDER = ByteOrder.ABCD
+
+
+def parse_byte_order(order_str: str) -> ByteOrder:
+    """Parse byte order string to ByteOrder enum."""
+    order_str = order_str.upper().strip()
+    mapping = {
+        "ABCD": ByteOrder.ABCD,
+        "BE": ByteOrder.ABCD,
+        "BIGENDIAN": ByteOrder.ABCD,
+        "CDBA": ByteOrder.CDBA,
+        "WORDSWAP": ByteOrder.CDBA,
+        "BADC": ByteOrder.BADC,
+        "BYTESWAP": ByteOrder.BADC,
+        "DCBA": ByteOrder.DCBA,
+        "LE": ByteOrder.DCBA,
+        "LITTLEENDIAN": ByteOrder.DCBA,
+    }
+    if order_str in mapping:
+        return mapping[order_str]
+    raise ValueError(f"Unknown byte order: {order_str}. Supported: {list(mapping.keys())}")
+
+
+def _swap_bytes(val: int) -> int:
+    """Swap bytes within a 16-bit value: 0xABCD -> 0xCDAB."""
+    return ((val & 0xFF) << 8) | ((val >> 8) & 0xFF)
+
+
+def _reorder_registers(registers: List[int], order: ByteOrder) -> Tuple[int, int]:
+    """Reorder 2 registers according to byte order, return (high_word, low_word)."""
+    r0 = registers[0] & 0xFFFF
+    r1 = registers[1] & 0xFFFF
+    if order == ByteOrder.ABCD:
+        return r0, r1
+    elif order == ByteOrder.CDBA:
+        return r1, r0
+    elif order == ByteOrder.BADC:
+        return _swap_bytes(r0), _swap_bytes(r1)
+    elif order == ByteOrder.DCBA:
+        return _swap_bytes(r1), _swap_bytes(r0)
+    return r0, r1
+
+
+def _reorder_to_registers(high: int, low: int, order: ByteOrder) -> List[int]:
+    """Convert (high_word, low_word) to register list according to byte order."""
+    if order == ByteOrder.ABCD:
+        return [high, low]
+    elif order == ByteOrder.CDBA:
+        return [low, high]
+    elif order == ByteOrder.BADC:
+        return [_swap_bytes(high), _swap_bytes(low)]
+    elif order == ByteOrder.DCBA:
+        return [_swap_bytes(low), _swap_bytes(high)]
+    return [high, low]
+
+
+# Register count needed for each data type
+DATA_TYPE_REGISTERS = {
+    DataType.INT16: 1,
+    DataType.UINT16: 1,
+    DataType.INT32: 2,
+    DataType.UINT32: 2,
+    DataType.FLOAT32: 2,
+    DataType.HEX: 1,
+}
+
+
+def parse_data_type(type_str: str) -> DataType:
+    """
+    Parse data type string to DataType enum.
+
+    Args:
+        type_str: Type string (e.g., "int16", "uint16", "3:float", "4:int32")
+
+    Returns:
+        DataType enum value
+    """
+    # Handle modpoll-style type strings like "3:int" or "4:float"
+    if ":" in type_str:
+        _, type_name = type_str.split(":", 1)
+        type_str = type_name
+
+    type_str = type_str.lower().strip()
+
+    mapping = {
+        "int16": DataType.INT16,
+        "int": DataType.INT16,
+        "16bit": DataType.INT16,
+        "uint16": DataType.UINT16,
+        "uint": DataType.UINT16,
+        "u16": DataType.UINT16,
+        "int32": DataType.INT32,
+        "32int": DataType.INT32,
+        "i32": DataType.INT32,
+        "uint32": DataType.UINT32,
+        "32uint": DataType.UINT32,
+        "u32": DataType.UINT32,
+        "float": DataType.FLOAT32,
+        "float32": DataType.FLOAT32,
+        "f32": DataType.FLOAT32,
+        "real": DataType.FLOAT32,
+        "hex": DataType.HEX,
+        "hexadecimal": DataType.HEX,
+    }
+
+    if type_str in mapping:
+        return mapping[type_str]
+
+    raise ValueError(f"Unknown data type: {type_str}. Supported: {list(mapping.keys())}")
+
+
+def registers_to_int16(registers: List[int], signed: bool = True) -> int:
+    """
+    Convert 1 register to int16/uint16.
+
+    Args:
+        registers: List of register values (16-bit each)
+        signed: If True, return signed int16
+
+    Returns:
+        Integer value
+    """
+    if len(registers) < 1:
+        raise ValueError("int16 requires 1 register")
+
+    value = registers[0] & 0xFFFF
+    if signed and value >= 0x8000:
+        value -= 0x10000
+    return value
+
+
+def registers_to_int32(
+    registers: List[int],
+    signed: bool = True,
+    byte_order: ByteOrder = DEFAULT_BYTE_ORDER,
+) -> int:
+    """
+    Convert 2 registers to int32/uint32.
+
+    Args:
+        registers: List of register values (16-bit each)
+        signed: If True, return signed int32
+        byte_order: Byte order for register arrangement
+
+    Returns:
+        Integer value
+    """
+    if len(registers) < 2:
+        raise ValueError("int32 requires 2 registers")
+
+    high, low = _reorder_registers(registers, byte_order)
+    value = (high << 16) | low
+
+    if signed and value >= 0x80000000:
+        value -= 0x100000000
+    return value
+
+
+def registers_to_float32(
+    registers: List[int],
+    byte_order: ByteOrder = DEFAULT_BYTE_ORDER,
+) -> float:
+    """
+    Convert 2 registers to float32 (IEEE 754).
+
+    Args:
+        registers: List of register values (16-bit each)
+        byte_order: Byte order for register arrangement
+
+    Returns:
+        Float value
+    """
+    if len(registers) < 2:
+        raise ValueError("float32 requires 2 registers")
+
+    high, low = _reorder_registers(registers, byte_order)
+    value = (high << 16) | low
+
+    return struct.unpack(">f", struct.pack(">I", value))[0]
+
+
+def registers_to_hex(registers: List[int], count: int = 1) -> str:
+    """
+    Convert registers to hexadecimal string.
+
+    Args:
+        registers: List of register values
+        count: Number of registers to format
+
+    Returns:
+        Hex string like "0x1234" or "0x1234 0x5678"
+    """
+    hex_values = []
+    for i in range(min(count, len(registers))):
+        hex_values.append(f"0x{registers[i] & 0xFFFF:04X}")
+    return " ".join(hex_values)
+
+
+def int16_to_registers(value: int, signed: bool = True) -> List[int]:
+    """
+    Convert int16/uint16 to register list.
+
+    Args:
+        value: Integer value
+        signed: If True, value is signed
+
+    Returns:
+        List with 1 register value
+    """
+    if signed:
+        if not (-32768 <= value <= 32767):
+            raise ValueError(f"int16 value out of range: {value}")
+        if value < 0:
+            value = value + 0x10000
+    else:
+        if not (0 <= value <= 65535):
+            raise ValueError(f"uint16 value out of range: {value}")
+
+    return [value & 0xFFFF]
+
+
+def int32_to_registers(
+    value: int,
+    signed: bool = True,
+    byte_order: ByteOrder = DEFAULT_BYTE_ORDER,
+) -> List[int]:
+    """
+    Convert int32/uint32 to register list.
+
+    Args:
+        value: Integer value
+        signed: If True, value is signed
+        byte_order: Byte order for register arrangement
+
+    Returns:
+        List with 2 register values
+    """
+    if signed:
+        if not (-2147483648 <= value <= 2147483647):
+            raise ValueError(f"int32 value out of range: {value}")
+        if value < 0:
+            value = value + 0x100000000
+    else:
+        if not (0 <= value <= 4294967295):
+            raise ValueError(f"uint32 value out of range: {value}")
+
+    high = (value >> 16) & 0xFFFF
+    low = value & 0xFFFF
+    return _reorder_to_registers(high, low, byte_order)
+
+
+def float32_to_registers(
+    value: float,
+    byte_order: ByteOrder = DEFAULT_BYTE_ORDER,
+) -> List[int]:
+    """
+    Convert float32 to register list.
+
+    Args:
+        value: Float value
+        byte_order: Byte order for register arrangement
+
+    Returns:
+        List with 2 register values
+    """
+    packed = struct.pack(">f", value)
+    integer_value = struct.unpack(">I", packed)[0]
+
+    high = (integer_value >> 16) & 0xFFFF
+    low = integer_value & 0xFFFF
+    return _reorder_to_registers(high, low, byte_order)
+
+
+def convert_registers(
+    registers: List[int],
+    data_type: DataType,
+    count: int = 1,
+    byte_order: ByteOrder = DEFAULT_BYTE_ORDER,
+) -> Union[str, int, float]:
+    """
+    Convert registers to specified data type.
+
+    Args:
+        registers: List of register values
+        data_type: Target data type
+        count: Number of registers to convert (for hex display)
+        byte_order: Byte order for 32-bit types
+
+    Returns:
+        Converted value as string, int, or float
+    """
+    if data_type == DataType.INT16:
+        return registers_to_int16(registers, signed=True)
+    elif data_type == DataType.UINT16:
+        return registers_to_int16(registers, signed=False)
+    elif data_type == DataType.INT32:
+        return registers_to_int32(registers, signed=True, byte_order=byte_order)
+    elif data_type == DataType.UINT32:
+        return registers_to_int32(registers, signed=False, byte_order=byte_order)
+    elif data_type == DataType.FLOAT32:
+        return registers_to_float32(registers, byte_order=byte_order)
+    elif data_type == DataType.HEX:
+        return registers_to_hex(registers, count=count)
+    else:
+        raise ValueError(f"Unsupported data type: {data_type}")
+
+
+def format_value(
+    value: Union[str, int, float],
+    data_type: DataType,
+    hex_format: bool = False,
+) -> str:
+    """
+    Format value for display.
+
+    Args:
+        value: Value to format
+        data_type: Data type of the value
+        hex_format: If True, also show hex representation
+
+    Returns:
+        Formatted string
+    """
+    if data_type == DataType.HEX:
+        return str(value)
+    elif data_type == DataType.FLOAT32:
+        return f"{value:.6f}"
+    elif data_type in (DataType.INT16, DataType.INT32):
+        result = str(value)
+        if hex_format and isinstance(value, int):
+            result += f" (0x{value & 0xFFFFFFFF:08X}" if value < 0 else f" (0x{value:08X}"
+            result += ")"
+        return result
+    elif data_type in (DataType.UINT16, DataType.UINT32):
+        result = str(value)
+        if hex_format:
+            hex_width = 4 if data_type == DataType.UINT16 else 8
+            result += f" (0x{value:0{hex_width}X})"
+        return result
+    else:
+        return str(value)