Add GenTL strobe support and trigger debugging

Add debugging helpers for GenTL trigger and frame-rate nodes and log their values during camera configuration. Improve GenTL trigger input handling by treating TriggerSource as best-effort (supporting read-only/auto cases) and emitting clearer warnings. Implement a dedicated master/output path for TIS/DMK 37U cameras using Strobe* nodes (StrobeEnable/Polarity/Operation/Duration/Delay) with a fallback to generic Line* configuration; respect strict mode and surface informative errors. Extend CameraTriggerSettings with strobe fields (polarity, operation, duration, delay) and validation/coercion. Update the trigger configuration dialog to expose strobe controls, tooltips, UI sync logic, and include strobe values in the saved payload.

Author: C-Achard

dlclivegui/cameras/backends/gentl_backend.py

@@ -192,6 +192,89 @@ def static_capabilities(cls) -> dict[str, SupportLevel]:
             "hardware_trigger": SupportLevel.BEST_EFFORT,
         }
 
+    def _debug_trigger_nodes(self, node_map, *, context: str = "") -> None:
+        names = (
+            "TriggerMode",
+            "TriggerSelector",
+            "TriggerSource",
+            "TriggerActivation",
+            "AcquisitionMode",
+            # Generic line nodes, if available.
+            "LineSelector",
+            "LineMode",
+            "LineSource",
+            # TIS 37U / DMK 37BUX287 strobe/output nodes.
+            "GPIn",
+            "GPOut",
+            "StrobeEnable",
+            "StrobePolarity",
+            "StrobeOperation",
+            "StrobeDuration",
+            "StrobeDelay",
+        )
+
+        label = f"GenTL trigger debug {context}".strip()
+
+        for name in names:
+            node = self._node(node_map, name)
+            if node is None:
+                continue
+
+            value = self._node_value(node_map, name, None)
+
+            extras = []
+
+            symbolics = self._node_symbolics(node)
+            if symbolics:
+                extras.append(f"symbolics={symbolics}")
+
+            for attr in ("access_mode", "is_writable", "is_readable"):
+                try:
+                    extras.append(f"{attr}={getattr(node, attr)}")
+                except Exception:
+                    pass
+
+            LOG.debug("%s: %s=%r %s", label, name, value, " ".join(extras))
+
+    def _debug_frame_rate_nodes(self, node_map, *, context: str = "") -> None:
+        names = (
+            "AcquisitionFrameRateEnable",
+            "AcquisitionFrameRateControlEnable",
+            "AcquisitionFrameRate",
+            "AcquisitionFrameRateAbs",
+            "AcquisitionResultingFrameRate",
+            "ResultingFrameRate",
+            "AcquisitionFrameRateResulting",
+            "DeviceFrameRate",
+            "ExposureAuto",
+            "ExposureTime",
+            "ExposureTimeAbs",
+            "DeviceLinkThroughputLimit",
+            "DeviceLinkThroughputLimitMode",
+            "PayloadSize",
+            "Width",
+            "Height",
+            "PixelFormat",
+        )
+
+        label = f"GenTL FPS debug {context}".strip()
+
+        for name in names:
+            node = self._node(node_map, name)
+            if node is None:
+                continue
+
+            value = self._node_value(node_map, name, None)
+
+            extras = []
+            for attr in ("min", "max", "inc"):
+                try:
+                    extras.append(f"{attr}={getattr(node, attr)}")
+                except Exception:
+                    pass
+
+            LOG.debug("%s: %s=%r %s", label, name, value, " ".join(extras))
+
     # ------------------------------------------------------------------
     # Discovery
     # ------------------------------------------------------------------
@@ -464,6 +547,7 @@ def open(self) -> None:
                     self._configure_gain(node_map)
                     self._configure_frame_rate(node_map)
                     self._configure_trigger(node_map)  # keep low in the list
+                    self._debug_trigger_nodes(node_map, context="after configuration before acquisition")
                     self._ensure_settings_ns()["trigger_actual"] = self._trigger_to_dict(self._trigger)
                     self._read_telemetry(node_map)
                     self._persist_device_metadata(selected_info, selected_serial)
