Tested and bugfixed application controller

src/qdlutils/applications/qdlscan/application_controller.py

@@ -19,12 +19,14 @@ def __init__(self,
                  x_axis_controller: NidaqPositionController,
                  y_axis_controller: NidaqPositionController,
                  z_axis_controller: NidaqPositionController,
-                 counter_controller: NidaqTimedRateCounter):
+                 counter_controller: NidaqTimedRateCounter,
+                 inter_scan_settle_time: float=0.01):
 
         self.x_axis_controller = x_axis_controller
         self.y_axis_controller = y_axis_controller
         self.z_axis_controller = z_axis_controller
         self.counter_controller = counter_controller
+        self.inter_scan_settle_time = inter_scan_settle_time
 
         # On initialization move all position controllers to zero.
         # WARNING: it is assumed that the zero is a valid position of the DAQ
@@ -90,7 +92,8 @@ def _set_axis(self, axis_controller: NidaqPositionController, position: float):
         This avoids logic required to determine which axis is to be moved, for example
         in the case of scans where only one axis is used repeatedly.
         '''
-        # Try to move the axis 
+        logger.debug(f'Attempting to move to position {position}.')
+        # Move the axis 
         axis_controller.go_to_position(position=position)
 
     def scan_axis(self, 
@@ -110,6 +113,9 @@ def scan_axis(self,
             raise RuntimeError('Application controller is currently in use.')
         # Block the controller from additional external commands
         self.busy=True
+        # Start the counter
+        logger.info('Starting counter task on DAQ.')
+        self.counter_controller.start()
 
         # Get the axis controller depending on which axis is requested
         if axis == 'x':
@@ -129,6 +135,7 @@ def scan_axis(self,
 
         # Free up the controller
         self.busy = False
+        self.stop()
         return data
 
 
@@ -205,7 +212,17 @@ def scan_image(self,
             raise RuntimeError('Application controller is currently in use.')
         # Reserve the controller
         self.busy = True
+
 
+        # Get the axis controller depending on which axis is requested
+        if axis_1 == 'x':
+            axis_controller_1 = self.x_axis_controller
+        elif axis_1 == 'y':
+            axis_controller_1 = self.y_axis_controller
+        elif axis_1 == 'z':
+            axis_controller_1 = self.z_axis_controller
+        else:
+            raise ValueError(f'Requested axis_1 {axis_1} is invalid.')
         # Get the axis controller depending on which axis is requested
         if axis_2 == 'x':
             axis_controller_2 = self.x_axis_controller
@@ -216,19 +233,25 @@ def scan_image(self,
         else:
             raise ValueError(f'Requested axis_2 {axis_2} is invalid.')
 
+        # Start the counter
+        logger.info('Starting counter task on DAQ.')
+        self.counter_controller.start()
+
         # Get the positions for the slow scan axis
         positions_2 = np.linspace(start=start_2, stop=stop_2, num=n_pixels_2)
 
         # Then iterate through the positions
         for index, position in enumerate(positions_2):
             # Move axis 2 to the desired position
             self._set_axis(axis_controller=axis_controller_2, position=position)
+            # Let the axis settle before next scan
+            time.sleep(self.inter_scan_settle_time)
             # Scan axis 1
-            single_scan =  self.scan_axis(axis=axis_1,
-                                          start=stop_1,
-                                          stop=stop_1,
-                                          n_pixels=n_pixels_1, 
-                                          scan_time=scan_time)
+            single_scan =  self._scan_axis(axis_controller=axis_controller_1,
+                                           start=start_1,
+                                           stop=stop_1,
+                                           n_pixels=n_pixels_1, 
+                                           scan_time=scan_time)
             # Update the buffer
             #output[index] = single_scan
 

src/qdlutils/hardware/nidaq/counters/nidaqbatchedratecounter.py

@@ -209,7 +209,7 @@ class docstring.
     def start(self) -> None:
         '''
         Configure the DAQ and start the clock task.
-        This method is called externally before a measurement is set to begi.
+        This method is called externally before a measurement is set to begin.
         '''
         # If currently running, stop the clock task
         if self.running:

src/qdlutils/hardware/nidaq/counters/nidaqtimedratecounter.py

@@ -125,14 +125,14 @@ class NidaqTimedRateCounter(NidaqBatchedRateCounter):
 
 
     def __init__(self,
-                 daq_name = 'Dev1',
-                 signal_terminal = 'PFI0',
-                 clock_rate = 1000000,
-                 sample_time_in_seconds = 1,
-                 clock_terminal = None,
-                 read_write_timeout = 10,
-                 signal_counter = 'ctr2',
-                 trigger_terminal = None,):
+                 daq_name: str = 'Dev1',
+                 signal_terminal: str  = 'PFI0',
+                 clock_rate: int  = 1000000,
+                 sample_time_in_seconds: float  = 1,
+                 clock_terminal: str  = None,
+                 read_write_timeout: float  = 10,
+                 signal_counter: str  = 'ctr2',
+                 trigger_terminal: str  = None):
 
         # Save the only new attribute
         self.sample_time_in_seconds = sample_time_in_seconds