conson-xp 1.3.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

xp/services/server/server_service.py

@@ -71,6 +71,13 @@ class ServerService:
             ],
         ] = {}  # serial -> device service instance
 
+        # Collect device buffer to broadcast to client
+        self.collector_thread: Optional[threading.Thread] = (
+            None  # Background thread for storm
+        )
+        self.collector_stop_event = threading.Event()  # Event to stop thread
+        self.collector_buffer: list[str] = []  # All collected buffers
+
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
@@ -167,6 +174,8 @@ class ServerService:
             self.server_socket.bind(("0.0.0.0", self.port))
             self.server_socket.listen(1)  # Accept single connection as per spec
 
+            self._start_device_collector_thread()
+
             self.is_running = True
             self.logger.info(f"Conbus emulator server started on port {self.port}")
             self.logger.info(
@@ -221,17 +230,44 @@ class ServerService:
     ) -> None:
         """Handle individual client connection."""
         try:
+
+            idle_timeout = 300
+            rcv_timeout = 10
+
             # Set timeout for idle connections (30 seconds as per spec)
-            client_socket.settimeout(300.0)
+            client_socket.settimeout(rcv_timeout)
+            timeout = idle_timeout / rcv_timeout
 
             while True:
+
+                # send waiting buffer
+                for i in range(len(self.collector_buffer)):
+                    buffer = self.collector_buffer.pop()
+                    client_socket.send(buffer.encode("latin-1"))
+                    self.logger.debug(f"Sent buffer to {client_address}")
+
                 # Receive data from client
-                data = client_socket.recv(1024)
+                self.logger.debug(f"Receiving data {client_address}")
+                data = None
+                try:
+                    data = client_socket.recv(1024)
+                except socket.timeout:
+                    self.logger.debug(
+                        f"Timeout receiving data {client_address} ({timeout})"
+                    )
+                finally:
+                    timeout -= 1
+
                 if not data:
-                    break
+                    if timeout <= 0:
+                        break
+                    continue
+
+                # reset timeout on receiving data
+                timeout = idle_timeout / rcv_timeout
 
                 message = data.decode("latin-1").strip()
-                self.logger.info(f"Received from {client_address}: {message}")
+                self.logger.debug(f"Received from {client_address}: {message}")
 
                 # Process request (discover or data request)
                 responses = self._process_request(message)
@@ -239,10 +275,10 @@ class ServerService:
                 # Send responses
                 for response in responses:
                     client_socket.send(response.encode("latin-1"))
-                    self.logger.info(f"Sent to {client_address}: {response[:-1]}")
+                    self.logger.debug(f"Sent to {client_address}: {response[:-1]}")
 
         except socket.timeout:
-            self.logger.info(f"Client {client_address} timed out")
+            self.logger.debug(f"Client {client_address} timed out")
         except Exception as e:
             self.logger.error(f"Error handling client {client_address}: {e}")
         finally:
@@ -253,15 +289,86 @@ class ServerService:
                 self.logger.error(f"Error closing client socket: {e}")
 
     def _process_request(self, message: str) -> List[str]:
-        """Process incoming request and generate responses."""
+        """Process incoming request and generate responses.
+
+        Args:
+            message: Message potentially containing multiple telegrams in format <TELEGRAM><TELEGRAM2>...
+
+        Returns:
+            List of responses for all processed telegrams.
+        """
+        responses: list[str] = []
+
+        try:
+            # Split message into individual telegrams (enclosed in angle brackets)
+            telegrams = self._split_telegrams(message)
+
+            if not telegrams:
+                self.logger.warning(f"No valid telegrams found in message: {message}")
+                return responses
+
+            # Process each telegram
+            for telegram in telegrams:
+                telegram_responses = self._process_single_telegram(telegram)
+                responses.extend(telegram_responses)
+
+        except Exception as e:
+            self.logger.error(f"Error processing request: {e}")
+
+        return responses
+
+    def _split_telegrams(self, message: str) -> List[str]:
+        """Split message into individual telegrams.
+
+        Args:
+            message: Raw message containing one or more telegrams in format <TELEGRAM><TELEGRAM2>...
+
+        Returns:
+            List of individual telegram strings including angle brackets.
+        """
+        telegrams = []
+        start = 0
+
+        while True:
+            # Find the start of a telegram
+            start_idx = message.find("<", start)
+            if start_idx == -1:
+                break
+
+            # Find the end of the telegram
+            end_idx = message.find(">", start_idx)
+            if end_idx == -1:
+                self.logger.warning(
+                    f"Incomplete telegram found starting at position {start_idx}"
+                )
+                break
+
+            # Extract telegram including angle brackets
+            telegram = message[start_idx : end_idx + 1]
+            telegrams.append(telegram)
+
+            # Move to the next position
+            start = end_idx + 1
+
+        return telegrams
+
+    def _process_single_telegram(self, telegram: str) -> List[str]:
+        """Process a single telegram and generate responses.
+
+        Args:
+            telegram: A single telegram string.
+
+        Returns:
+            List of response strings for this telegram.
+        """
         responses: list[str] = []
 
         try:
             # Parse the telegram
-            parsed_telegram = self.telegram_service.parse_system_telegram(message)
+            parsed_telegram = self.telegram_service.parse_system_telegram(telegram)
 
             if not parsed_telegram:
-                self.logger.warning(f"Failed to parse telegram: {message}")
+                self.logger.warning(f"Failed to parse telegram: {telegram}")
                 return responses
 
             # Handle discover requests
@@ -296,7 +403,7 @@ class ServerService:
                         )
 
         except Exception as e:
-            self.logger.error(f"Error processing request: {e}")
+            self.logger.error(f"Error processing telegram: {e}")
 
         return responses
 
@@ -319,3 +426,48 @@ class ServerService:
         self.logger.info(
             f"Configuration reloaded: {len(self.devices)} devices, {len(self.device_services)} services"
         )
+
+    def _start_device_collector_thread(self) -> None:
+        """Start device buffer collector thread."""
+        if self.collector_thread and self.collector_thread.is_alive():
+            self.logger.debug("Collector thread already running")
+            return
+
+        # Start background thread to send storm telegrams
+        self.collector_thread = threading.Thread(
+            target=self._device_collector_thread, daemon=True, name="DeviceCollector"
+        )
+        self.collector_thread.start()
+        self.logger.info("Collector thread started")
+
+    def _stop_device_collector_thread(self) -> None:
+        """Stop device buffer collector thread."""
+        if not self.collector_thread or not self.collector_thread.is_alive():
+            self.logger.debug("Collector thread not running")
+            return
+
+        self.logger.info(f"Stopping collector thread: {self.collector_thread.name}")
+
+        # Wait for thread to finish (with timeout)
+        if self.collector_thread and self.collector_thread.is_alive():
+            self.collector_thread.join(timeout=1.0)
+
+            self.logger.info("Collector stopped.")
+
+    def _device_collector_thread(self) -> None:
+        """Device buffer collector thread."""
+        self.logger.info("Collector thread starting")
+
+        while True:
+            self.logger.debug(
+                f"Collector thread collecting ({len(self.collector_buffer)})"
+            )
+            collected = 0
+            for device_service in self.device_services.values():
+                telegram_buffer = device_service.collect_telegram_buffer()
+                self.collector_buffer.extend(telegram_buffer)
+                collected += len(telegram_buffer)
+
+            # Wait a bit before checking again
+            self.logger.debug(f"Collector thread collected ({collected})")
+            self.collector_stop_event.wait(timeout=1)

xp/services/server/xp130_server_service.py

@@ -7,6 +7,7 @@ XP130 is an Ethernet/TCPIP interface module.
 
 from typing import Dict
 
+from xp.models import ModuleTypeCode
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -32,7 +33,7 @@ class XP130ServerService(BaseServerService):
         """
         super().__init__(serial_number)
         self.device_type = "XP130"
-        self.module_type_code = 13  # XP130 module type from registry
+        self.module_type_code = ModuleTypeCode.XP130  # XP130 module type from registry
         self.firmware_version = "XP130_V1.02.15"
 
         # XP130-specific network configuration

xp/services/server/xp20_server_service.py

@@ -6,6 +6,7 @@ including response generation and device configuration handling.
 
 from typing import Dict
 
+from xp.models import ModuleTypeCode
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -31,7 +32,7 @@ class XP20ServerService(BaseServerService):
         """
         super().__init__(serial_number)
         self.device_type = "XP20"