@@ -1186,31 +1270,42 @@ def _configure_trigger_off(self, node_map, *, strict: bool = False) -> None:
     def _configure_trigger_input(self, node_map, cfg, *, strict: bool = False) -> None:
         role = str(self._trigger_attr(cfg, "role", "external") or "external").strip().lower()
         selector = str(self._trigger_attr(cfg, "selector", "FrameStart") or "FrameStart")
-        source = str(self._trigger_attr(cfg, "source", "Line0") or "Line0")
         activation = str(self._trigger_attr(cfg, "activation", "RisingEdge") or "RisingEdge")
+        source = str(self._trigger_attr(cfg, "source", "auto") or "auto").strip()
 
         # Disable trigger while changing trigger-related nodes.
         self._set_enum_node(node_map, "TriggerMode", "Off", strict=False)
 
         selector_ok = self._set_enum_node(node_map, "TriggerSelector", selector, strict=strict)
-        source, source_resolved = self._resolve_trigger_source(node_map, source, strict=strict)
-        source_ok = source_resolved and self._set_enum_node(node_map, "TriggerSource", source, strict=strict)
         activation_ok = self._set_enum_node(node_map, "TriggerActivation", activation, strict=strict)
 
-        # TriggerSelector and TriggerSource are required routing nodes.
-        # If either failed in non-strict mode, do not arm TriggerMode=On.
-        # Otherwise the camera may wait on a previous/default input line.
-        if not (selector_ok and source_ok):
+        source_ok = False
+        if source and source.lower() not in {"", "auto", "none"}:
+            source_node = self._node(node_map, "TriggerSource")
+            source_symbolics = self._node_symbolics(source_node)
+
+            if source_node is not None:
+                if source in source_symbolics:
+                    source_ok = self._set_enum_node(node_map, "TriggerSource", source, strict=False)
+                    if not source_ok:
+                        LOG.warning(
+                            "GenTL TriggerSource=%s is supported but not writable; "
+                            "continuing without changing TriggerSource. Available: %s",
+                            source,
+                            source_symbolics,
+                        )
+                else:
+                    LOG.warning(
+                        "Requested GenTL TriggerSource=%s not in available sources %s; "
+                        "continuing without changing TriggerSource.",
+                        source,
+                        source_symbolics,
+                    )
+
+        if not selector_ok:
             LOG.warning(
-                "Could not apply GenTL trigger input routing "
-                "(selector_ok=%s, source_ok=%s); disabling trigger. "
-                "requested role=%s selector=%s source=%s activation=%s",
-                selector_ok,
-                source_ok,
-                role,
+                "Could not apply GenTL TriggerSelector=%s; disabling trigger.",
                 selector,
-                source,
-                activation,
             )
             self._configure_trigger_off(node_map, strict=False)
             self._trigger = CameraTriggerSettings()
@@ -1231,55 +1326,153 @@ def _configure_trigger_input(self, node_map, cfg, *, strict: bool = False) -> No
             return
 
         LOG.info(
-            "GenTL trigger input configured: role=%s selector=%s source=%s activation=%s activation_ok=%s",
+            "GenTL trigger input configured: role=%s selector=%s activation=%s "
+            "selector_ok=%s activation_ok=%s source_requested=%s source_ok=%s",
             role,
             selector,
-            source,
             activation,
+            selector_ok,
             activation_ok,
+            source,
+            source_ok,
         )
 
     def _configure_trigger_master(self, node_map, cfg, *, strict: bool = False) -> None:
+        """Configure this camera as a free-running master that emits STROBE_OUT pulses.
+
+        For DMK 37BUX287 / TIS 37U series, the physical output is controlled by
+        StrobeEnable/StrobePolarity/StrobeOperation rather than SFNC LineSelector/
+        LineMode/LineSource nodes.
+        """
         output_line = str(self._trigger_attr(cfg, "output_line", "Line2") or "Line2")
         output_source = str(self._trigger_attr(cfg, "output_source", "ExposureActive") or "ExposureActive")
 
