Add pluggable RS-485 / serial device support

- New collector/rs485/ package with drivers for JK BMS, Modbus RTU, and raw hex discovery.
- Rs485Device base class + registry for adding future drivers.
- Standalone collector/rs485_collector.py daemon that writes to MariaDB/InfluxDB/MQTT.
- CLI entrypoint bin/lux-mon-rs485 and discovery helper scripts/discover-rs485.py.
- Installer updates: pyserial/pymodbus deps, dialout group, optional lux-mon-rs485.service.
- Prefix RS-485 fields to avoid colliding with inverter register names.
- Skip non-numeric values (e.g. raw hex dumps) before database writes.

Author: jmewing

.gitignore

@@ -13,6 +13,8 @@ venv/
 config.yaml
 config.py
 .env
+.credentials
+backup.tar.gz
 !config.example.yaml
 !config.example.py
 !env.example

bin/lux-mon-rs485

@@ -0,0 +1,33 @@
+#!/srv/lux-mon/venv/bin/python3
+"""CLI entry point for the lux-mon RS-485 collector."""
+
+import argparse
+import logging
+import sys
+from pathlib import Path
+
+# Allow running from a source checkout without being installed.
+repo = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(repo))
+
+from collector.rs485_collector import run_rs485_collector
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="lux-mon-rs485",
+        description="Poll RS-485 / serial devices (JK BMS, Modbus RTU, etc.) and write to lux-mon backends",
+    )
+    parser.add_argument("--log-level", default="INFO", help="Logging level (DEBUG/INFO/WARNING/ERROR)")
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        level=getattr(logging, args.log_level.upper(), logging.INFO),
+        format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+    )
+
+    run_rs485_collector(log_level=args.log_level.upper())
+
+
+if __name__ == "__main__":
+    main()

collector/rs485/README.md

@@ -0,0 +1,106 @@
+# lux-mon RS-485 / serial device support
+
+This package adds pluggable RS-485 and TTL-UART drivers to lux-mon so the
+same collector can ingest data from external devices (battery monitors,
+meters, weather stations, etc.) and write it to the same MariaDB, InfluxDB,
+and MQTT backends.
+
+It is designed to be **additive**: the existing TCP collector is untouched,
+and RS-485 collection runs as a separate daemon.
+
+## Available drivers
+
+| Driver         | Device / protocol                                   |
+|----------------|------------------------------------------------------|
+| `jk_bms`       | JiKong (JK) BMS over UART/RS-485                    |
+| `modbus_rtu`   | Generic Modbus RTU master                           |
+| `raw`          | Listen-only hex dump for discovery / unknown devices |
+
+New drivers can be added by creating a class that inherits from
+`Rs485Device` and registering it in `registry.py`.
+
+## Quick start (native install)
+
+1. Install lux-mon. The installer now adds `pyserial`/`pymodbus` and puts
+   `jmewing` in the `dialout` group.
+
+2. Discover what is connected to your RS-485 adapter:
+
+   ```bash
+   lux-mon-discover-rs485 /dev/ttyUSB0
+   ```
+
+3. Enable the RS-485 collector in `/srv/lux-mon/.env`:
+
+   ```env
+   LUX_RS485_ENABLED=true
+   LUX_RS485_PORT=/dev/ttyUSB0
+   LUX_RS485_BAUD=115200
+   LUX_RS485_DEVICE_TYPE=jk_bms
+   LUX_RS485_POLL_INTERVAL=2.0
+   LUX_RS485_WRITE_INTERVAL=30.0
+   LUX_RS485_PREFIX=rs485
+   ```
+
+4. Start the collector:
+
+   ```bash
+   sudo systemctl enable --now lux-mon-rs485
+   ```
+
+   Or run manually for testing:
+
+   ```bash
+   cd /srv/lux-mon
+   source .env
+   venv/bin/lux-mon-rs485
+   ```
+
+## Data shape
+
+Every driver returns a dictionary of:
+
+```python
+{
+    "field_name": {"value": float, "unit": str},
+    ...
+}
+```
+
+Before writing, the collector prefixes field names with `LUX_RS485_PREFIX`
+(default `rs485_`) so they do not collide with inverter registers. For
+example a JK BMS `total_voltage` becomes `rs485_total_voltage` in MariaDB
+and `luxmon_register{name="rs485_total_voltage"}` in InfluxDB.
+
+## Adding a new driver
+
+1. Create `collector/rs485/my_device.py` with a class:
+
+   ```python
+   from . import Rs485Device, Rs485DeviceConfig
+
+   class MyDevice(Rs485Device):
+       name = "my_device"
+       label = "My custom device"
+
+       def read(self):
+           return {"temperature": {"value": 25.0, "unit": "°C"}}
+   ```
+
+2. Register it in `collector/rs485/registry.py`:
+
+   ```python
+   ("my_device", "collector.rs485.my_device", "MyDevice"),
+   ```
+
+3. Optional: add a scale map or protocol-specific options to
+   `Rs485DeviceConfig.options`.
+
+## Notes
+
+- `modbus_rtu` is a generic master; supply a `scale_map` in code to translate
+  registers into named sensors.
+- `raw` never transmits, it only listens. Use it to confirm bytes are arriving
+  before choosing a driver.
+- Missing dependencies (e.g. `pymodbus`) are logged and skipped instead of
+  crashing the registry.

collector/rs485/__init__.py

@@ -0,0 +1,62 @@
+"""RS-485 / serial device drivers for lux-mon.
+
+This package provides pluggable drivers for devices connected to the host via
+an RS-485 or TTL serial adapter (for example a CP210x USB-to-UART bridge).
+
+Each driver inherits from :class:`Rs485Device` and implements ``read()`` to
+return a snapshot of decoded values.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class Rs485DeviceConfig:
+    """Common configuration for an RS-485 device."""
+
+    port: str = "/dev/ttyUSB0"
+    baudrate: int = 115200
+    timeout: float = 1.0
+    poll_interval: float = 2.0
+    device_type: str = "jk_bms"
+    # Generic Modbus settings
+    slave_id: int = 1
+    modbus_start: int = 0
+    modbus_count: int = 40
+    modbus_function: str = "input"  # or "holding"
+    # Driver-specific options
+    options: Dict[str, Any] = field(default_factory=dict)
+
+
+class Rs485Device(ABC):
+    """Base class for an RS-485 connected device driver.
+
+    A driver owns a serial port and knows how to request/parse data from one
+    specific device family. The :meth:`read` method should return a dictionary
+    of decoded values using the same shape as the main inverter driver:
+
+        {"field_name": {"value": float, "unit": str}}
+    """
+
+    name: str = "generic"
+    label: str = "Generic RS-485 device"
+
+    def __init__(self, config: Rs485DeviceConfig):
+        self.cfg = config
+
+    @abstractmethod
+    def read(self) -> Dict[str, Dict[str, Any]]:
+        """Read the device and return decoded values.
+
+        Returns a mapping of field name -> {"value": ..., "unit": ...}.
+        Returns an empty dict if the read failed or no data was available.
+        """
+        raise NotImplementedError
+
+    def close(self) -> None:
+        """Release any resources."""
+        pass