feat: create runable program

Author: sidey79

main.py

@@ -0,0 +1,145 @@
+import argparse
+import logging
+import signal
+import sys
+import time
+import os
+import re
+from typing import Optional
+
+from signalduino.constants import SDUINO_CMD_TIMEOUT
+from signalduino.controller import SignalduinoController
+from signalduino.transport import SerialTransport, TCPTransport
+from signalduino.types import DecodedMessage
+
+# Konfiguration des Loggings
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
+logger = logging.getLogger("main")
+
+def message_callback(message: DecodedMessage):
+    """Callback-Funktion, die aufgerufen wird, wenn eine Nachricht dekodiert wurde."""
+    print("\n" + "="*50)
+    print(f"NEUE NACHRICHT EMPFANGEN (Protokoll-ID: {message.protocol_id})")
+    model = message.metadata.get("model", "Unbekannt")
+    print(f"Modell: {model}")
+    print(f"Payload: {message.payload}")
+    print("-" * 20)
+    print("Alle Felder:")
+    # Zeige Metadaten an
+    for key, value in message.metadata.items():
+        print(f"  {key}: {value}")
+    
+    # Zeige RawFrame-Infos an, falls vorhanden
+    if message.raw:
+        print("  Raw Frame Info:")
+        print(f"    Line: {message.raw.line}")
+        print(f"    Timestamp: {message.raw.timestamp}")
+        if message.raw.rssi:
+            print(f"    RSSI: {message.raw.rssi}")
+    print("="*50 + "\n")
+
+def main():
+    parser = argparse.ArgumentParser(description="Signalduino Python Controller")
+    
+    # Verbindungseinstellungen
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--serial", help="Serieller Port (z.B. /dev/ttyUSB0)")
+    group.add_argument("--tcp", help="TCP Host (z.B. 192.168.1.10)")
+    
+    parser.add_argument("--baud", type=int, default=57600, help="Baudrate für serielle Verbindung (Standard: 57600)")
+    parser.add_argument("--port", type=int, default=23, help="Port für TCP Verbindung (Standard: 23)")
+    parser.add_argument("--debug", action="store_true", help="Debug-Logging aktivieren")
+    
+    # MQTT Einstellungen (optional via CLI, sonst via ENV)
+    parser.add_argument("--mqtt-host", help="MQTT Broker Host")
+    parser.add_argument("--mqtt-port", type=int, help="MQTT Broker Port")
+    parser.add_argument("--mqtt-username", help="MQTT Broker Benutzername")
+    parser.add_argument("--mqtt-password", help="MQTT Broker Passwort")
+    
+    args = parser.parse_args()
+
+    # Logging Level anpassen
+    if args.debug:
+        logging.getLogger().setLevel(logging.DEBUG)
+        logger.debug("Debug-Modus aktiviert")
+
+    # MQTT Umgebungsvariablen setzen, falls über CLI übergeben
+    if args.mqtt_host:
+        os.environ["MQTT_HOST"] = args.mqtt_host
+    if args.mqtt_port:
+        os.environ["MQTT_PORT"] = str(args.mqtt_port)
+    if args.mqtt_username:
+        os.environ["MQTT_USERNAME"] = args.mqtt_username
+    if args.mqtt_password:
+        os.environ["MQTT_PASSWORD"] = args.mqtt_password
+
+    # Transport initialisieren
+    transport = None
+    if args.serial:
+        logger.info(f"Initialisiere serielle Verbindung auf {args.serial} mit {args.baud} Baud...")
+        transport = SerialTransport(port=args.serial, baudrate=args.baud)
+    elif args.tcp:
+        logger.info(f"Initialisiere TCP Verbindung zu {args.tcp}:{args.port}...")
+        transport = TCPTransport(host=args.tcp, port=args.port)
+
+    if not transport:
+        logger.error("Kein gültiger Transport konfiguriert.")
+        sys.exit(1)
+
+    # Controller initialisieren
+    controller = SignalduinoController(
+        transport=transport,
+        message_callback=message_callback,
+        logger=logger
+    )
+
+    # Graceful Shutdown Handler
+    def signal_handler(sig, frame):
+        logger.info("Programm wird beendet...")
+        controller.disconnect()
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    # Starten
+    try:
+        logger.info("Verbinde zum Signalduino...")
+        controller.connect()
+        logger.info("Verbunden! Drücke Ctrl+C zum Beenden.")
+        
+        # Sende Versionsabfrage zum Test
+        logger.info("Sende Versionsabfrage (V)...")
+        # 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
+        )
+        version = controller.send_command(
+            "V",
+            expect_response=True,
+            timeout=SDUINO_CMD_TIMEOUT,
+            response_pattern=version_pattern,
+        )
+        if version:
+            logger.info(f"Signalduino Version: {version.strip()}")
+        else:
+            logger.warning("Keine Antwort auf Versionsabfrage erhalten.")
+
+        # Hauptschleife
+        while True:
+            time.sleep(1)
+
+    except Exception as e:
+        logger.error(f"Ein Fehler ist aufgetreten: {e}", exc_info=True)
+        controller.disconnect()
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

sd_protocols/pattern_utils.py

@@ -71,8 +71,8 @@ def pattern_exists(search_pattern: List[float], pattern_list: Dict[str, float],
 
         for pid, pval in pattern_list.items():
             gap = abs(pval - search_val)
-            if gap <= tol:
-                weighted_matches.append((gap, str(pid)))
+            if gap <= 0.001 or gap <= tol: # The gap is likely 0.0 for exact match, add a small tolerance to guarantee it
+                weighted_matches.append((gap, pid))
 
         if not weighted_matches:
             # If any value has no candidates, the pattern cannot exist

signalduino/constants.py

@@ -4,7 +4,7 @@
 SDUINO_INIT_WAIT_XQ = 1.5
 SDUINO_INIT_WAIT = 2.0
 SDUINO_INIT_MAXRETRY = 3
-SDUINO_CMD_TIMEOUT = 10
+SDUINO_CMD_TIMEOUT = 10.0
 SDUINO_KEEPALIVE_TIMEOUT = 60
 SDUINO_KEEPALIVE_MAXRETRY = 3
 SDUINO_WRITEQUEUE_NEXT = 0.3

signalduino/controller.py

@@ -2,10 +2,13 @@
 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
+from typing import Any, Callable, List, Literal, Optional, Pattern
 
+from .constants import SDUINO_CMD_TIMEOUT
 from .exceptions import SignalduinoCommandTimeout, SignalduinoConnectionError
+from .mqtt import MqttPublisher # NEU: MQTT-Import
 from .parser import SignalParser
 from .transport import BaseTransport
 from .types import DecodedMessage, PendingResponse, QueuedCommand
@@ -26,6 +29,13 @@ def __init__(
         self.message_callback = message_callback
         self.logger = logger or logging.getLogger(__name__)
 
+        # NEU: MQTT Publisher initialisieren
+        self.mqtt_publisher: Optional[MqttPublisher] = None
+        if os.environ.get("MQTT_HOST"):
+            # Nur initialisieren, wenn MQTT-Host konfiguriert ist
+            self.mqtt_publisher = MqttPublisher(logger=self.logger)
+            self.mqtt_publisher.register_command_callback(self._handle_mqtt_command)
+
         self._reader_thread: Optional[threading.Thread] = None
         self._parser_thread: Optional[threading.Thread] = None
         self._writer_thread: Optional[threading.Thread] = None
@@ -68,6 +78,10 @@ def disconnect(self) -> None:
         self.logger.info("Disconnecting...")
         self._stop_event.set()
 
+        # NEU: MQTT Publisher stoppen
+        if self.mqtt_publisher:
+            self.mqtt_publisher.stop()
+
         # Wake up threads that might be waiting on queues
         self._raw_message_queue.put("")
         self._write_queue.put(QueuedCommand("", 0))
@@ -113,6 +127,12 @@ def _parser_loop(self) -> None:
 
                 decoded_messages = self.parser.parse_line(raw_line)
                 for message in decoded_messages:
+                    if self.mqtt_publisher:
+                        try:
+                            self.mqtt_publisher.publish(message)
+                        except Exception:
+                            self.logger.exception("Error in MQTT publish")
+
                     if self.message_callback:
                         try:
                             self.message_callback(message)
@@ -241,7 +261,11 @@ def send_message(self, message: str) -> None:
         self.send_command(message)
 
     def send_command(
-        self, payload: str, expect_response: bool = False, timeout: float = 2.0
+        self,
+        payload: str,
+        expect_response: bool = False,
+        timeout: float = 2.0,
+        response_pattern: Optional[Pattern[str]] = None,
     ) -> Optional[str]:
         """Queues a command and optionally waits for a specific response."""
         if not self.transport.is_open:
@@ -256,11 +280,16 @@ def send_command(
         def on_response(response: str):
             response_queue.put(response)
 
+        if response_pattern is None:
+            response_pattern = re.compile(
+                f".*{re.escape(payload)}.*|.*OK.*", re.IGNORECASE
+            )
+
         command = QueuedCommand(
             payload=payload,
             timeout=timeout,
             expect_response=True,
-            response_pattern=re.compile(f".*{re.escape(payload)}.*|.*OK.*", re.IGNORECASE),
+            response_pattern=response_pattern,
             on_response=on_response,
             description=payload,
         )
@@ -270,4 +299,52 @@ def on_response(response: str):
         try:
             return response_queue.get(timeout=timeout)
         except queue.Empty:
-            raise SignalduinoCommandTimeout(f"Command '{payload}' timed out")
+            raise SignalduinoCommandTimeout(f"Command '{payload}' timed out")
+
+    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")
+
+            except Exception as e:
+                self.logger.error("Error executing version command: %s", e)
+        else:
+            self.logger.warning("Unknown MQTT command: %s", command)

signalduino/transport.py

@@ -65,7 +65,7 @@ def is_open(self) -> bool:
     def write_line(self, data: str) -> None:
         if not self._serial or not self._serial.is_open:
             raise SignalduinoConnectionError("serial port is not open")
-        payload = (data + "\n").encode("ascii", errors="ignore")
+        payload = (data + "\n").encode("latin-1", errors="ignore")
         self._serial.write(payload)
 
     def readline(self, timeout: Optional[float] = None) -> Optional[str]:
@@ -74,7 +74,7 @@ def readline(self, timeout: Optional[float] = None) -> Optional[str]:
         if timeout is not None:
             self._serial.timeout = timeout
         raw = self._serial.readline()
-        return raw.decode("ascii", errors="ignore") if raw else None
+        return raw.decode("latin-1", errors="ignore") if raw else None
 
 
 class TCPTransport(BaseTransport):
@@ -107,7 +107,7 @@ def is_open(self) -> bool:
     def write_line(self, data: str) -> None:
         if not self._sock:
             raise SignalduinoConnectionError("socket is not open")
-        payload = (data + "\n").encode("ascii", errors="ignore")
+        payload = (data + "\n").encode("latin-1", errors="ignore")
         self._sock.sendall(payload)
 
     def readline(self, timeout: Optional[float] = None) -> Optional[str]:
@@ -119,9 +119,13 @@ def readline(self, timeout: Optional[float] = None) -> Optional[str]:
         while True:
             if b"\n" in self._buffer:
                 line, _, self._buffer = self._buffer.partition(b"\n")
-                return line.decode("ascii", errors="ignore")
+                return line.decode("latin-1", errors="ignore")
 
-            chunk = self._sock.recv(4096)
-            if not chunk:
+            try:
+                chunk = self._sock.recv(4096)
+            except socket.timeout:
                 return None
+
+            if not chunk:
+                raise SignalduinoConnectionError("Remote closed connection")
             self._buffer.extend(chunk)