Throttle hardware-trigger wait logs

Reduce log flooding when waiting for hardware triggers by adding throttled logging.

Changes in dlclivegui/services/multi_camera_controller.py:
- Import time.
- Add a new _log_interval_while_waiting_for_trigger_s attribute to SingleCameraWorker.
- Replace the direct LOGGER.debug call for expected trigger wait timeouts with a call to _log_trigger_wait_throttled.
- Implement _log_trigger_wait_throttled to suppress repeated timeout messages, emit a consolidated debug message, and report how many repeated logs were suppressed.

This prevents high-frequency expected poll-timeout logs (common in trigger-waiting modes) from overwhelming the logs.

Author: C-Achard

dlclivegui/services/multi_camera_controller.py

@@ -4,6 +4,7 @@
 
 import copy
 import logging
+import time
 from dataclasses import dataclass
 from threading import Event, Lock
 
@@ -50,6 +51,7 @@ def __init__(self, camera_id: str, settings: CameraSettings):
         self._max_consecutive_errors = 5
         self._retry_delay = 0.1
         self._trigger_timeout_delay = 0.05
+        self._log_interval_while_waiting_for_trigger_s = 2.0
 
         # Performance logs
         self._timing = WorkerTimingStats(
@@ -121,11 +123,7 @@ def run(self) -> None:
                 # "no trigger pulse arrived during this poll interval".
                 # This is expected and should not count as a camera failure.
                 if bool(getattr(self._backend, "waits_for_hardware_trigger", False)):
-                    LOGGER.debug(
-                        "[Worker %s] waiting for hardware trigger: %s",
-                        self._camera_id,
-                        exc,
-                    )
+                    self._log_trigger_wait_throttled(exc)
                     consecutive_errors = 0
 
                     if self._stop_event.wait(self._trigger_timeout_delay):
@@ -275,6 +273,36 @@ def _timing_for_camera(self, camera_id: str) -> WorkerTimingStats:
             self._timing_per_cam[camera_id] = timing
         return timing
 
+    def _log_trigger_wait_throttled(self, exc: BaseException) -> None:
+        """Log hardware-trigger wait timeouts at a controlled rate.
+
+        In trigger-waiting modes, read timeouts are expected polling misses.
+        Without throttling, the log can be flooded at ~10-20 messages/sec/camera.
+        """
+        now = time.monotonic()
+
+        if now - self._last_trigger_wait_log < self._trigger_wait_log_interval:
+            self._trigger_wait_suppressed_count += 1
+            return
+
+        suppressed = self._trigger_wait_suppressed_count
+        self._trigger_wait_suppressed_count = 0
+        self._last_trigger_wait_log = now
+
+        if suppressed:
+            LOGGER.debug(
+                "[Worker %s] waiting for hardware trigger: %s (suppressed %d repeated timeout logs)",
+                self._camera_id,
+                exc,
+                suppressed,
+            )
+        else:
+            LOGGER.debug(
+                "[Worker %s] waiting for hardware trigger: %s",
+                self._camera_id,
+                exc,
+            )
+
     def start(self, camera_settings: list[CameraSettings]) -> None:
         """Start multiple cameras; accepts dataclasses, pydantic models, or dicts."""
         if self._running: