moat-lib-modbus 0.0.2__tar.gz

moat_lib_modbus-0.0.2/LICENSE.txt

@@ -0,0 +1,14 @@
+The code in this repository, and all MoaT submodules it refers to,
+is part of the MoaT project.
+
+Unless a submodule's LICENSE.txt states otherwise, all included files are
+licensed under the LGPL V3, as published by the FSF at
+https://www.gnu.org/licenses/lgpl-3.0.html .
+
+In addition to the LGPL's terms, the author(s) respectfully ask all users of
+this code to contribute any bug fixes or enhancements. Also, please link back to
+https://M-o-a-T.org.
+
+Thank you.
+
+Copyright © 2021 ff.: the MoaT contributor(s), as per the git changelog(s).

moat_lib_modbus-0.0.2/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: moat-lib-modbus
+Version: 0.0.2
+Summary: Sans-IO Modbus protocol core (no pymodbus)
+Author-email: Matthias Urlichs <matthias@urlichs.de>
+Maintainer-email: Matthias Urlichs <matthias@urlichs.de>
+Project-URL: homepage, https://m-o-a-t.org
+Project-URL: repository, https://github.com/M-o-a-T/moat
+Keywords: MoaT
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AnyIO
+Classifier: Framework :: Trio
+Classifier: Framework :: AsyncIO
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
+
+# moat-lib-modbus
+
+% start synopsis
+% start main
+
+A sans-IO Modbus protocol core implementing the minimal subset used by
+``moat.modbus``: PDU encoding/decoding for function codes 1, 2, 3, 4,
+5, 6, 15, 16, plus TCP (MBAP) and RTU framers with a client/server
+role flag, and an RTU-only ``monitor`` role for passive bus sniffing.
+
+Stdlib only -- no ``pymodbus``, no ``anyio``.
+
+% end synopsis
+
+## Design
+
+The library is strictly sans-IO: it never opens a socket, touches a
+serial port, sleeps, waits, or spawns a task.  Every component is a
+pure transform -- bytes in -> messages/PDUs out, messages in -> bytes
+out.  The only mutable state permitted is a framer's internal byte
+accumulator.  All real I/O stays in ``moat.modbus``.
+
+### Role flag
+
+The same function-code byte decodes to a request on a server and a
+response on a client.  The role is therefore a constructor flag on the
+framer itself: ``FramerTCP(role)`` / ``FramerRTU(role)`` where ``role``
+is ``True`` / ``"server"`` (decode incoming bytes as requests),
+``False`` / ``"client"`` (decode as responses), or -- for RTU only --
+``"monitor"`` (passive bus sniffer; see below).
+
+### Monitor mode (RTU only)
+
+``FramerRTU("monitor")`` taps a live master/slave RTU line without
+participating in it.  Sending is prohibited (``buildFrame`` raises
+``ModbusIOError``).  Frames are decoded as an alternating
+request/response sequence starting with a request; each decoded frame
+flips the expectation (queryable via ``expecting_request``).  Since the
+framer is sans-IO it cannot time the inter-frame gap, so the caller
+calls ``resetFrame()`` on an inter-frame timeout, which clears the
+accumulator and returns the framer to expecting a request -- covering
+both torn partial frames and silent slaves.  Monitor mode is RTU-only;
+``FramerTCP("monitor")`` is rejected.
+
+% end main

moat_lib_modbus-0.0.2/README.md

@@ -0,0 +1,45 @@
+# moat-lib-modbus
+
+% start synopsis
+% start main
+
+A sans-IO Modbus protocol core implementing the minimal subset used by
+``moat.modbus``: PDU encoding/decoding for function codes 1, 2, 3, 4,
+5, 6, 15, 16, plus TCP (MBAP) and RTU framers with a client/server
+role flag, and an RTU-only ``monitor`` role for passive bus sniffing.
+
+Stdlib only -- no ``pymodbus``, no ``anyio``.
+
+% end synopsis
+
+## Design
+
+The library is strictly sans-IO: it never opens a socket, touches a
+serial port, sleeps, waits, or spawns a task.  Every component is a
+pure transform -- bytes in -> messages/PDUs out, messages in -> bytes
+out.  The only mutable state permitted is a framer's internal byte
+accumulator.  All real I/O stays in ``moat.modbus``.
+
+### Role flag
+
+The same function-code byte decodes to a request on a server and a
+response on a client.  The role is therefore a constructor flag on the
+framer itself: ``FramerTCP(role)`` / ``FramerRTU(role)`` where ``role``
+is ``True`` / ``"server"`` (decode incoming bytes as requests),
+``False`` / ``"client"`` (decode as responses), or -- for RTU only --
+``"monitor"`` (passive bus sniffer; see below).
+
+### Monitor mode (RTU only)
+
+``FramerRTU("monitor")`` taps a live master/slave RTU line without
+participating in it.  Sending is prohibited (``buildFrame`` raises
+``ModbusIOError``).  Frames are decoded as an alternating
+request/response sequence starting with a request; each decoded frame
+flips the expectation (queryable via ``expecting_request``).  Since the
+framer is sans-IO it cannot time the inter-frame gap, so the caller
+calls ``resetFrame()`` on an inter-frame timeout, which clears the
+accumulator and returns the framer to expecting a request -- covering
+both torn partial frames and silent slaves.  Monitor mode is RTU-only;
+``FramerTCP("monitor")`` is rejected.
+
+% end main

