move the external trigger task to the daq

Author: annie-xd-wang

src/navigate/model/devices/daq/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(self.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,10 +34,7 @@
 import time
 from functools import reduce
 from threading import Lock
-import copy
 
-# Third party imports
-import nidaqmx
 
 # Local application imports
 from .image_writer import ImageWriter
@@ -247,28 +244,14 @@ def signal_func(self):
         # Pause the data thread to prevent camera timeout
         self.model.pause_data_thread()
 
-        # Create a digital input task and wait until either a trigger is detected,
-        # or the timeout is exceeded. If timeout < 0, wait forever...
-        self.task = nidaqmx.Task('WaitDigitalEdge')
-        self.task.di_channels.add_di_chan(self.trigger_channel)
-
-        total_wait_time = 0.
-
-        while not self.task.read():
-            time.sleep(self.wait_interval)
-            total_wait_time += self.wait_interval
-
-            if self.timeout > 0 and total_wait_time >= self.timeout:
-                break
-        
-        # Close the task
-        self.task.stop()
-        self.task.close()
+        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 True
+        return result
 
 class WaitToContinue:
     """WaitToContinue class for synchronizing signal and data acquisition.