feat: mqtt hartbeat and more options

Author: sidey79

signalduino/constants.py

@@ -10,6 +10,8 @@
 SDUINO_WRITEQUEUE_NEXT = 0.3
 SDUINO_WRITEQUEUE_TIMEOUT = 2
 
+SDUINO_STATUS_HEARTBEAT_INTERVAL = 600.0 # 10 minutes
+
 SDUINO_DISPATCH_VERBOSE = 5
 SDUINO_MC_DISPATCH_VERBOSE = 5
 SDUINO_MC_DISPATCH_LOG_ID = "12.1"

signalduino/controller.py

@@ -1,16 +1,19 @@
+import json # NEU: Import für JSON-Serialisierung
 import logging
 import queue
 import re
 import threading
 import os # NEU: Import für Umgebungsvariablen
 from datetime import datetime, timedelta, timezone
-from typing import Any, Callable, List, Literal, Optional, Pattern
+from typing import Any, Callable, List, Optional, Pattern
 
+from .commands import SignalduinoCommands # NEU: Import für Befehle
 from .constants import (
     SDUINO_CMD_TIMEOUT,
     SDUINO_INIT_MAXRETRY,
     SDUINO_INIT_WAIT,
     SDUINO_INIT_WAIT_XQ,
+    SDUINO_STATUS_HEARTBEAT_INTERVAL, # NEU: Heartbeat-Konstante
 )
 from .exceptions import SignalduinoCommandTimeout, SignalduinoConnectionError
 from .mqtt import MqttPublisher # NEU: MQTT-Import
@@ -30,6 +33,7 @@ def __init__(
         logger: Optional[logging.Logger] = None,
     ) -> None:
         self.transport = transport
+        self.commands = SignalduinoCommands(self.send_command) # NEU: Befehlsklasse initialisieren
         self.parser = parser or SignalParser()
         self.message_callback = message_callback
         self.logger = logger or logging.getLogger(__name__)