-        # Master camera runs freerun and exposes an output signal.
+        # Optional extra fields if present in trigger dict/model.
+        strobe_polarity = str(self._trigger_attr(cfg, "strobe_polarity", "ActiveHigh") or "ActiveHigh")
+        strobe_operation = str(self._trigger_attr(cfg, "strobe_operation", "Exposure") or "Exposure")
+        strobe_duration = self._trigger_attr(cfg, "strobe_duration", None)
+        strobe_delay = self._trigger_attr(cfg, "strobe_delay", None)
+
+        # Master camera should be free-running.
         self._configure_trigger_off(node_map, strict=False)
 
-        line_selected = self._set_enum_node(
-            node_map,
-            "LineSelector",
-            output_line,
-            strict=strict,
-        )
+        # ------------------------------------------------------------------
+        # Preferred path for The Imaging Source 37U / DMK 37BUX287:
+        # StrobeEnable, StrobePolarity, StrobeOperation, StrobeDuration, StrobeDelay
+        # ------------------------------------------------------------------
+        strobe_enable_node = self._node(node_map, "StrobeEnable")
+
+        if strobe_enable_node is not None:
+            # Disable first while changing parameters.
+            self._set_enum_node(node_map, "StrobeEnable", "Off", strict=False)
+
+            polarity_ok = self._set_enum_node(
+                node_map,
+                "StrobePolarity",
+                strobe_polarity,
+                strict=False,
+            )
 