moat_lib_modbus-0.0.2/debian/changelog

@@ -0,0 +1,5 @@
+moat-lib-modbus (0.0.2-1) unstable; urgency=medium
+
+  * Initial release for 26.2.13
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Wed, 23 Sep 2026 18:03:49 +0200

moat_lib_modbus-0.0.2/debian/control

@@ -0,0 +1,17 @@
+Source: moat-lib-modbus
+Maintainer: Matthias Urlichs <matthias@urlichs.de>
+Section: python
+Priority: optional
+Build-Depends: dh-python, python3-all, debhelper (>= 13), debhelper-compat (= 13),
+  python3-setuptools,
+  python3-wheel,
+Standards-Version: 3.9.6
+Homepage: https://github.com/M-o-a-T/moat
+
+Package: moat-lib-modbus
+Architecture: all
+Depends: ${misc:Depends}, ${python3:Depends},
+Description: Sans-IO Modbus protocol core
+ A dependency-free, sans-IO implementation of the minimal Modbus
+ protocol subset used by moat-modbus: PDU encoding/decoding for
+ function codes 1,2,3,4,5,6,15,16, plus TCP (MBAP) and RTU framers.

moat_lib_modbus-0.0.2/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["wheel","setuptools"]
+
+[project]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: AnyIO",
+    "Framework :: Trio",
+    "Framework :: AsyncIO",
+    "Programming Language :: Python :: 3",
+    "Intended Audience :: Developers",
+]
+dependencies = []
+keywords = ["MoaT"]
+requires-python = ">=3.11"
+name = "moat-lib-modbus"
+maintainers = [{email = "matthias@urlichs.de", name = "Matthias Urlichs"}]
+description = "Sans-IO Modbus protocol core (no pymodbus)"
+readme = "README.md"
+authors = [{email = "matthias@urlichs.de", name = "Matthias Urlichs"}]
+version = "0.0.2"
+
+[project.urls]
+homepage = "https://m-o-a-t.org"
+repository = "https://github.com/M-o-a-T/moat"
+
+[tool.setuptools]
+[tool.setuptools.packages.find]
+where = ["src"]

moat_lib_modbus-0.0.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

moat_lib_modbus-0.0.2/src/moat/lib/modbus/__init__.py

@@ -0,0 +1,68 @@
+"""
+Sans-IO Modbus protocol core.
+
+This library implements the minimal Modbus protocol subset used by
+``moat.modbus`` -- PDU encoding/decoding for function codes 1, 2, 3,
+4, 5, 6, 15, 16, plus TCP (MBAP) and RTU framers with a role flag.
+
+It is strictly **sans-IO**: no sockets, no serial ports, no sleeping,
+no waiting, no task spawning.  Bytes in -> PDUs out, and vice-versa.
+The only mutable state permitted is a framer's internal byte
+accumulator.
+
+Stdlib only -- no ``pymodbus``, no ``anyio``.
+"""
+
+from __future__ import annotations
+
+from ._crc import crc16
+from .errors import ExcCodes, ModbusIOError
+from .framer import FramerRTU, FramerTCP
+from .pdu import (
+    PDU,
+    ExceptionResponse,
+    ReadCoilsRequest,
+    ReadCoilsResponse,
+    ReadDiscreteInputsRequest,
+    ReadDiscreteInputsResponse,
+    ReadHoldingRegistersRequest,
+    ReadHoldingRegistersResponse,
+    ReadInputRegistersRequest,
+    ReadInputRegistersResponse,
+    WriteMultipleCoilsRequest,
+    WriteMultipleCoilsResponse,
+    WriteMultipleRegistersRequest,
+    WriteMultipleRegistersResponse,
+    WriteSingleCoilRequest,
+    WriteSingleCoilResponse,
+    WriteSingleRegisterRequest,
+    WriteSingleRegisterResponse,
+    decode_pdu,
+)
+
+__all__ = [
+    "PDU",
+    "ExcCodes",
+    "ExceptionResponse",
+    "FramerRTU",
+    "FramerTCP",
+    "ModbusIOError",
+    "ReadCoilsRequest",
+    "ReadCoilsResponse",
+    "ReadDiscreteInputsRequest",
+    "ReadDiscreteInputsResponse",
+    "ReadHoldingRegistersRequest",
+    "ReadHoldingRegistersResponse",
+    "ReadInputRegistersRequest",
+    "ReadInputRegistersResponse",
+    "WriteMultipleCoilsRequest",
+    "WriteMultipleCoilsResponse",
+    "WriteMultipleRegistersRequest",
+    "WriteMultipleRegistersResponse",
+    "WriteSingleCoilRequest",
+    "WriteSingleCoilResponse",
+    "WriteSingleRegisterRequest",
+    "WriteSingleRegisterResponse",
+    "crc16",
+    "decode_pdu",
+]