@@ -45,6 +49,8 @@ def __init__(
         self._parser_thread: Optional[threading.Thread] = None
         self._writer_thread: Optional[threading.Thread] = None
 
+        self._heartbeat_timer: Optional[threading.Timer] = None # NEU: Heartbeat Timer initialisieren
+
         self._stop_event = threading.Event()
         self._raw_message_queue: queue.Queue[str] = queue.Queue()
         self._write_queue: queue.Queue[QueuedCommand] = queue.Queue()
@@ -89,6 +95,10 @@ def disconnect(self) -> None:
         # NEU: MQTT Publisher stoppen
         if self.mqtt_publisher:
             self.mqtt_publisher.stop()
+            
+        if self._heartbeat_timer: # NEU: Heartbeat Timer stoppen
+            self._heartbeat_timer.cancel()
+            self._heartbeat_timer = None
 
         # Wake up threads that might be waiting on queues
         self._raw_message_queue.put("")
@@ -119,7 +129,7 @@ def initialize(self) -> None:
     def _send_xq(self) -> None:
         try:
             self.logger.debug("Sending XQ to disable receiver during init")
-            self.send_command("XQ", expect_response=False)
+            self.commands.disable_receiver()
         except Exception as e:
             self.logger.warning("Failed to send XQ: %s", e)
 
@@ -142,15 +152,8 @@ def _start_init(self) -> None:
 
         response = None
         try:
-            # Perl Regex: 'V\s.*SIGNAL(?:duino|ESP|STM).*(?:\s\d\d:\d\d:\d\d)'
-            version_pattern = re.compile(r"V\s.*SIGNAL(?:duino|ESP|STM).*", re.IGNORECASE)
-            # Use a short timeout here to speed up failed attempts
-            response = self.send_command(
-                "V",
-                expect_response=True,
-                timeout=2.0, # Shorter timeout for retries
-                response_pattern=version_pattern,
-            )
+            # Use commands class for version check
+            response = self.commands.get_version(timeout=2.0) # Shorter timeout for retries
         except Exception as e:
             self.logger.debug("StartInit: Exception during version check: %s", e)
 
@@ -161,18 +164,28 @@ def _check_version_resp(self, msg: Optional[str]) -> None:
             self.logger.info("Initialized %s", msg.strip())
             self.init_reset_flag = False
             self.init_retry_count = 0
+            self.init_version_response = msg # Speichern der Version
+
+            # NEU: Versionsmeldung per MQTT veröffentlichen (Schritt 5)
+            if self.mqtt_publisher:
+                # Topic: <mqtt_topic>/status/version
+                self.mqtt_publisher.publish_simple("status/version", msg.strip(), retain=True)
 
             # Enable Receiver XE
             try:
                 self.logger.info("Enabling receiver (XE)")
-                self.send_command("XE", expect_response=False)
+                self.commands.enable_receiver()
             except Exception as e:
                 self.logger.warning("Failed to enable receiver: %s", e)
 
             # Check for CC1101
             if "cc1101" in msg.lower():
                 self.logger.info("CC1101 detected")
                 # Here we could query ccconf and ccpatable like in Perl
+            
+            # NEU: Starte Heartbeat-Timer
+            self._start_heartbeat_timer()
+
         else:
             self.logger.warning("StartInit: No valid version response.")
             self.init_retry_count += 1
@@ -321,49 +334,6 @@ def send_raw_command(self, command: str, expect_response: bool = False, timeout:
         """Queues a raw command and optionally waits for a specific response."""
         return self.send_command(payload=command, expect_response=expect_response, timeout=timeout)
 
-    def set_message_type_enabled(
-        self, message_type: Literal["MS", "MU", "MC"], enabled: bool
-    ) -> None:
-        """Enables or disables a specific message type in the firmware."""
-        if message_type not in {"MS", "MU", "MC"}:
-            raise ValueError(f"Invalid message type: {message_type}")
-
-        verb = "E" if enabled else "D"
-        noun = message_type[-1]  # S, U, or C
-        command = f"C{verb}{noun}"
-        self.send_command(command)
-
-    def _send_cc1101_command(self, command: str, value: Any) -> None:
-        """Helper to send a CC1101-specific command."""
-        full_command = f"{command}{value}"
-        self.send_command(full_command)
-
-    def set_bwidth(self, bwidth: int) -> None:
-        """Set the CC1101 bandwidth."""
-        self._send_cc1101_command("C10", bwidth)
-
-    def set_rampl(self, rampl: int) -> None:
-        """Set the CC1101 rAmpl."""
-        self._send_cc1101_command("W1D", rampl)
-
-    def set_sens(self, sens: int) -> None:
-        """Set the CC1101 sensitivity."""
-        self._send_cc1101_command("W1F", sens)
-
-    def set_patable(self, patable: str) -> None:
-        """Set the CC1101 PA table."""
-        self._send_cc1101_command("x", patable)
-
-    def set_freq(self, freq: float) -> None:
-        """Set the CC1101 frequency."""
-        # This is a simplified version. The Perl code has complex logic here.
-        command = f"W0F{int(freq):02X}"  # Example, not fully correct
-        self.send_command(command)
-
-    def send_message(self, message: str) -> None:
-        """Sends a pre-encoded message string."""
-        self.send_command(message)
-
     def send_command(
         self,
         payload: str,
@@ -419,50 +389,112 @@ def on_response(response: str):
             )
             raise SignalduinoCommandTimeout(f"Command '{payload}' timed out") from None
 
+    def _start_heartbeat_timer(self) -> None:
+        """Schedules the periodic status heartbeat."""
+        if not self.mqtt_publisher:
+            return
+
+        if self._heartbeat_timer:
+            self._heartbeat_timer.cancel()
+        
+        self._heartbeat_timer = threading.Timer(
+            SDUINO_STATUS_HEARTBEAT_INTERVAL,
+            self._publish_status_heartbeat
+        )
+        self._heartbeat_timer.name = "sd-heartbeat"
+        self._heartbeat_timer.start()
+        self.logger.info("Heartbeat timer started, interval: %d seconds.", SDUINO_STATUS_HEARTBEAT_INTERVAL)
+
+    def _publish_status_heartbeat(self) -> None:
+        """Publishes the current device status."""
+        if not self.mqtt_publisher or not self.mqtt_publisher.is_connected():
+            self.logger.warning("Cannot publish heartbeat; publisher not connected.")
+            self._start_heartbeat_timer() # Try again later
+            return
+            
+        try:
+            # 1. Heartbeat/Alive message (Retain: True)
+            self.mqtt_publisher.publish_simple("status/alive", "online", retain=True)
+            self.logger.debug("Published heartbeat status.")
+
+            # 2. Status data (version, ram, uptime)
+            # Fetch data from device (non-blocking call, runs in timer thread)
+            status_data = {}
+            
+            # Version (if not already known from init)
+            if self.init_version_response:
+                status_data["version"] = self.init_version_response.strip()
+            
+            # Free RAM
+            try:
+                ram_resp = self.commands.get_free_ram()
+                # Format: R: 1234
+                if ":" in ram_resp:
+                    status_data["free_ram"] = ram_resp.split(":")[-1].strip()
+                else:
+                    status_data["free_ram"] = ram_resp.strip()
+            except Exception as e:
+                self.logger.warning("Could not get free RAM for heartbeat: %s", e)
+                status_data["free_ram"] = "error"
+                
+            # Uptime
+            try:
+                uptime_resp = self.commands.get_uptime()
+                # Format: t: 1234
+                if ":" in uptime_resp:
+                    status_data["uptime"] = uptime_resp.split(":")[-1].strip()
+                else:
+                    status_data["uptime"] = uptime_resp.strip()
+            except Exception as e:
+                self.logger.warning("Could not get uptime for heartbeat: %s", e)
+                status_data["uptime"] = "error"
+            
+            # Publish all collected data to a single status/data topic
+            if status_data:
+                # Publish as JSON for structured data
+                payload = json.dumps(status_data)
+                self.mqtt_publisher.publish_simple("status/data", payload)
+            
+        except Exception as e:
+            self.logger.error("Error during status heartbeat: %s", e)
+
+        # Reschedule for next run
+        self._start_heartbeat_timer()
+
     def _handle_mqtt_command(self, command: str, payload: str) -> None:
         """Handles commands received via MQTT."""
         self.logger.info("Handling MQTT command: %s (payload: %s)", command, payload)
-        
-        if command == "version":
-            try:
-                # Send 'V' command and wait for response matching version pattern
-                # Perl: 'V\s.*SIGNAL(?:duino|ESP|STM).*(?:\s\d\d:\d\d:\d\d)'
-                version_pattern = re.compile(
-                    r"V\s.*SIGNAL(?:duino|ESP|STM).*", re.IGNORECASE
-                )
 
-                try:
-                    response = self.send_command(
-                        payload="V",
-                        expect_response=True,
-                        timeout=SDUINO_CMD_TIMEOUT,
-                        response_pattern=version_pattern,
-                    )
-                    self.logger.info("Got version response: %s", response)
-                    # Publish result back to MQTT
-                    # Topic: signalduino/messages/result/version
-                    # We need access to the client to publish ad-hoc messages or add a method to publisher
-                    if (
-                        self.mqtt_publisher
-                        and self.mqtt_publisher.client.is_connected()
-                    ):
-                        result_topic = (
-                            f"{self.mqtt_publisher.mqtt_topic}/result/{command}"
-                        )
-                        self.mqtt_publisher.client.publish(result_topic, response)
-
-                except SignalduinoCommandTimeout:
-                    self.logger.error("Timeout waiting for version response")
-                    if (
-                        self.mqtt_publisher
-                        and self.mqtt_publisher.client.is_connected()
-                    ):
-                        result_topic = (
-                            f"{self.mqtt_publisher.mqtt_topic}/error/{command}"
-                        )
-                        self.mqtt_publisher.client.publish(result_topic, "Timeout")
+        if not self.mqtt_publisher or not self.mqtt_publisher.is_connected():
+            self.logger.warning("Cannot handle MQTT command; publisher not connected.")
+            return
+
+        command_mapping = {
+            "version": self.commands.get_version,
+            "help": self.commands.get_help,
+            "free_ram": self.commands.get_free_ram,
+            "uptime": self.commands.get_uptime,
+        }
 
+        if command in command_mapping:
+            try:
+                # Execute the corresponding command method
+                response = command_mapping[command]()
+                
+                self.logger.info("Got response for %s: %s", command, response)
+                
+                # Publish result back to MQTT
+                # Topic: <mqtt_topic>/result/<command>
+                self.mqtt_publisher.publish_simple(f"result/{command}", response)
+
+            except SignalduinoCommandTimeout:
+                self.logger.error("Timeout waiting for command response: %s", command)
+                self.mqtt_publisher.publish_simple(f"error/{command}", "Timeout")
+                
             except Exception as e:
-                self.logger.error("Error executing version command: %s", e)
+                self.logger.error("Error executing command %s: %s", command, e)
+                self.mqtt_publisher.publish_simple(f"error/{command}", f"Error: {e}")
+
         else:
-            self.logger.warning("Unknown MQTT command: %s", command)
+            self.logger.warning("Unknown MQTT command: %s", command)
+            self.mqtt_publisher.publish_simple(f"error/{command}", "Unknown command")

signalduino/mqtt.py

@@ -7,19 +7,21 @@
 import paho.mqtt.client as mqtt
 
 from .types import DecodedMessage, RawFrame
+from .persistence import get_or_create_client_id
 
 class MqttPublisher:
     """Publishes DecodedMessage objects to an MQTT server and listens for commands."""
 
     def __init__(self, logger: Optional[logging.Logger] = None) -> None:
         self.logger = logger or logging.getLogger(__name__)
-        self.client = mqtt.Client()
+        client_id = get_or_create_client_id()
+        self.client = mqtt.Client(client_id=client_id)
         self.client.on_connect = self._on_connect
         self.client.on_disconnect = self._on_disconnect
 
         self.mqtt_host = os.environ.get("MQTT_HOST", "localhost")
         self.mqtt_port = int(os.environ.get("MQTT_PORT", 1883))
-        self.mqtt_topic = os.environ.get("MQTT_TOPIC", "signalduino/messages")
+        self.mqtt_topic = os.environ.get("MQTT_TOPIC", "signalduino")
         self.mqtt_username = os.environ.get("MQTT_USERNAME")
         self.mqtt_password = os.environ.get("MQTT_PASSWORD")
 
@@ -49,8 +51,8 @@ def _on_message(self, client: mqtt.Client, userdata: Any, msg: mqtt.MQTTMessage)
 
             if self.command_callback:
                 # Extract command from topic or payload
-                # Topic structure: signalduino/messages/commands/<command>
-                # Example: signalduino/messages/commands/version -> get version
+                # Topic structure: signalduino/commands/<command>
+                # Example: signalduino/commands/version -> get version
 
                 parts = msg.topic.split("/")
                 if "commands" in parts:
@@ -99,14 +101,31 @@ def _raw_frame_to_dict(raw_frame: RawFrame) -> dict:
 
         return json.dumps(message_dict, indent=4)
 
+    def is_connected(self) -> bool:
+        """Checks if the client is connected."""
+        return self.client.is_connected()
+
+    def publish_simple(self, subtopic: str, payload: str, retain: bool = False) -> None:
+        """Publishes a simple string payload to a subtopic of the main topic."""
+        if not self.is_connected():
+            self._connect_if_needed()
+        
+        if self.is_connected():
+            try:
+                topic = f"{self.mqtt_topic}/{subtopic}"
+                self.client.publish(topic, payload, retain=retain)
+                self.logger.debug("Published simple message to %s: %s", topic, payload)
+            except Exception:
+                self.logger.error("Failed to publish simple message to %s", subtopic, exc_info=True)
+
     def publish(self, message: DecodedMessage) -> None:
         """Publishes a DecodedMessage."""
-        if not self.client.is_connected():
+        if not self.is_connected():
             self._connect_if_needed()
 
-        if self.client.is_connected():
+        if self.is_connected():
             try:
-                topic = f"{self.mqtt_topic}/{message.protocol_id}"
+                topic = f"{self.mqtt_topic}/messages"
                 payload = self._message_to_json(message)
                 self.client.publish(topic, payload)
                 self.logger.debug("Published message for protocol %s to %s", message.protocol_id, topic)