-        self.module_type_code = 33  # XP20 module type from registry
+        self.module_type_code = ModuleTypeCode.XP20  # XP20 module type from registry
         self.firmware_version = "XP20_V0.01.05"
 
     def get_device_info(self) -> Dict:

xp/services/server/xp230_server_service.py

@@ -6,6 +6,7 @@ including response generation and device configuration handling.
 
 from typing import Dict
 
+from xp.models import ModuleTypeCode
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -31,7 +32,7 @@ class XP230ServerService(BaseServerService):
         """
         super().__init__(serial_number)
         self.device_type = "XP230"
-        self.module_type_code = 34  # XP230 module type from registry
+        self.module_type_code = ModuleTypeCode.XP230  # XP230 module type from registry
         self.firmware_version = "XP230_V1.00.04"
 
     def get_device_info(self) -> Dict:

xp/services/server/xp24_server_service.py

@@ -6,6 +6,7 @@ including response generation and device configuration handling.
 
 from typing import Dict, Optional
 
+from xp.models import ModuleTypeCode
 from xp.models.telegram.datapoint_type import DataPointType
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.system_telegram import SystemTelegram
@@ -18,6 +19,16 @@ class XP24ServerError(Exception):
     pass
 
 
+class XP24Output:
+    """Represents an XP24 output state.
+
+    Attributes:
+        state: Current state of the output (True=on, False=off).
+    """
+
+    state: bool = False
+
+
 class XP24ServerService(BaseServerService):
     """
     XP24 device emulation service.