moat_lib_modbus-0.0.2/src/moat/lib/modbus/_crc.py

@@ -0,0 +1,36 @@
+"""
+CRC-16/Modbus checksum.
+
+Implements :func:`crc16` per the Modbus specification: polynomial
+``0xA001`` (bit-reversed ``0x8005``), init ``0xFFFF``, no final XOR,
+LSB-first processing, byte-wise loop (no lookup table).
+
+The CRC is appended to RTU frames as two bytes, low byte first.
+"""
+
+from __future__ import annotations
+
+
+def crc16(data: bytes) -> int:
+    """Compute the CRC-16/Modbus checksum of *data*.
+
+    Args:
+        data: The bytes to checksum.
+
+    Returns:
+        The 16-bit CRC value (0--65535).
+
+    The algorithm uses polynomial ``0xA001`` (reverse of ``0x8005``),
+    initial value ``0xFFFF``, and no final XOR.  Bytes are processed
+    LSB-first.  The result is emitted low byte first when appended to
+    a frame.
+    """
+    crc = 0xFFFF
+    for byte in data:
+        crc ^= byte
+        for _ in range(8):
+            if crc & 1:
+                crc = (crc >> 1) ^ 0xA001
+            else:
+                crc >>= 1
+    return crc & 0xFFFF

moat_lib_modbus-0.0.2/src/moat/lib/modbus/errors.py

@@ -0,0 +1,49 @@
+"""
+Modbus exception codes and I/O error.
+
+Defines :class:`ExcCodes` as an :class:`enum.IntEnum` covering the
+standard Modbus exception codes, plus two source-compatibility
+aliases used by the legacy ``moat.modbus`` code, and
+:class:`ModbusIOError` replacing pymodbus'
+``pymodbus.exceptions.ModbusIOException``.
+"""
+
+from __future__ import annotations
+
+import enum
+
+
+class ExcCodes(enum.IntEnum):
+    """Standard Modbus exception codes.
+
+    The aliases :attr:`DEVICE_FAILURE` and :attr:`GATEWAY_NO_RESPONSE`
+    are kept for source compatibility with the old ``moat.modbus`` code
+    that referenced pymodbus' ``ExcCodes.DEVICE_FAILURE`` /
+    ``ExcCodes.GATEWAY_NO_RESPONSE``.
+    """
+
+    ILLEGAL_FUNCTION = 1
+    ILLEGAL_DATA_ADDRESS = 2
+    ILLEGAL_DATA_VALUE = 3
+    SERVER_DEVICE_FAILURE = 4
+    ACKNOWLEDGE = 5
+    SERVER_DEVICE_BUSY = 6
+    NEGATIVE_ACKNOWLEDGE = 7
+    MEMORY_PARITY_ERROR = 8
+    GATEWAY_PATH_UNAVAILABLE = 10
+    GATEWAY_TARGET_NO_RESPONSE = 11
+
+    # Source-compatibility aliases.
+    DEVICE_FAILURE = 4
+    """Alias for :attr:`~ExcCodes.SERVER_DEVICE_FAILURE`."""
+
+    GATEWAY_NO_RESPONSE = 11
+    """Alias for :attr:`~ExcCodes.GATEWAY_TARGET_NO_RESPONSE`."""
+
+
+class ModbusIOError(Exception):
+    """Generic Modbus I/O error.
+
+    Replaces pymodbus' ``ModbusIOException``.  Raised when a frame
+    cannot be decoded or a protocol violation is detected.
+    """