modpoll2mqtt 2.0.0__py3-none-any.whl

modpoll/__init__.py

@@ -0,0 +1,6 @@
+import importlib.metadata as importlib_metadata
+
+try:
+    __version__ = importlib_metadata.version("modpoll2mqtt")
+except importlib_metadata.PackageNotFoundError:
+    __version__ = "0.0.0"

modpoll/__main__.py

@@ -0,0 +1,3 @@
+from .main import app
+
+app()

modpoll/arg_parser.py

@@ -0,0 +1,209 @@
+import argparse
+
+from . import __version__
+
+_CSV_DELIMITER_CHOICES = ("comma", "tab")
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        description=f"modpoll2mqtt v{__version__} - Modbus to MQTT gateway"
+    )
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"v{__version__}",
+    )
+    parser.add_argument(
+        "-f",
+        "--config",
+        required=True,
+        help="A local path or URL of Modbus configuration file. Required!",
+        nargs="+",
+    )
+    parser.add_argument(
+        "--csv-delimiter",
+        default="comma",
+        choices=_CSV_DELIMITER_CHOICES,
+        help=(
+            "Column delimiter code for Modbus config files "
+            f"({', '.join(_CSV_DELIMITER_CHOICES)}). Defaults to comma"
+        ),
+    )
+    parser.add_argument(
+        "-d",
+        "--daemon",
+        action="store_true",
+        help="Run in daemon mode without printing result",
+    )
+    parser.add_argument(
+        "-r",
+        "--rate",
+        type=float,
+        default=10.0,
+        help="The sampling rate (s) to poll modbus device, Defaults to 10.0",
+    )
+    parser.add_argument(
+        "-1", "--once", action="store_true", help="Only run polling at one time"
+    )
+    parser.add_argument(
+        "--interval",
+        type=float,
+        default=0.5,
+        help="The time interval in seconds between two polling, Defaults to 0.5",
+    )
+    parser.add_argument(
+        "--tcp", help="Act as a Modbus TCP master, connecting to host TCP"
+    )
+    parser.add_argument(
+        "--tcp-port", type=int, default=502, help="Port for MODBUS TCP. Defaults to 502"
+    )
+    parser.add_argument(
+        "--udp", help="Act as a Modbus UDP master, connecting to host UDP"
+    )
+    parser.add_argument(
+        "--udp-port", type=int, default=502, help="Port for MODBUS UDP. Defaults to 502"
+    )
+    parser.add_argument(
+        "--serial",
+        "--rtu",
+        dest="serial",
+        help="pyserial URL (or port name) for serial transport (alias: --rtu)",
+    )
+    parser.add_argument(
+        "--serial-baud",
+        "--rtu-baud",
+        dest="serial_baud",
+        type=int,
+        default=9600,
+        help="Baud rate for serial port. Defaults to 9600",
+    )
+    parser.add_argument(
+        "--serial-parity",
+        "--rtu-parity",
+        dest="serial_parity",
+        choices=["none", "odd", "even"],
+        default="none",
+        help="Parity for serial port. Defaults to none",
+    )
+    parser.add_argument(
+        "--timeout",
+        type=float,
+        default=3.0,
+        help="Response time-out seconds for MODBUS devices, Defaults to 3.0",
+    )
+    parser.add_argument(
+        "-o",
+        "--export",
+        default=None,
+        help="The file name to export references/registers",
+    )
+    parser.add_argument(
+        "--mqtt-version",
+        choices=["3.1.1", "5.0"],
+        default="3.1.1",
+        help="MQTT version. Defaults to MQTT v3.1.1",
+    )
+    parser.add_argument(
+        "--mqtt-host",
+        default=None,
+        help="MQTT server address. Skip MQTT setup if not specified",
+    )
+    parser.add_argument(
+        "--mqtt-port",
+        type=int,
+        default=1883,
+        help="1883 for non-TLS or 8883 for TLS, Defaults to 1883",
+    )
+    parser.add_argument(
+        "--mqtt-clientid",
+        default=None,
+        help="MQTT client name, If qos > 0, set unique name for multiple clients",
+    )
+    parser.add_argument(
+        "--mqtt-publish-topic-pattern",
+        default="modpoll/{{device_name}}/data",
+        help='Topic pattern for MQTT publish. Use {{device_name}} as placeholder for the device names in Modbus config. Defaults to "modpoll/{{device_name}}/data"',
+    )
+    parser.add_argument(
+        "--mqtt-subscribe-topic-pattern",
+        default="modpoll/+/set",
+        help='Topic pattern for MQTT write commands. Use + as placeholder for device name. Defaults to "modpoll/+/set"',
+    )
+    parser.add_argument(
+        "--mqtt-diagnostics-topic-pattern",
+        default="modpoll/{{device_name}}/diagnostics",
+        help="Topic pattern for MQTT diagnostics. Use {{device_name}} as placeholder for the device names in Modbus config. Defaults to modpoll/{{device_name}}/diagnostics",
+    )
+    parser.add_argument(
+        "--mqtt-qos",
+        choices=[0, 1, 2],
+        type=int,
+        default=0,
+        help="MQTT QoS value. Defaults to 0",
+    )
+    parser.add_argument(
+        "--mqtt-rx-queue-size",
+        type=int,
+        default=1000,
+        metavar="N",
+        help="Max MQTT subscribe messages buffered between polls (default: 1000)",
+    )
+    parser.add_argument(
+        "--mqtt-user", default=None, help="Username for authentication (optional)"
+    )
+    parser.add_argument(
+        "--mqtt-pass", default=None, help="Password for authentication (optional)"
+    )
+    parser.add_argument("--mqtt-use-tls", action="store_true", help="Use TLS")
+    parser.add_argument(
+        "--mqtt-insecure",
+        action="store_true",
+        help="Use TLS without providing certificates",
+    )
+    parser.add_argument("--mqtt-cacerts", default=None, help="Path to ca keychain")
+    parser.add_argument(
+        "--mqtt-tls-version",
+        choices=["tlsv1.2", "tlsv1.1", "tlsv1"],
+        default="tlsv1.2",
+        help="TLS protocol version, can be one of tlsv1.2 tlsv1.1 or tlsv1",
+    )
+    parser.add_argument(
+        "--mqtt-single",
+        action="store_true",
+        help="Publish each value in a single topic. If not specified, groups all values in one topic.",
+    )
+    parser.add_argument(
+        "--diagnostics-rate",
+        type=float,
+        default=0,
+        help="Time in seconds as publishing period for each device diagnostics",
+    )
+    parser.add_argument(
+        "--autoremove",
+        action="store_true",
+        help="Automatically remove poller if modbus communication has failed 3 times.",
+    )
+    parser.add_argument(
+        "--loglevel",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        default="INFO",
+        help="Set log level, Defaults to INFO",
+    )
+    parser.add_argument(
+        "--timestamp", action="store_true", help="Add timestamp to the result"
+    )
+    parser.add_argument(
+        "--delay",
+        type=int,
+        default=0,
+        help="Time to delay sending first request in seconds after connecting. Default to 0",
+    )
+    parser.add_argument(
+        "--framer",
+        default="default",
+        choices=["default", "ascii", "rtu", "socket"],
+        help="The type of framer for Modbus messages. Serial supports ascii/rtu; TCP/UDP use socket.",
+    )
+    return parser