@@ -34,30 +45,107 @@ class XP24ServerService(BaseServerService):
         """
         super().__init__(serial_number)
         self.device_type = "XP24"
-        self.module_type_code = 7  # XP24 module type from registry
+        self.module_type_code = ModuleTypeCode.XP24
+        self.autoreport_status = True
         self.firmware_version = "XP24_V0.34.03"
+        self.output_0: XP24Output = XP24Output()
+        self.output_1: XP24Output = XP24Output()
+        self.output_2: XP24Output = XP24Output()
+        self.output_3: XP24Output = XP24Output()
+
+    def _handle_device_specific_action_request(
+        self, request: SystemTelegram
+    ) -> Optional[str]:
+        """Handle XP24-specific data requests."""
+        telegrams = self._handle_action_module_output_state(request.data)
+        self.logger.debug(
+            f"Generated {self.device_type} module type responses: {telegrams}"
+        )
+        return telegrams
+
+    def _handle_action_module_output_state(self, data_value: str) -> str:
+        """Handle XP24-specific module output state."""
+        output_number = int(data_value[:2])
+        output_state = data_value[2:]
+        if output_number not in range(0, 4):
+            return self._build_ack_nak_response_telegram(False)
+
+        if output_state not in ("AA", "AB"):
+            return self._build_ack_nak_response_telegram(False)
+
+        output = (self.output_0, self.output_1, self.output_2, self.output_3)[
+            output_number
+        ]
+        previous_state = output.state
+        output.state = True if output_state == "AB" else False
+        state_changed = previous_state != output.state
+
+        telegrams = self._build_ack_nak_response_telegram(True)
+        if state_changed and self.autoreport_status:
+            telegrams += self._build_make_break_response_telegram(
+                output.state, output_number
+            )
+
+        return telegrams
+
+    def _build_ack_nak_response_telegram(self, ack_or_nak: bool) -> str:
+        """Build a complete ACK or NAK response telegram with checksum.
+
+        Args:
+            ack_or_nak: true: ACK telegram response, false: NAK telegram response.
+
+        Returns:
+            The complete telegram with checksum enclosed in angle brackets.
+        """
+        data_value = (
+            SystemFunction.ACK.value if ack_or_nak else SystemFunction.NAK.value
+        )
+        data_part = f"R{self.serial_number}" f"F{data_value:02}D"
+        return self._build_response_telegram(data_part)
+
+    def _build_make_break_response_telegram(
+        self, make_or_break: bool, output_number: int
+    ) -> str:
+        """Build a complete ACK or NAK response telegram with checksum.
+
+        Args:
+            make_or_break: true: MAKE event response, false: BREAK event response.
+            output_number: output concerned
+
+        Returns:
+            The complete event telegram with checksum enclosed in angle brackets.
+        """
+        data_value = "M" if make_or_break else "B"
+        data_part = (
+            f"E{self.module_type_code.value:02}"
+            f"L{self.link_number:02}"
+            f"I{output_number:02}"
+            f"{data_value}"
+        )
+        return self._build_response_telegram(data_part)
 
     def _handle_device_specific_data_request(
         self, request: SystemTelegram
     ) -> Optional[str]:
         """Handle XP24-specific data requests."""
-        if (
-            request.system_function != SystemFunction.READ_DATAPOINT
-            or not request.datapoint_type
-        ):
+        if not request.datapoint_type:
             return None
 
         datapoint_type = request.datapoint_type
-        datapoint_values = {
-            DataPointType.MODULE_OUTPUT_STATE: "xxxx0001",
-            DataPointType.MODULE_STATE: "OFF",
-            DataPointType.MODULE_OPERATING_HOURS: "00:000[H],01:000[H],02:000[H],03:000[H]",
-        }
+        handler = {
+            DataPointType.MODULE_OUTPUT_STATE: self._handle_read_module_output_state,
+            DataPointType.MODULE_STATE: self._handle_read_module_state,
+            DataPointType.MODULE_OPERATING_HOURS: self._handle_read_module_operating_hours,
+        }.get(datapoint_type)
+        if not handler:
+            return None
+
+        data_value = handler()
         data_part = (
             f"R{self.serial_number}"
-            f"F02{datapoint_type.value}"
-            f"{self.module_type_code}"
-            f"{datapoint_values.get(datapoint_type)}"
+            f"F02D{datapoint_type.value}"
+            f"{self.module_type_code.value:02}"
+            f"{data_value}"
         )
         telegram = self._build_response_telegram(data_part)
 
@@ -66,21 +154,26 @@ class XP24ServerService(BaseServerService):
         )
         return telegram
 
-    def _handle_device_specific_action_request(
-        self, request: SystemTelegram
-    ) -> Optional[str]:
-        """Handle XP24-specific action requests.
-
-        Args:
-            request: The system telegram request.
-
-        Returns:
-            The response telegram string, or None if request cannot be handled.
-        """
-        if request.system_function != SystemFunction.ACTION:
-            return None
-
-        return self.generate_action_response(request)
+    def _handle_read_module_operating_hours(self) -> str:
+        """Handle XP24-specific module operating hours."""
+        return "00:000[H],01:000[H],02:000[H],03:000[H]"
+
+    def _handle_read_module_state(self) -> str:
+        """Handle XP24-specific module state."""
+        for output in (self.output_0, self.output_1, self.output_2, self.output_3):
+            if output.state:
+                return "ON"
+        return "OFF"
+
+    def _handle_read_module_output_state(self) -> str:
+        """Handle XP24-specific module output state."""
+        return (
+            f"xxxx"
+            f"{1 if self.output_0.state else 0}"
+            f"{1 if self.output_1.state else 0}"
+            f"{1 if self.output_2.state else 0}"
+            f"{1 if self.output_3.state else 0}"
+        )
 
     def get_device_info(self) -> Dict:
         """Get XP24 device information.
@@ -91,29 +184,9 @@ class XP24ServerService(BaseServerService):
         return {
             "serial_number": self.serial_number,
             "device_type": self.device_type,
+            "module_type_code": self.module_type_code.value,
             "firmware_version": self.firmware_version,
             "status": self.device_status,
             "link_number": self.link_number,
+            "autoreport_status": self.autoreport_status,
         }
-
-    def generate_action_response(self, request: SystemTelegram) -> Optional[str]:
-        """Generate action response telegram (simulated).
-
-        Args:
-            request: The system telegram request.
-
-        Returns:
-            The ACK or NAK response telegram string.
-        """
-        response = "F19D"  # NAK
-        if (
-            request.system_function == SystemFunction.ACTION
-            and request.data[:2] in ("00", "01", "02", "03")
-            and request.data[2:] in ("AA", "AB")
-        ):
-            response = "F18D"  # ACK
-
-        data_part = f"R{self.serial_number}{response}"
-        telegram = self._build_response_telegram(data_part)
-        self._log_response("module_action_response", telegram)
-        return telegram