Merge pull request #937 from TheDeanLab/conor-develop-20240711

New feature: WaitForExternalTrigger

Author: AdvancedImagingUTSW

src/navigate/model/devices/daq/ni.py

@@ -34,6 +34,7 @@
 import logging
 from threading import Lock
 import traceback
+import time
 
 # Third Party Imports
 import nidaqmx
@@ -177,6 +178,53 @@ def set_external_trigger(self, external_trigger=None):
                 task.register_done_event(None)
                 task.register_done_event(self.restart_analog_task_callback_func(task))
 
+    def wait_for_external_trigger(
+        self, trigger_channel, wait_internal=0.001, timeout=-1
+    ):
+        """Wait for a digital external trigger.
+
+        Parameters
+        ----------
+        trigger_channel : str
+            The name of the DAQ PFI digital input.
+        wait_internal : float
+            The internal waiting time to check the trigger
+        timeout : float
+            Continue on anyway if timeout is reached. timeout < 0 will
+            run forever.
+
+        Returns
+        -------
+            result : bool
+                True for the trigger, False for no trigger.
+        """
+        if not trigger_channel:
+            logger.info(
+                "No external trigger channel is specified! Return from waiting!"
+            )
+            return False
+        # Create a digital input task and wait until either a trigger is detected,
+        # or the timeout is exceeded. If timeout < 0, wait forever...
+        external_trigger_task = nidaqmx.Task("WaitDigitalEdge")
+        external_trigger_task.di_channels.add_di_chan(trigger_channel)
+
+        total_wait_time = 0.0
+        result = True
+
+        while not external_trigger_task.read():
+            time.sleep(wait_internal)
+            total_wait_time += wait_internal
+
+            if timeout > 0 and total_wait_time >= timeout:
+                result = False
+                break
+
+        # Close the task
+        external_trigger_task.stop()
+        external_trigger_task.close()
+
+        return result
+
     @staticmethod
     def restart_analog_task_callback_func(task):
         """Restart analog task callback function.

src/navigate/model/features/common_features.py

@@ -34,9 +34,7 @@
 import time
 from functools import reduce
 from threading import Lock
-import copy
 
-# Third party imports
 
 # Local application imports
 from .image_writer import ImageWriter
@@ -199,6 +197,62 @@ def data_func(self, frame_ids):
         return True
 
 
+class WaitForExternalTrigger:
+    """WaitForExternalTrigger class to time parts of the feature list using external input.
+
+    This class waits for either an external trigger (or the timeout) before continuing 
+    on to the next feature block in the list. Useful when combined with LoopByCounts
+    when each iteration may depend on some external event happening.
+
+    Notes:
+    ------
+    - This class pauses the data thread while waiting for the trigger to avoid
+      camera timeout issues.
+    
+    - Only digital triggers are handeled at this time: use the PFI inputs on the DAQ.
+    """
+
+    def __init__(self, model, trigger_channel="/PCIe-6738/PFI4", timeout=-1):
+        """Initialize the WaitForExternalTrigger class.
+
+        Parameters:
+        ----------
+        model : MicroscopeModel
+            The microscope model object used for synchronization.
+        trigger_channel : str
+            The name of the DAQ PFI digital input.
+        timeout : float
+            Continue on anyway if timeout is reached. timeout < 0 will
+            run forever.
+        """
+        self.model = model
+
+        self.wait_interval = 0.001 # sec
+
+        self.task = None
+        self.trigger_channel = trigger_channel
+        self.timeout = timeout
+
+        self.config_table = {
+            "signal": {
+                "main": self.signal_func,
+            }
+        }
+
+    def signal_func(self):
+
+        # Pause the data thread to prevent camera timeout
+        self.model.pause_data_thread()
+
+        result = self.model.active_microscope.daq.wait_for_external_trigger(
+            self.trigger_channel, self.wait_interval, self.timeout
+        )
+
+        # Resume the data thread
+        self.model.resume_data_thread()
+
+        return result
+
 class WaitToContinue:
     """WaitToContinue class for synchronizing signal and data acquisition.
 
@@ -619,11 +673,16 @@ def signal_func(self):
             self.model.pause_data_thread()
 
         self.current_idx += 1
+        # Make sure to go back to the beginning if using LoopByCount
+        if self.current_idx == self.position_count:
+            self.current_idx = 0
+
         abs_pos_dict = dict(map(lambda k: (f"{k}_abs", pos_dict[k]), pos_dict.keys()))
         self.model.logger.debug(f"MoveToNextPositionInMultiPosition: " f"{pos_dict}")
         self.model.move_stage(abs_pos_dict, wait_until_done=True)
 
         self.model.logger.debug("MoveToNextPositionInMultiPosition: move done")
+        
         # resume data thread
         if should_pause_data_thread:
             self.model.resume_data_thread()

src/navigate/model/features/feature_related_functions.py

@@ -45,6 +45,7 @@
     ChangeResolution,  # noqa
     Snap,  # noqa
     WaitToContinue,  # noqa
+    WaitForExternalTrigger,  # noqa
     LoopByCount,  # noqa
     PrepareNextChannel,  # noqa
     MoveToNextPositionInMultiPositionTable,  # noqa