modpoll/main.py

@@ -0,0 +1,256 @@
+import json
+import logging
+import re
+import signal
+import sys
+
+from .arg_parser import get_parser
+from .mqtt_task import MqttHandler
+from .modbus_task import setup_modbus_handlers, modbus_connect, modbus_close
+
+from . import __version__
+from .utils import set_threading_event, delay_thread, on_threading_event, get_utc_time
+
+
+LOG_SIMPLE = "%(asctime)s | %(levelname).1s | %(name)s | %(message)s"
+logger = None
+
+
+def _signal_handler(signal, frame):
+    logger.info(f"Exiting {sys.argv[0]}")
+    set_threading_event()
+
+
+def extract_device_from_mqtt_topic(pattern: str, topic: str):
+    """Return device name from the first '+' wildcard segment, or None if no match."""
+    parts = pattern.split("+")
+    if len(parts) < 2:
+        raise ValueError("MQTT subscribe pattern must contain '+' wildcard")
+    topic_regex = "([^/\n]*)".join(re.escape(p) for p in parts)
+    match = re.fullmatch(topic_regex, topic)
+    return match.group(1) if match else None
+
+
+def setup_logging(level, format):
+    logging.basicConfig(level=level, format=format)
+
+
+def app(name="modpoll"):
+    mqtt_handler = None
+    modbus_client = None
+    modbus_handlers = []
+
+    print(
+        f"\nmodpoll2mqtt v{__version__} - Modbus to MQTT gateway\n",
+        flush=True,
+    )
+
+    # parse args
+    args = get_parser().parse_args()
+
+    # get logger
+    setup_logging(args.loglevel, LOG_SIMPLE)
+    global logger
+    logger = logging.getLogger(__name__)
+
+    signal.signal(signal.SIGINT, _signal_handler)
+    signal.signal(signal.SIGTERM, _signal_handler)
+
+    # setup mqtt
+    if not args.mqtt_host:
+        logger.info("No MQTT host specified, skip MQTT setup.")
+    else:
+        logger.info(f"Setup MQTT connection to {args.mqtt_host}:{args.mqtt_port}")
+        try:
+            if "+" not in args.mqtt_subscribe_topic_pattern:
+                logger.error(
+                    "MQTT subscribe pattern must contain '+' wildcard for the device "
+                    f"name segment: {args.mqtt_subscribe_topic_pattern}"
+                )
+                exit(1)
+            if args.mqtt_rx_queue_size < 1:
+                logger.error(
+                    f"MQTT rx queue size must be at least 1: {args.mqtt_rx_queue_size}"
+                )
+                exit(1)
+            mqtt_handler = MqttHandler(
+                "MqttHandler",
+                args.mqtt_host,
+                args.mqtt_port,
+                args.mqtt_user,
+                args.mqtt_pass,
+                args.mqtt_clientid,
+                args.mqtt_qos,
+                subscribe_topics=[args.mqtt_subscribe_topic_pattern],
+                use_tls=args.mqtt_use_tls,
+                tls_version=args.mqtt_tls_version,
+                cacerts=args.mqtt_cacerts,
+                insecure=args.mqtt_insecure,
+                mqtt_version=args.mqtt_version,
+                log_level=args.loglevel,
+                rx_queue_size=args.mqtt_rx_queue_size,
+            )
+            if mqtt_handler.setup() and mqtt_handler.connect():
+                logger.info("Connected to MQTT broker.")
+            else:
+                logger.error("Failed to connect with MQTT broker, exiting...")
+                try:
+                    mqtt_handler.close()
+                except Exception as close_err:
+                    logger.debug(
+                        f"Ignoring MQTT close error after failed connect: {close_err}"
+                    )
+                exit(1)
+        except Exception as e:
+            logger.error(f"Error setting up MQTT input: {e}, exiting...")
+            if mqtt_handler:
+                try:
+                    mqtt_handler.close()
+                except Exception as close_err:
+                    logger.debug(
+                        f"Ignoring MQTT close error after setup exception: {close_err}"
+                    )
+            exit(1)
+
+    # setup modbus tasks
+    modbus_client, modbus_handlers = setup_modbus_handlers(args, mqtt_handler)
+    if modbus_handlers:
+        logger.info(f"Loaded {len(modbus_handlers)} Modbus config(s).")
+        delay_thread(args.delay)
+    else:
+        logger.error("No Modbus config(s) defined. Exiting...")
+        if mqtt_handler:
+            mqtt_handler.close()
+        exit(1)
+
+    # main loop
+    last_check = 0
+    last_diag = 0
+    while not on_threading_event():
+        now = get_utc_time()
+        # routine check
+        if now > last_check + args.rate:
+            if last_check == 0:
+                elapsed = args.rate
+            else:
+                elapsed = round(now - last_check, 6)
+            logger.info(
+                f" === Modpoll is polling at rate:{args.rate}s, actual:{elapsed}s ==="
+            )
+            if not modbus_connect(modbus_client):
+                for modbus_handler in modbus_handlers:
+                    modbus_handler.on_connect_failure()
+            else:
+                try:
+                    for modbus_handler in modbus_handlers:
+                        modbus_handler.poll()
+                        if on_threading_event():
+                            break
+                finally:
+                    modbus_close(modbus_client)
+            for modbus_handler in modbus_handlers:
+                if on_threading_event():
+                    break
+                if args.mqtt_host:
+                    if args.timestamp:
+                        modbus_handler.publish_data(timestamp=now)
+                    else:
+                        modbus_handler.publish_data()
+                if args.export:
+                    if args.timestamp:
+                        modbus_handler.export(args.export, timestamp=now)
+                    else:
+                        modbus_handler.export(args.export)
+            last_check = get_utc_time()
+        if args.diagnostics_rate > 0 and now > last_diag + args.diagnostics_rate:
+            last_diag = now
+            for modbus_handler in modbus_handlers:
+                modbus_handler.publish_diagnostics()
+        if on_threading_event():
+            break
+        # Check if receive mqtt request
+        if mqtt_handler:
+            topic, payload = mqtt_handler.receive()
+            if topic and payload:
+                try:
+                    device_name = extract_device_from_mqtt_topic(
+                        args.mqtt_subscribe_topic_pattern, topic
+                    )
+                except ValueError:
+                    logger.error(
+                        "MQTT subscribe pattern must contain '+' wildcard: "
+                        f"{args.mqtt_subscribe_topic_pattern}"
+                    )
+                    continue
+                if not device_name:
+                    logger.error(f"Failed to extract device name from topic: {topic}")
+                    continue
+
+                try:
+                    command = json.loads(payload)
+                    ref_name = command["ref"]
+                    value = command["value"]
+                except KeyError as e:
+                    logger.error(f"Missing required key in payload: {e}")
+                    continue
+                except json.JSONDecodeError:
+                    logger.error(f"Failed to parse JSON message: {payload}")
+                    continue
+
+                if "device" in command:
+                    logger.debug(
+                        "Ignoring 'device' in write payload; device is taken from topic"
+                    )
+
+                logger.info(
+                    f"Received write request for device={device_name}, ref={ref_name}"
+                )
+                device_found = False
+                write_success = False
+                connect_failed = False
+                for modbus_handler in modbus_handlers:
+                    if not modbus_handler.has_device(device_name):
+                        continue
+                    device_found = True
+                    if not modbus_connect(modbus_client):
+                        connect_failed = True
+                    else:
+                        try:
+                            write_success = modbus_handler.write_reference(
+                                device_name, ref_name, value
+                            )
+                        finally:
+                            modbus_close(modbus_client)
+                    break
+
+                if not device_found:
+                    logger.error(f"No device found with name: {device_name}")
+                elif connect_failed:
+                    logger.error(
+                        f"Modbus connect failed for write: device={device_name}, "
+                        f"ref={ref_name}"
+                    )
+                elif write_success:
+                    logger.info(
+                        f"Successfully wrote device={device_name}, ref={ref_name}, "
+                        f"value={value}"
+                    )
+                else:
+                    logger.warning(
+                        f"Failed to write device={device_name}, ref={ref_name}, "
+                        f"value={value}"
+                    )
+        if args.once:
+            set_threading_event()
+            break
+
+        remaining = last_check + args.rate - get_utc_time()
+        delay_thread(min(max(remaining, 0.01), 0.5))
+
+    modbus_close(modbus_client)
+    if mqtt_handler:
+        mqtt_handler.close()
+
+
+if __name__ == "__main__":
+    app()