-        # In non-strict mode, do not continue configuring output behavior if the
-        # requested line could not be selected. Otherwise we may accidentally drive
-        # whichever GPIO line the camera had selected previously/defaulted to.
-        if not line_selected:
-            LOG.warning(
-                "Could not select GenTL output line '%s'; skipping trigger output configuration.",
-                output_line,
+            operation_ok = self._set_enum_node(
+                node_map,
+                "StrobeOperation",
+                strobe_operation,
+                strict=False,
             )
-            return
 
-        mode_ok = self._set_enum_node(node_map, "LineMode", "Output", strict=strict)
-        source_ok = self._set_enum_node(node_map, "LineSource", output_source, strict=strict)
+            if strobe_duration is not None:
+                try:
+                    node = self._node(node_map, "StrobeDuration")
+                    if node is not None:
+                        node.value = int(strobe_duration)
+                        LOG.info("Configured GenTL StrobeDuration=%s", int(strobe_duration))
+                except Exception as exc:
+                    if strict:
+                        raise RuntimeError(f"Failed to set StrobeDuration={strobe_duration}: {exc}") from exc
+                    LOG.warning("Failed to set StrobeDuration=%s: %s", strobe_duration, exc)
+
+            if strobe_delay is not None:
+                try:
+                    node = self._node(node_map, "StrobeDelay")
+                    if node is not None:
+                        node.value = int(strobe_delay)
+                        LOG.info("Configured GenTL StrobeDelay=%s", int(strobe_delay))
+                except Exception as exc:
+                    if strict:
+                        raise RuntimeError(f"Failed to set StrobeDelay={strobe_delay}: {exc}") from exc
+                    LOG.warning("Failed to set StrobeDelay=%s: %s", strobe_delay, exc)
+
+            enable_ok = self._set_enum_node(
+                node_map,
+                "StrobeEnable",
+                "On",
+                strict=strict,
+            )
+
+            if enable_ok:
+                LOG.info(
+                    "GenTL trigger master configured via Strobe*: "
+                    "StrobeEnable=On StrobePolarity=%s polarity_ok=%s "
+                    "StrobeOperation=%s operation_ok=%s",
+                    strobe_polarity,
+                    polarity_ok,
+                    strobe_operation,
+                    operation_ok,
+                )
+                return
+
+            if strict:
+                raise RuntimeError("Could not enable GenTL StrobeEnable=On")
 
-        if not (mode_ok and source_ok):
             LOG.warning(
-                "GenTL trigger master output configuration incomplete (LineMode ok=%s, LineSource ok=%s).",
-                mode_ok,
-                source_ok,
+                "StrobeEnable node exists but could not be enabled; falling back to generic Line* output configuration."
             )
-            return
 
-        LOG.info(
-            "GenTL trigger master configured: output_line=%s output_source=%s",
-            output_line,
-            output_source,
+        # ------------------------------------------------------------------
+        # Generic SFNC fallback for cameras that expose LineSelector/LineMode/LineSource.
+        # ------------------------------------------------------------------
+        line_selector = self._node(node_map, "LineSelector")
+        if line_selector is not None:
+            line_selected = self._set_enum_node(
+                node_map,
+                "LineSelector",
+                output_line,
+                strict=strict,
+            )
+
+            if not line_selected:
+                LOG.warning(
+                    "Could not select GenTL output line '%s'; skipping Line* output configuration.",
+                    output_line,
+                )
+            else:
+                mode_ok = self._set_enum_node(node_map, "LineMode", "Output", strict=strict)
+                source_ok = self._set_enum_node(node_map, "LineSource", output_source, strict=strict)
+
+                if mode_ok and source_ok:
+                    LOG.info(
+                        "GenTL trigger master configured via Line*: output_line=%s output_source=%s",
+                        output_line,
+                        output_source,
+                    )
+                    return
+
+                LOG.warning(
+                    "GenTL Line* trigger output configuration incomplete (LineMode ok=%s, LineSource ok=%s).",
+                    mode_ok,
+                    source_ok,
+                )
+
+        msg = (
+            "Could not configure GenTL trigger master output. "
+            "No supported Strobe* or Line* output path was successfully configured."
         )
 
+        if strict:
+            raise RuntimeError(msg)
+
+        LOG.warning(msg)
+
     def _restore_trigger_idle(self, node_map) -> None:
         """Best-effort restore to a safe non-triggering state after acquisition stops.
 

dlclivegui/config.py

@@ -14,6 +14,8 @@
 ModelType = Literal["pytorch", "tensorflow"]
 TriggerRole = Literal["off", "external", "master", "follower"]
 TriggerActivation = Literal["RisingEdge", "FallingEdge", "AnyEdge", "LevelHigh", "LevelLow"]
+TriggerStrobePolarity = Literal["ActiveHigh", "ActiveLow"]
+TriggerStrobeOperation = Literal["Exposure", "FixedDuration"]
 
 SINGLE_CAMERA_WORKER_DO_LOG_TIMING = False
 MULTI_CAMERA_WORKER_DO_LOG_TIMING = True
@@ -239,9 +241,13 @@ class CameraTriggerSettings(BaseModel):
     Generic hardware-trigger settings.
 
     Backend-specific code may ignore fields that are unsupported by a given
-    camera/SDK. For GenTL, these map to common GenICam nodes such as:
-    TriggerMode, TriggerSelector, TriggerSource, TriggerActivation,
-    LineSelector, LineMode, and LineSource.
+    camera/SDK.
+
+    For GenTL/TIS DMK 37BUX287:
+      - follower/external maps mainly to TriggerMode, TriggerSelector,
+        TriggerActivation. TriggerSource may be read-only and is best-effort.
+      - master output maps primarily to StrobeEnable, StrobePolarity,
+        StrobeOperation, StrobeDuration, and StrobeDelay.
     """
 
     role: TriggerRole = "off"
@@ -251,10 +257,16 @@ class CameraTriggerSettings(BaseModel):
     source: str = "auto"
     activation: TriggerActivation | str = "RisingEdge"
 
-    # Output config: master
+    # Generic/SFNC output config: master fallback for cameras exposing Line* nodes.
     output_line: str = "Line2"
     output_source: str = "ExposureActive"
 
+    # Strobe output config: master path for TIS/DMK 37U cameras.
+    strobe_polarity: TriggerStrobePolarity | str = "ActiveHigh"
+    strobe_operation: TriggerStrobeOperation | str = "Exposure"
+    strobe_duration: int | None = None  # µs, used when strobe_operation=FixedDuration
+    strobe_delay: int | None = None  # µs
+
     # Runtime behavior
     timeout: float | None = None
     strict: bool = False
@@ -296,6 +308,17 @@ def _coerce_timeout(cls, v):
             return None
         return fv if fv > 0 else None
 
+    @field_validator("strobe_duration", "strobe_delay", mode="before")
+    @classmethod
+    def _coerce_optional_nonnegative_int(cls, v):
+        if v in (None, ""):
+            return None
+        try:
+            iv = int(float(v))
+        except Exception:
+            return None
+        return iv if iv >= 0 else None
+
     @field_validator("source", mode="before")
     @classmethod
     def _coerce_source(cls, v):