From 287bf3b528ac98b34075d62997c2ede6a53be4eb Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Thu, 26 Oct 2023 16:33:50 -0700
Subject: [PATCH 01/32] Created simple PLE experiment which can set a voltage

---
 src/applications/PLEscan.py | 139 ++++++++++++++++++++++++++++++++++++
 1 file changed, 139 insertions(+)
 create mode 100644 src/applications/PLEscan.py

diff --git a/src/applications/PLEscan.py b/src/applications/PLEscan.py
new file mode 100644
index 00000000..caa00097
--- /dev/null
+++ b/src/applications/PLEscan.py
@@ -0,0 +1,139 @@
+import argparse
+import tkinter as tk
+import logging
+from threading import Thread
+
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
+import matplotlib
+import nidaqmx
+
+import qt3utils.datagenerators as datasources
+
+matplotlib.use('Agg')
+
+
+parser = argparse.ArgumentParser(description='NI DAQ (PCIx 6363) / PLE Scanner',
+                                 formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+parser.add_argument('-d', '--daq-name', default = 'Dev1', type=str, metavar = 'daq_name',
+                    help='NI DAQ Device Name')
+parser.add_argument('-st', '--signal-terminal', metavar = 'terminal', default = 'PFI0', type=str,
+                    help='NI DAQ terminal connected to input digital TTL signal')
+parser.add_argument('-c', '--clock-rate', metavar = 'rate (Hz)', default = 100000, type=int,
+                    help='''Specifies the clock rate in Hz. If using an external clock,
+                    you should specifiy the clock rate here so that the correct counts per
+                    second are displayed. If using the internal NI DAQ clock (default behavior),
+                    this value specifies the clock rate to use. Per the NI DAQ manual,
+                    use a suitable clock rate for the device for best performance, which is an integer
+                    multiple downsample of the digital sample clock.''')
+parser.add_argument('-n', '--num-data-samples-per-batch', metavar = 'N', default = 250, type=int,
+                    help='''Number of data points to acquire per DAQ batch request.
+                           Note that only ONE data point is shown in the scope.
+                           After each request to the NI DAQ for data, the mean count
+                           rate from the batch is computed and displayed. Increasing
+                           the "num-data-samples-per-batch" should reduce your noise, but
+                           slow the response of the scope. Increase this value if the
+                           scope appears too noisy.''')
+parser.add_argument('-ct', '--clock-terminal', metavar = 'terminal', default = None, type=str,
+                    help='''Specifies the digital input terminal to the NI DAQ to use for a clock.
+                            If None, which is the default, the internal NI DAQ clock is used.''')
+parser.add_argument('-to', '--rwtimeout', metavar = 'seconds', default = 10, type=int,
+                    help='NI DAQ read/write timeout in seconds.')
+parser.add_argument('-sc', '--signal-counter', metavar = 'ctrN', default = 'ctr2', type=str,
+                    help='NI DAQ interal counter (ctr1, ctr2, ctr3, ctr4)')
+parser.add_argument('--piezo-write-channel', metavar = '<ch0>', default = 'ao0', type=str,
+                    help='Analog output channel used to control the wavelength of the laser')
+parser.add_argument('-r', '--randomtest', action = 'store_true',
+                    help='When true, program will run showing random numbers. This is for development testing.')
+parser.add_argument('-q', '--quiet', action = 'store_true',
+                    help='When true,logger level will be set to warning. Otherwise, set to "info".')
+parser.add_argument('-cmap', metavar = '<MPL color>', default = 'gray',
+                    help='Set the MatplotLib colormap scale')
+
+args = parser.parse_args()
+
+logger = logging.getLogger(__name__)
+logging.basicConfig()
+
+if args.quiet is False:
+    logger.setLevel(logging.INFO)
+
+
+class ScanImage:
+    def __init__(self, mplcolormap = 'gray'):
+        self.fig, self.ax = plt.subplots()
+        self.cbar = None
+        self.cmap = mplcolormap
+        self.cid = self.fig.canvas.mpl_connect('button_press_event', self.onclick)
+        self.ax.set_xlabel('Voltage')
+        self.log_data = False
+
+
+    def onclick(self, event):
+        pass
+
+class SidePanel():
+    def __init__(self, root, scan_range):
+        frame = tk.Frame(root)
+        frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+
+        row = 0
+        tk.Label(frame, text="Scan Settings", font='Helvetica 16').grid(row=row, column=0,pady=10)
+        row += 1
+        tk.Label(frame, text="x range (um)").grid(row=row, column=0)
+        self.x_min_entry = tk.Entry(frame, width=10)
+        self.x_max_entry = tk.Entry(frame, width=10)
+        self.x_min_entry.insert(10, scan_range[0])
+        self.x_max_entry.insert(10, scan_range[1])
+        self.x_min_entry.grid(row=row, column=1)
+        self.x_max_entry.grid(row=row, column=2)
+        self.startButton = tk.Button(frame, text="Start Scan")
+        self.startButton.grid(row=row, column=0)
+
+class MainApplicationView():
+    def __init__(self, main_frame, scan_range = [0,80]):
+        frame = tk.Frame(main_frame)
+        frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+
+        self.scan_view = ScanImage(args.cmap)
+        self.sidepanel = SidePanel(main_frame, scan_range)
+
+        self.canvas = FigureCanvasTkAgg(self.scan_view.fig, master=frame)
+        self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)
+
+        toolbar = NavigationToolbar2Tk(self.canvas, frame)
+        toolbar.update()
+        self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
+
+        self.canvas.draw()
+
+class MainTkApplication():
+
+    def __init__(self):
+        self.root = tk.Tk()
+        self.view = MainApplicationView(self.root)
+        self.view.sidepanel.startButton.bind("<Button>", self.start_scan)
+
+    #TODO: add device/channel name, change functionality to nidaq, add sweep loop and sleep() with settling time
+    def start_scan(self, event = None):
+        self.view.sidepanel.startButton['state'] = 'disabled'
+        xmin = float(self.view.sidepanel.x_min_entry.get())
+        xmax = float(self.view.sidepanel.x_max_entry.get())
+        with nidaqmx.Task() as task:
+            task.ao_channels.add_ao_voltage_chan("Dev1/ai0")
+            task.write(xmin)
+
+    def run(self):
+        self.root.title("QT3PLE: Run PLE scan")
+        self.root.deiconify()
+        self.root.mainloop()
+
+def main():
+    tkapp = MainTkApplication()
+    tkapp.run()
+
+
+if __name__ == '__main__':
+    main()

From a31792c687d1b26808205f10dd09710dbbaaf9c4 Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Mon, 13 Nov 2023 15:35:16 -0800
Subject: [PATCH 02/32] Added custom controller and scanner for interfacing
 with SPCM in a PLE experiment.

---
 src/applications/PLEscan.py               | 126 ++++++++++++++++++---
 src/qt3utils/datagenerators/PLEscanner.py | 127 ++++++++++++++++++++++
 src/qt3utils/nidaq/config.py              |   2 +-
 src/qt3utils/nidaq/customcontrollers.py   |  94 ++++++++++++++++
 4 files changed, 334 insertions(+), 15 deletions(-)
 create mode 100644 src/qt3utils/datagenerators/PLEscanner.py
 create mode 100644 src/qt3utils/nidaq/customcontrollers.py

diff --git a/src/applications/PLEscan.py b/src/applications/PLEscan.py
index caa00097..086a498c 100644
--- a/src/applications/PLEscan.py
+++ b/src/applications/PLEscan.py
@@ -8,6 +8,9 @@
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
 import matplotlib
 import nidaqmx
+import nipiezojenapy
+from qt3utils.nidaq.customcontrollers import VControl
+from qt3utils.datagenerators import PLEscanner
 
 import qt3utils.datagenerators as datasources
 
@@ -43,8 +46,16 @@
                     help='NI DAQ read/write timeout in seconds.')
 parser.add_argument('-sc', '--signal-counter', metavar = 'ctrN', default = 'ctr2', type=str,
                     help='NI DAQ interal counter (ctr1, ctr2, ctr3, ctr4)')
-parser.add_argument('--piezo-write-channel', metavar = '<ch0>', default = 'ao0', type=str,
+parser.add_argument('--wavelength-write-channel', metavar = 'ch0', default = 'ao0', type=str,
                     help='Analog output channel used to control the wavelength of the laser')
+parser.add_argument('--wavelength-read-channel', metavar = 'ch0', default = 'ai0', type=str,
+                    help='Analog input channels used to read the instantaneous wavelength')
+parser.add_argument('-lmin', '--wavelength-min-position', metavar = 'nanometers', default = 0, type=float,
+                    help='sets min allowed wavelength on PLE controller.')
+parser.add_argument('-lmax', '--wavelength-max-position', metavar = 'nanometers', default = 80, type=float,
+                    help='sets min allowed wavelength on PLE controller.')
+parser.add_argument('-lscale', '--wavelength-scale-nm-per-volt', default = 8, type=float,
+                    help='sets nanometer to volt scale for PLE controller.')
 parser.add_argument('-r', '--randomtest', action = 'store_true',
                     help='When true, program will run showing random numbers. This is for development testing.')
 parser.add_argument('-q', '--quiet', action = 'store_true',
@@ -83,15 +94,30 @@ def __init__(self, root, scan_range):
         tk.Label(frame, text="Scan Settings", font='Helvetica 16').grid(row=row, column=0,pady=10)
         row += 1
         tk.Label(frame, text="x range (um)").grid(row=row, column=0)
-        self.x_min_entry = tk.Entry(frame, width=10)
-        self.x_max_entry = tk.Entry(frame, width=10)
-        self.x_min_entry.insert(10, scan_range[0])
-        self.x_max_entry.insert(10, scan_range[1])
-        self.x_min_entry.grid(row=row, column=1)
-        self.x_max_entry.grid(row=row, column=2)
+        self.v_min_entry = tk.Entry(frame, width=10)
+        self.v_max_entry = tk.Entry(frame, width=10)
+        self.v_min_entry.insert(10, scan_range[0])
+        self.v_max_entry.insert(10, scan_range[1])
+        self.v_min_entry.grid(row=row, column=1)
+        self.v_max_entry.grid(row=row, column=2)
         self.startButton = tk.Button(frame, text="Start Scan")
         self.startButton.grid(row=row, column=0)
 
+        row += 1
+        tk.Label(frame, text="step size (um)").grid(row=row, column=0)
+        self.step_size_entry = tk.Entry(frame, width=10)
+        self.step_size_entry.insert(10, 1.0)
+        self.step_size_entry.grid(row=row, column=1)
+
+        row += 1
+        tk.Label(frame, text="DAQ Settings", font='Helvetica 16').grid(row=row, column=0,pady=10)
+        row += 1
+        tk.Label(frame, text="N samples/step").grid(row=row, column=0)
+        self.n_sample_size_value = tk.IntVar()
+        self.n_sample_size_entry = tk.Entry(frame, width=10, textvariable = self.n_sample_size_value)
+        self.n_sample_size_entry.grid(row=row, column=1)
+        self.n_sample_size_value.set(args.num_data_samples_per_batch)
+
 class MainApplicationView():
     def __init__(self, main_frame, scan_range = [0,80]):
         frame = tk.Frame(main_frame)
@@ -111,27 +137,99 @@ def __init__(self, main_frame, scan_range = [0,80]):
 
 class MainTkApplication():
 
-    def __init__(self):
+    def __init__(self, counter_scanner):
+        self.counter_scanner = counter_scanner
         self.root = tk.Tk()
         self.view = MainApplicationView(self.root)
         self.view.sidepanel.startButton.bind("<Button>", self.start_scan)
+        self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
 
     #TODO: add device/channel name, change functionality to nidaq, add sweep loop and sleep() with settling time
     def start_scan(self, event = None):
         self.view.sidepanel.startButton['state'] = 'disabled'
-        xmin = float(self.view.sidepanel.x_min_entry.get())
-        xmax = float(self.view.sidepanel.x_max_entry.get())
-        with nidaqmx.Task() as task:
-            task.ao_channels.add_ao_voltage_chan("Dev1/ai0")
-            task.write(xmin)
+        vmin = float(self.view.sidepanel.v_min_entry.get())
+        vmax = float(self.view.sidepanel.v_max_entry.get())
+        args = [vmin, vmax]
+        args.append(float(self.view.sidepanel.step_size_entry.get()))
+        args.append(int(self.view.sidepanel.n_sample_size_value.get()))
+
+        self.scan_thread = Thread(target=self.scan_thread_function, args = args)
+        self.scan_thread.start()
+
+
+        #with nidaqmx.Task() as task:
+        #    task.ao_channels.add_ao_voltage_chan("Dev1/ai0")
+        #    task.write(xmin)
 
     def run(self):
         self.root.title("QT3PLE: Run PLE scan")
         self.root.deiconify()
         self.root.mainloop()
 
+    def stop_scan(self, event = None):
+        self.counter_scanner.stop()
+
+    def on_closing(self):
+        try:
+            self.stop_scan()
+            self.root.quit()
+            self.root.destroy()
+        except Exception as e:
+            logger.debug(e)
+            pass
+
+    def scan_thread_function(self, vmin, vmax, step_size, N):
+
+        self.counter_scanner.set_scan_range(vmin, vmax)
+        self.counter_scanner.step_size = step_size
+        self.counter_scanner.set_num_data_samples_per_batch(N)
+
+        try:
+            self.counter_scanner.reset()  # clears the data
+            self.counter_scanner.start()  # starts the DAQ
+            self.counter_scanner.set_to_starting_position()  # moves the stage to starting position
+
+            while self.counter_scanner.still_scanning():
+                self.counter_scanner.scan_v()
+                self.view.scan_view.update(self.counter_scanner)
+                self.view.canvas.draw()
+
+            self.counter_scanner.stop()
+
+        except nidaqmx.errors.DaqError as e:
+            logger.info(e)
+            logger.info(
+                'Check for other applications using resources. If not, you may need to restart the application.')
+
+        self.view.sidepanel.startButton['state'] = 'normal'
+
+def build_data_scanner():
+
+    if args.randomtest:
+        data_acq = datasources.RandomRateCounter(simulate_single_light_source=True,
+                                                 num_data_samples_per_batch=args.num_data_samples_per_batch)
+    else:
+        data_acq = datasources.NiDaqDigitalInputRateCounter(args.daq_name,
+                                                            args.signal_terminal,
+                                                            args.clock_rate,
+                                                            args.num_data_samples_per_batch,
+                                                            args.clock_terminal,
+                                                            args.rwtimeout,
+                                                            args.signal_counter)
+
+    voltage_controller = VControl(device_name = args.daq_name,
+                                  write_channel = args.wavelength_write_channel,
+                                  read_channel = args.wavelength_read_channel,
+                                  min_position = args.wavelength_min_position,
+                                  max_position = args.wavelength_max_position,
+                                  scale_nm_per_volt = args.wavelength_scale_nm_per_volt)
+
+    scanner = PLEscanner.CounterAndScanner(data_acq, voltage_controller)
+
+    return scanner
+
 def main():
-    tkapp = MainTkApplication()
+    tkapp = MainTkApplication(build_data_scanner())
     tkapp.run()
 
 
diff --git a/src/qt3utils/datagenerators/PLEscanner.py b/src/qt3utils/datagenerators/PLEscanner.py
new file mode 100644
index 00000000..eb2158d7
--- /dev/null
+++ b/src/qt3utils/datagenerators/PLEscanner.py
@@ -0,0 +1,127 @@
+import numpy as np
+import time
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class CounterAndScanner:
+    def __init__(self, rate_counter, wavelength_controller):
+
+        self.running = False
+        self.current_y = 0
+        self.vmin = wavelength_controller.minimum_allowed_position
+        self.vmax = wavelength_controller.maximum_allowed_position
+        self.step_size = 0.5
+        self.raster_line_pause = 0.150  # wait 150ms for the voltage to settle before a line scan
+
+        self.scanned_raw_counts = []
+        self.scanned_count_rate = []
+
+        self.wavelength_controller = wavelength_controller
+        self.rate_counter = rate_counter
+        self.num_daq_batches = 1  # could change to 10 if want 10x more samples for each position
+
+    def stop(self):
+        self.rate_counter.stop()
+        self.running = False
+
+    def start(self):
+        self.running = True
+        self.rate_counter.start()
+
+    def set_to_starting_position(self):
+        self.current_v = self.vmin
+        if self.wavelength_controller:
+            self.wavelength_controller.go_to_voltage(v=self.vmin)
+
+    def close(self):
+        self.rate_counter.close()
+
+    def set_num_data_samples_per_batch(self, N):
+        self.rate_counter.num_data_samples_per_batch = N
+
+    def sample_counts(self):
+        return self.rate_counter.sample_counts(self.num_daq_batches)
+
+    def sample_count_rate(self, data_counts=None):
+        if data_counts is None:
+            data_counts = self.sample_counts()
+        return self.rate_counter.sample_count_rate(data_counts)
+
+    def set_scan_range(self, vmin, vmax):
+        if self.wavelength_controller:
+            self.wavelength_controller.check_allowed_position(vmin, vmin)
+        self.vmin = vmin
+        self.vmax = vmax
+
+    def get_scan_range(self) -> tuple:
+        """
+        Returns a tuple of the full scan range
+        :return: xmin, xmax, ymin, ymax
+        """
+        return self.vmin, self.vmax,
+
+    def get_completed_scan_range(self) -> tuple:
+        """
+        Returns a tuple of the scan range that has been completed
+        :return: xmin, xmax, ymin, current_y
+        """
+        return self.xmin, self.xmax, self.current_v
+
+    def still_scanning(self):
+        if self.running == False:  # this allows external process to stop scan
+            return False
+
+        if self.current_v <= self.vmax:  # stops scan when reaches final position
+            return True
+        else:
+            self.running = False
+            return False
+
+    def move_v(self):
+        self.current_v += self.step_size
+        if self.wavelength_controller and self.current_v <= self.vmax:
+            try:
+                self.wavelength_controller.go_to_position(v=self.current_v)
+            except ValueError as e:
+                logger.info(f'out of range\n\n{e}')
+
+    def scan_v(self):
+        """
+        Scans the wavelengths from vmin to vmax in steps of step_size.
+
+        Stores results in self.scanned_raw_counts and self.scanned_count_rate.
+        """
+        raw_counts_for_axis = self.scan_axis('v', self.vmin, self.vmax, self.step_size)
+        self.scanned_raw_counts.append(raw_counts_for_axis)
+        self.scanned_count_rate.append([self.sample_count_rate(raw_counts) for raw_counts in raw_counts_for_axis])
+
+    def scan_axis(self, axis, min, max, step_size):
+        """
+        Moves the stage along the specified axis from min to max in steps of step_size.
+        Returns a list of raw counts from the scan in the shape
+        [[[counts, clock_samples]], [[counts, clock_samples]], ...] where each [[counts, clock_samples]] is the
+        result of a single call to sample_counts at each scan position along the axis.
+        """
+        raw_counts = []
+        self.wavelength_controller.go_to_voltage(**{axis: min})
+        time.sleep(self.raster_line_pause)
+        for val in np.arange(min, max, step_size):
+            if self.wavelength_controller:
+                logger.info(f'go to voltage {axis}: {val:.2f}')
+                self.wavelength_controller.go_to_voltage(**{axis: val})
+            _raw_counts = self.sample_counts()
+            raw_counts.append(_raw_counts)
+            logger.info(f'raw counts, total clock samples: {_raw_counts}')
+            if self.wavelength_controller:
+                logger.info(f'current voltage: {self.wavelength_controller.get_current_voltage()}')
+
+        return raw_counts
+
+    def reset(self):
+        self.scanned_raw_counts = []
+        self.scanned_count_rate = []
+
+
+
diff --git a/src/qt3utils/nidaq/config.py b/src/qt3utils/nidaq/config.py
index 67cffcbb..63900f97 100644
--- a/src/qt3utils/nidaq/config.py
+++ b/src/qt3utils/nidaq/config.py
@@ -76,7 +76,7 @@ def configure_di_clock(self, internal_clock_di_line = 'port0',
 
         '''
         Creates and configures a clock task using a dummy channel. A clock task
-        using an internal clock surce is needed
+        using an internal clock source is needed
         for edge counting tasks (maybe -- documentation is confusing) if you do not
         supply your own exernal clock.
 
diff --git a/src/qt3utils/nidaq/customcontrollers.py b/src/qt3utils/nidaq/customcontrollers.py
new file mode 100644
index 00000000..0c3bb8b1
--- /dev/null
+++ b/src/qt3utils/nidaq/customcontrollers.py
@@ -0,0 +1,94 @@
+import nidaqmx
+import nipiezojenapy
+from typing import List
+import time
+import logging
+
+logger = logging.getLogger(__name__)
+class VControl(nipiezojenapy.BaseControl):
+
+    def __init__(self, device_name: str,
+                 write_channel: str = 'ao0',
+                 read_channel: str = None,
+                 scale_nm_per_volt: float = 8,
+                 move_settle_time: float = 0.001,
+                 min_position: float = 0.0,
+                 max_position: float = 80.0) -> None:
+        super().__init__()
+
+        self.device_name = device_name
+        self.write_channel = write_channel
+        self.read_channel = read_channel
+        self.scale_nm_per_volt = scale_nm_per_volt
+        self.minimum_allowed_position = min_position
+        self.maximum_allowed_position = max_position
+        self.settling_time_in_seconds = move_settle_time #10 millisecond settle time
+        self.last_write_value = None
+
+
+
+    def go_to_voltage(self, v: float = None) -> None:
+        '''
+        Sets the x,y,z position in microns.
+
+        You do not need to specify all three axis values in order
+        to move in one direction. For example, you can call: go_to_position(z = 40)
+
+        raises ValueError if try to set position out of bounds.
+        '''
+
+        def goto(val):
+            self._validate_value(val)
+            with nidaqmx.Task() as task:
+                task.ao_channels.add_ao_voltage_chan(self.device_name + '/' + self.write_channel)
+                task.write(self._microns_to_volts(val))
+                self.last_write_value = val
+
+        debug_string = []
+        if v is not None:
+            goto(v)
+            debug_string.append(f'v: {v:.2f}')
+
+        logger.info(f'go to position {" ".join(debug_string)}')
+
+        time.sleep(self.settling_time_in_seconds) #wait to ensure piezo actuator has settled into position.
+        logger.debug(f'last write: {self.last_write_value}')
+
+    def get_current_voltage(self) -> List[float]:
+        '''
+        Returns the voltage supplied to the three input analog channels.
+
+        If no input analog channels were provided when objected was created,
+        returns [-1,-1,-1]
+        '''
+        output = [-1,-1,-1]
+        if self.read_channel is not None:
+            with nidaqmx.Task() as vread, nidaqmx.Task():
+
+                vread.ai_channels.add_ai_voltage_chan(self.device_name + '/' + self.read_channel, min_val = 0, max_val = 10.0)
+
+                output = vread.read()
+
+        return output
+
+    def get_current_voltage(self) -> List[float]:
+        '''
+        Returns the x,y,z position in microns
+
+        If no input analog channels were provided when objected was created,
+        returns the last requested position.
+        '''
+
+        if self.read_channel is None:
+            return self.last_write_value
+
+        else:
+            return [self._volts_to_nm(v) for v in self.get_current_voltage()]
+
+    @staticmethod
+    def _nm_to_volts(self, nm: float) -> float:
+        return nm / self.scale_nm_per_volt
+
+    @staticmethod
+    def _volts_to_nm(self, volts: float) -> float:
+        return  self.scale_nm_per_volt * volts

From 0798297db91c51d790cb1b8ef3976764d6c9525c Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Thu, 16 Nov 2023 11:50:18 -0800
Subject: [PATCH 03/32] Changed Side Panel to have all necessary scan
 parameters. Added GoTo voltage button

---
 src/applications/PLEscan.py               | 81 +++++++++++++++++------
 src/qt3utils/datagenerators/PLEscanner.py | 20 +++++-
 src/qt3utils/nidaq/customcontrollers.py   | 14 ++--
 3 files changed, 89 insertions(+), 26 deletions(-)

diff --git a/src/applications/PLEscan.py b/src/applications/PLEscan.py
index 086a498c..578c563f 100644
--- a/src/applications/PLEscan.py
+++ b/src/applications/PLEscan.py
@@ -50,10 +50,10 @@
                     help='Analog output channel used to control the wavelength of the laser')
 parser.add_argument('--wavelength-read-channel', metavar = 'ch0', default = 'ai0', type=str,
                     help='Analog input channels used to read the instantaneous wavelength')
-parser.add_argument('-lmin', '--wavelength-min-position', metavar = 'nanometers', default = 0, type=float,
-                    help='sets min allowed wavelength on PLE controller.')
-parser.add_argument('-lmax', '--wavelength-max-position', metavar = 'nanometers', default = 80, type=float,
-                    help='sets min allowed wavelength on PLE controller.')
+parser.add_argument('-lmin', '--wavelength-min-position', metavar = 'voltage', default = -10, type=float,
+                    help='sets min allowed voltage on PLE controller.')
+parser.add_argument('-lmax', '--wavelength-max-position', metavar = 'voltage', default = 10, type=float,
+                    help='sets min allowed voltage on PLE controller.')
 parser.add_argument('-lscale', '--wavelength-scale-nm-per-volt', default = 8, type=float,
                     help='sets nanometer to volt scale for PLE controller.')
 parser.add_argument('-r', '--randomtest', action = 'store_true',
@@ -93,33 +93,60 @@ def __init__(self, root, scan_range):
         row = 0
         tk.Label(frame, text="Scan Settings", font='Helvetica 16').grid(row=row, column=0,pady=10)
         row += 1
-        tk.Label(frame, text="x range (um)").grid(row=row, column=0)
+        self.startButton = tk.Button(frame, text="Start Scan")
+        self.startButton.grid(row=row, column=0)
+        row += 1
+        tk.Label(frame, text="Voltage Range (V)").grid(row=row, column=0)
         self.v_min_entry = tk.Entry(frame, width=10)
         self.v_max_entry = tk.Entry(frame, width=10)
         self.v_min_entry.insert(10, scan_range[0])
         self.v_max_entry.insert(10, scan_range[1])
         self.v_min_entry.grid(row=row, column=1)
         self.v_max_entry.grid(row=row, column=2)
-        self.startButton = tk.Button(frame, text="Start Scan")
-        self.startButton.grid(row=row, column=0)
 
         row += 1
-        tk.Label(frame, text="step size (um)").grid(row=row, column=0)
-        self.step_size_entry = tk.Entry(frame, width=10)
-        self.step_size_entry.insert(10, 1.0)
-        self.step_size_entry.grid(row=row, column=1)
+        tk.Label(frame, text="Number of Pixels").grid(row=row, column=0)
+        self.num_pixels= tk.Entry(frame, width=10)
+        self.num_pixels.insert(10, 150)
+        self.num_pixels.grid(row=row, column=1)
+
+        row += 1
+        tk.Label(frame, text="Number of Scans").grid(row=row, column=0)
+        self.scan_num_entry = tk.Entry(frame, width=10)
+        self.scan_num_entry.insert(10, 10)
+        self.scan_num_entry.grid(row=row, column=1)
+
+        row += 1
+        tk.Label(frame, text="Sweep Time").grid(row=row, column=0)
+        self.sweep_time_entry = tk.Entry(frame, width=10)
+        self.sweep_time_entry.insert(10, 3)
+        self.sweep_time_entry.grid(row=row, column=1)
 
         row += 1
         tk.Label(frame, text="DAQ Settings", font='Helvetica 16').grid(row=row, column=0,pady=10)
+
         row += 1
-        tk.Label(frame, text="N samples/step").grid(row=row, column=0)
-        self.n_sample_size_value = tk.IntVar()
-        self.n_sample_size_entry = tk.Entry(frame, width=10, textvariable = self.n_sample_size_value)
-        self.n_sample_size_entry.grid(row=row, column=1)
-        self.n_sample_size_value.set(args.num_data_samples_per_batch)
+        self.GotoButton = tk.Button(frame, text="Go To Voltage")
+        self.GotoButton.grid(row=row, column=0)
+        row += 1
+        tk.Label(frame, text="Voltage (V)").grid(row=row, column=0)
+        self.v_entry = tk.Entry(frame, width=10)
+        self.v_entry.insert(10, 0)
+        self.v_entry.grid(row=row, column=1)
+
+        row += 1
+        tk.Label(frame, text="Voltage Limits (V)").grid(row=row, column=0)
+        self.v_lmin_entry = tk.Entry(frame, width=10)
+        self.v_lmax_entry = tk.Entry(frame, width=10)
+        self.v_lmin_entry.insert(10, args.wavelength_min_position)
+        self.v_lmax_entry.insert(10, args.wavelength_max_position)
+        self.v_lmin_entry.grid(row=row, column=1)
+        self.v_lmax_entry.grid(row=row, column=2)
+
+
 
 class MainApplicationView():
-    def __init__(self, main_frame, scan_range = [0,80]):
+    def __init__(self, main_frame, scan_range = [-3, 5]):
         frame = tk.Frame(main_frame)
         frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
 
@@ -142,16 +169,31 @@ def __init__(self, counter_scanner):
         self.root = tk.Tk()
         self.view = MainApplicationView(self.root)
         self.view.sidepanel.startButton.bind("<Button>", self.start_scan)
+        self.view.sidepanel.GotoButton.bind("<Button>", self.go_to_voltage)
         self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
 
+    def go_to_voltage(self, event = None):
+        self.view.sidepanel.startButton['state'] = 'disabled'
+        self.view.sidepanel.GotoButton['state'] = 'disabled'
+        self.counter_scanner.go_to_v(self.view.sidepanel.v_entry.get())
+        self.view.sidepanel.startButton['state'] = 'normal'
+        self.view.sidepanel.GotoButton['state'] = 'normal'
+
     #TODO: add device/channel name, change functionality to nidaq, add sweep loop and sleep() with settling time
     def start_scan(self, event = None):
         self.view.sidepanel.startButton['state'] = 'disabled'
+        self.view.sidepanel.GotoButton['state'] = 'disabled'
+
+        n_sample_size = self.view.sidepanel.num_pixels.get()
         vmin = float(self.view.sidepanel.v_min_entry.get())
         vmax = float(self.view.sidepanel.v_max_entry.get())
+        step_size = int((vmax - vmin) / n_sample_size)
         args = [vmin, vmax]
-        args.append(float(self.view.sidepanel.step_size_entry.get()))
-        args.append(int(self.view.sidepanel.n_sample_size_value.get()))
+        args.append(step_size)
+        args.append(n_sample_size)
+
+        settling_time = self.view.sidepanel.sweep_tme_entry.get() / n_sample_size
+        self.counter_scanner.waelength_controller.settling_time_in_seconds = settling_time
 
         self.scan_thread = Thread(target=self.scan_thread_function, args = args)
         self.scan_thread.start()
@@ -202,6 +244,7 @@ def scan_thread_function(self, vmin, vmax, step_size, N):
                 'Check for other applications using resources. If not, you may need to restart the application.')
 
         self.view.sidepanel.startButton['state'] = 'normal'
+        self.view.sidepanel.GotoButton['state'] = 'normal'
 
 def build_data_scanner():
 
diff --git a/src/qt3utils/datagenerators/PLEscanner.py b/src/qt3utils/datagenerators/PLEscanner.py
index eb2158d7..464f1176 100644
--- a/src/qt3utils/datagenerators/PLEscanner.py
+++ b/src/qt3utils/datagenerators/PLEscanner.py
@@ -12,7 +12,7 @@ def __init__(self, rate_counter, wavelength_controller):
         self.current_y = 0
         self.vmin = wavelength_controller.minimum_allowed_position
         self.vmax = wavelength_controller.maximum_allowed_position
-        self.step_size = 0.5
+        self._step_size = 0.5
         self.raster_line_pause = 0.150  # wait 150ms for the voltage to settle before a line scan
 
         self.scanned_raw_counts = []
@@ -80,20 +80,27 @@ def still_scanning(self):
             return False
 
     def move_v(self):
-        self.current_v += self.step_size
+        self.current_v += self._step_size
         if self.wavelength_controller and self.current_v <= self.vmax:
             try:
                 self.wavelength_controller.go_to_position(v=self.current_v)
             except ValueError as e:
                 logger.info(f'out of range\n\n{e}')
 
+    def go_to_v(self, desired_voltage):
+        if self.wavelength_controller and desired_voltage <= self.vmax and desired_voltage >= self.vmin:
+            try:
+                self.wavelength_controller.go_to_position(v=self.desired_voltage)
+            except ValueError as e:
+                logger.info(f'out of range\n\n{e}')
+
     def scan_v(self):
         """
         Scans the wavelengths from vmin to vmax in steps of step_size.
 
         Stores results in self.scanned_raw_counts and self.scanned_count_rate.
         """
-        raw_counts_for_axis = self.scan_axis('v', self.vmin, self.vmax, self.step_size)
+        raw_counts_for_axis = self.scan_axis('v', self.vmin, self.vmax, self._step_size)
         self.scanned_raw_counts.append(raw_counts_for_axis)
         self.scanned_count_rate.append([self.sample_count_rate(raw_counts) for raw_counts in raw_counts_for_axis])
 
@@ -123,5 +130,12 @@ def reset(self):
         self.scanned_raw_counts = []
         self.scanned_count_rate = []
 
+    @property
+    def step_size(self):
+        return self._step_size
+    @step_size.setter
+    def step_size(self, val):
+        self._step_size = val
+
 
 
diff --git a/src/qt3utils/nidaq/customcontrollers.py b/src/qt3utils/nidaq/customcontrollers.py
index 0c3bb8b1..6e352ccf 100644
--- a/src/qt3utils/nidaq/customcontrollers.py
+++ b/src/qt3utils/nidaq/customcontrollers.py
@@ -22,16 +22,16 @@ def __init__(self, device_name: str,
         self.scale_nm_per_volt = scale_nm_per_volt
         self.minimum_allowed_position = min_position
         self.maximum_allowed_position = max_position
-        self.settling_time_in_seconds = move_settle_time #10 millisecond settle time
+        self._settling_time_in_seconds = move_settle_time #10 millisecond settle time
         self.last_write_value = None
 
 
 
     def go_to_voltage(self, v: float = None) -> None:
         '''
-        Sets the x,y,z position in microns.
+        !//Sets the x,y,z position in microns.
 
-        You do not need to specify all three axis values in order
+        //You do not need to specify all three axis values in order
         to move in one direction. For example, you can call: go_to_position(z = 40)
 
         raises ValueError if try to set position out of bounds.
@@ -91,4 +91,10 @@ def _nm_to_volts(self, nm: float) -> float:
 
     @staticmethod
     def _volts_to_nm(self, volts: float) -> float:
-        return  self.scale_nm_per_volt * volts
+        return self.scale_nm_per_volt * volts
+    @property
+    def settling_time_in_seconds (self):
+        return self._settling_time_in_seconds
+    @settling_time_in_seconds.setter
+    def settling_time_in_seconds (self, val):
+        self._settling_time_in_seconds = val

From ace09bcf14b998e68690575cb3efc1afa5a4d8e3 Mon Sep 17 00:00:00 2001
From: Fu Lab NV PC <laneb88@uw.edu>
Date: Thu, 16 Nov 2023 14:40:34 -0800
Subject: [PATCH 04/32] Fixed some typos

---
 src/applications/PLEscan.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/applications/PLEscan.py b/src/applications/PLEscan.py
index 578c563f..234a2dc6 100644
--- a/src/applications/PLEscan.py
+++ b/src/applications/PLEscan.py
@@ -184,7 +184,8 @@ def start_scan(self, event = None):
         self.view.sidepanel.startButton['state'] = 'disabled'
         self.view.sidepanel.GotoButton['state'] = 'disabled'
 
-        n_sample_size = self.view.sidepanel.num_pixels.get()
+        n_sample_size = int(self.view.sidepanel.num_pixels.get())
+        sweep_time_entry = float(self.view.sidepanel.sweep_time_entry.get())
         vmin = float(self.view.sidepanel.v_min_entry.get())
         vmax = float(self.view.sidepanel.v_max_entry.get())
         step_size = int((vmax - vmin) / n_sample_size)
@@ -192,8 +193,8 @@ def start_scan(self, event = None):
         args.append(step_size)
         args.append(n_sample_size)
 
-        settling_time = self.view.sidepanel.sweep_tme_entry.get() / n_sample_size
-        self.counter_scanner.waelength_controller.settling_time_in_seconds = settling_time
+        settling_time = sweep_time_entry / n_sample_size
+        self.counter_scanner.wavelength_controller.settling_time_in_seconds = settling_time
 
         self.scan_thread = Thread(target=self.scan_thread_function, args = args)
         self.scan_thread.start()

From 7b6f9e7b4921022e8c34892f9e911e7fbd3fb601 Mon Sep 17 00:00:00 2001
From: Fu Lab NV PC <laneb88@uw.edu>
Date: Tue, 21 Nov 2023 18:19:33 -0800
Subject: [PATCH 05/32] Can set voltage and read from SPCM.

---
 src/applications/PLEscan.py               | 39 ++++++++++++++++++++---
 src/qt3utils/datagenerators/PLEscanner.py | 12 ++++---
 src/qt3utils/nidaq/customcontrollers.py   | 20 ++----------
 3 files changed, 43 insertions(+), 28 deletions(-)

diff --git a/src/applications/PLEscan.py b/src/applications/PLEscan.py
index 234a2dc6..e8646770 100644
--- a/src/applications/PLEscan.py
+++ b/src/applications/PLEscan.py
@@ -54,7 +54,7 @@
                     help='sets min allowed voltage on PLE controller.')
 parser.add_argument('-lmax', '--wavelength-max-position', metavar = 'voltage', default = 10, type=float,
                     help='sets min allowed voltage on PLE controller.')
-parser.add_argument('-lscale', '--wavelength-scale-nm-per-volt', default = 8, type=float,
+parser.add_argument('-lscale', '--wavelength-scale-nm-per-volt', default = 1, type=float,
                     help='sets nanometer to volt scale for PLE controller.')
 parser.add_argument('-r', '--randomtest', action = 'store_true',
                     help='When true, program will run showing random numbers. This is for development testing.')
@@ -81,6 +81,35 @@ def __init__(self, mplcolormap = 'gray'):
         self.ax.set_xlabel('Voltage')
         self.log_data = False
 
+    def update(self, model):
+
+        if self.log_data:
+            data = np.log10(model.scanned_count_rate)
+            data[np.isinf(data)] = 0 #protect against +-inf
+        else:
+            data = model.scanned_count_rate
+
+        self.artist = self.ax.imshow(data, cmap=self.cmap, extent=[model.vmin,
+                                                                   model.vmax + model.step_size,
+                                                                   model.current_t + model.raster_line_pause,
+                                                                   model.rate_counter.num_data_samples_per_batch])
+        if self.cbar is None:
+            self.cbar = self.fig.colorbar(self.artist, ax=self.ax)
+        else:
+            self.cbar.update_normal(self.artist)
+
+        if self.log_data is False:
+            self.cbar.formatter.set_powerlimits((0, 3))
+
+        self.ax.set_xlabel('x position (um)')
+        self.ax.set_ylabel('y position (um)')
+
+    def reset(self):
+        self.ax.cla()
+
+    def set_onclick_callback(self, f):
+        self.onclick_callback = f
+
 
     def onclick(self, event):
         pass
@@ -138,8 +167,8 @@ def __init__(self, root, scan_range):
         tk.Label(frame, text="Voltage Limits (V)").grid(row=row, column=0)
         self.v_lmin_entry = tk.Entry(frame, width=10)
         self.v_lmax_entry = tk.Entry(frame, width=10)
-        self.v_lmin_entry.insert(10, args.wavelength_min_position)
-        self.v_lmax_entry.insert(10, args.wavelength_max_position)
+        self.v_lmin_entry.insert(10, float(args.wavelength_min_position))
+        self.v_lmax_entry.insert(10, float(args.wavelength_max_position))
         self.v_lmin_entry.grid(row=row, column=1)
         self.v_lmax_entry.grid(row=row, column=2)
 
@@ -175,7 +204,7 @@ def __init__(self, counter_scanner):
     def go_to_voltage(self, event = None):
         self.view.sidepanel.startButton['state'] = 'disabled'
         self.view.sidepanel.GotoButton['state'] = 'disabled'
-        self.counter_scanner.go_to_v(self.view.sidepanel.v_entry.get())
+        self.counter_scanner.go_to_v(float(self.view.sidepanel.v_entry.get()))
         self.view.sidepanel.startButton['state'] = 'normal'
         self.view.sidepanel.GotoButton['state'] = 'normal'
 
@@ -188,7 +217,7 @@ def start_scan(self, event = None):
         sweep_time_entry = float(self.view.sidepanel.sweep_time_entry.get())
         vmin = float(self.view.sidepanel.v_min_entry.get())
         vmax = float(self.view.sidepanel.v_max_entry.get())
-        step_size = int((vmax - vmin) / n_sample_size)
+        step_size = (vmax - vmin) / float(n_sample_size)
         args = [vmin, vmax]
         args.append(step_size)
         args.append(n_sample_size)
diff --git a/src/qt3utils/datagenerators/PLEscanner.py b/src/qt3utils/datagenerators/PLEscanner.py
index 464f1176..f2d3ff2b 100644
--- a/src/qt3utils/datagenerators/PLEscanner.py
+++ b/src/qt3utils/datagenerators/PLEscanner.py
@@ -9,9 +9,10 @@ class CounterAndScanner:
     def __init__(self, rate_counter, wavelength_controller):
 
         self.running = False
-        self.current_y = 0
-        self.vmin = wavelength_controller.minimum_allowed_position
-        self.vmax = wavelength_controller.maximum_allowed_position
+        self.current_t = 0
+        self.vmin = float(wavelength_controller.minimum_allowed_position)
+        self.vmax = float(wavelength_controller.maximum_allowed_position)
+        self.tmax = 100
         self._step_size = 0.5
         self.raster_line_pause = 0.150  # wait 150ms for the voltage to settle before a line scan
 
@@ -73,7 +74,7 @@ def still_scanning(self):
         if self.running == False:  # this allows external process to stop scan
             return False
 
-        if self.current_v <= self.vmax:  # stops scan when reaches final position
+        if self.current_t <= self.tmax:  # stops scan when reaches final position
             return True
         else:
             self.running = False
@@ -90,7 +91,7 @@ def move_v(self):
     def go_to_v(self, desired_voltage):
         if self.wavelength_controller and desired_voltage <= self.vmax and desired_voltage >= self.vmin:
             try:
-                self.wavelength_controller.go_to_position(v=self.desired_voltage)
+                self.wavelength_controller.go_to_voltage(v=desired_voltage)
             except ValueError as e:
                 logger.info(f'out of range\n\n{e}')
 
@@ -103,6 +104,7 @@ def scan_v(self):
         raw_counts_for_axis = self.scan_axis('v', self.vmin, self.vmax, self._step_size)
         self.scanned_raw_counts.append(raw_counts_for_axis)
         self.scanned_count_rate.append([self.sample_count_rate(raw_counts) for raw_counts in raw_counts_for_axis])
+        self.current_t = self.current_t + 1
 
     def scan_axis(self, axis, min, max, step_size):
         """
diff --git a/src/qt3utils/nidaq/customcontrollers.py b/src/qt3utils/nidaq/customcontrollers.py
index 6e352ccf..9bfb8df3 100644
--- a/src/qt3utils/nidaq/customcontrollers.py
+++ b/src/qt3utils/nidaq/customcontrollers.py
@@ -41,7 +41,7 @@ def goto(val):
             self._validate_value(val)
             with nidaqmx.Task() as task:
                 task.ao_channels.add_ao_voltage_chan(self.device_name + '/' + self.write_channel)
-                task.write(self._microns_to_volts(val))
+                task.write(self._nm_to_volts(nm=val))
                 self.last_write_value = val
 
         debug_string = []
@@ -61,7 +61,7 @@ def get_current_voltage(self) -> List[float]:
         If no input analog channels were provided when objected was created,
         returns [-1,-1,-1]
         '''
-        output = [-1,-1,-1]
+        output = -1
         if self.read_channel is not None:
             with nidaqmx.Task() as vread, nidaqmx.Task():
 
@@ -71,25 +71,9 @@ def get_current_voltage(self) -> List[float]:
 
         return output
 
-    def get_current_voltage(self) -> List[float]:
-        '''
-        Returns the x,y,z position in microns
-
-        If no input analog channels were provided when objected was created,
-        returns the last requested position.
-        '''
-
-        if self.read_channel is None:
-            return self.last_write_value
-
-        else:
-            return [self._volts_to_nm(v) for v in self.get_current_voltage()]
-
-    @staticmethod
     def _nm_to_volts(self, nm: float) -> float:
         return nm / self.scale_nm_per_volt
 
-    @staticmethod
     def _volts_to_nm(self, volts: float) -> float:
         return self.scale_nm_per_volt * volts
     @property

From 733e79a0ee1a167dd37be79b8a18cab346506faa Mon Sep 17 00:00:00 2001
From: Fu Lab NV PC <laneb88@uw.edu>
Date: Fri, 24 Nov 2023 18:46:38 -0800
Subject: [PATCH 06/32] Fixed issues with PL display.

---
 src/applications/PLEscan.py | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/applications/PLEscan.py b/src/applications/PLEscan.py
index e8646770..f0577dff 100644
--- a/src/applications/PLEscan.py
+++ b/src/applications/PLEscan.py
@@ -88,11 +88,13 @@ def update(self, model):
             data[np.isinf(data)] = 0 #protect against +-inf
         else:
             data = model.scanned_count_rate
+        data = np.array(data).T.tolist()
 
-        self.artist = self.ax.imshow(data, cmap=self.cmap, extent=[model.vmin,
-                                                                   model.vmax + model.step_size,
-                                                                   model.current_t + model.raster_line_pause,
-                                                                   model.rate_counter.num_data_samples_per_batch])
+        self.artist = self.ax.imshow(data, cmap=self.cmap, extent=[model.current_t + model.raster_line_pause,
+                                                                   0,
+                                                                   model.vmin,
+                                                                   model.vmax + model.step_size
+                                                                   ])
         if self.cbar is None:
             self.cbar = self.fig.colorbar(self.artist, ax=self.ax)
         else:
@@ -101,8 +103,9 @@ def update(self, model):
         if self.log_data is False:
             self.cbar.formatter.set_powerlimits((0, 3))
 
-        self.ax.set_xlabel('x position (um)')
-        self.ax.set_ylabel('y position (um)')
+        self.ax.set_xlabel('Pixels')
+        self.ax.set_ylabel('Voltage (V)')
+
 
     def reset(self):
         self.ax.cla()

From 6bf3425d9d0db2b64330e96aff09544cc689c0d3 Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Tue, 26 Dec 2023 20:14:44 -0800
Subject: [PATCH 07/32] Changed module names to be pythonic

---
 src/applications/{PLEscan.py => plescan.py}                  | 2 +-
 src/qt3utils/datagenerators/{PLEscanner.py => plescanner.py} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/applications/{PLEscan.py => plescan.py} (99%)
 rename src/qt3utils/datagenerators/{PLEscanner.py => plescanner.py} (100%)

diff --git a/src/applications/PLEscan.py b/src/applications/plescan.py
similarity index 99%
rename from src/applications/PLEscan.py
rename to src/applications/plescan.py
index f0577dff..fe202f3b 100644
--- a/src/applications/PLEscan.py
+++ b/src/applications/plescan.py
@@ -10,7 +10,7 @@
 import nidaqmx
 import nipiezojenapy
 from qt3utils.nidaq.customcontrollers import VControl
-from qt3utils.datagenerators import PLEscanner
+from qt3utils.datagenerators import plescanner
 
 import qt3utils.datagenerators as datasources
 
diff --git a/src/qt3utils/datagenerators/PLEscanner.py b/src/qt3utils/datagenerators/plescanner.py
similarity index 100%
rename from src/qt3utils/datagenerators/PLEscanner.py
rename to src/qt3utils/datagenerators/plescanner.py

From 8b9222c856f0119ca1e40004e409bfc79d727430 Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Tue, 26 Dec 2023 20:21:57 -0800
Subject: [PATCH 08/32] Cleaned up comments, return types, and unnecessary
 imports

---
 src/applications/plescan.py             |  3 +--
 src/qt3utils/nidaq/customcontrollers.py | 12 ++++--------
 2 files changed, 5 insertions(+), 10 deletions(-)

diff --git a/src/applications/plescan.py b/src/applications/plescan.py
index fe202f3b..e5546eea 100644
--- a/src/applications/plescan.py
+++ b/src/applications/plescan.py
@@ -8,7 +8,6 @@
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
 import matplotlib
 import nidaqmx
-import nipiezojenapy
 from qt3utils.nidaq.customcontrollers import VControl
 from qt3utils.datagenerators import plescanner
 
@@ -300,7 +299,7 @@ def build_data_scanner():
                                   max_position = args.wavelength_max_position,
                                   scale_nm_per_volt = args.wavelength_scale_nm_per_volt)
 
-    scanner = PLEscanner.CounterAndScanner(data_acq, voltage_controller)
+    scanner = plescanner.CounterAndScanner(data_acq, voltage_controller)
 
     return scanner
 
diff --git a/src/qt3utils/nidaq/customcontrollers.py b/src/qt3utils/nidaq/customcontrollers.py
index 9bfb8df3..c71047d8 100644
--- a/src/qt3utils/nidaq/customcontrollers.py
+++ b/src/qt3utils/nidaq/customcontrollers.py
@@ -29,11 +29,7 @@ def __init__(self, device_name: str,
 
     def go_to_voltage(self, v: float = None) -> None:
         '''
-        !//Sets the x,y,z position in microns.
-
-        //You do not need to specify all three axis values in order
-        to move in one direction. For example, you can call: go_to_position(z = 40)
-
+        !//Sets the voltage
         raises ValueError if try to set position out of bounds.
         '''
 
@@ -49,12 +45,12 @@ def goto(val):
             goto(v)
             debug_string.append(f'v: {v:.2f}')
 
-        logger.info(f'go to position {" ".join(debug_string)}')
+        logger.info(f'go to voltage {" ".join(debug_string)}')
 
         time.sleep(self.settling_time_in_seconds) #wait to ensure piezo actuator has settled into position.
         logger.debug(f'last write: {self.last_write_value}')
 
-    def get_current_voltage(self) -> List[float]:
+    def get_current_voltage(self) -> float:
         '''
         Returns the voltage supplied to the three input analog channels.
 
@@ -65,7 +61,7 @@ def get_current_voltage(self) -> List[float]:
         if self.read_channel is not None:
             with nidaqmx.Task() as vread, nidaqmx.Task():
 
-                vread.ai_channels.add_ai_voltage_chan(self.device_name + '/' + self.read_channel, min_val = 0, max_val = 10.0)
+                vread.ai_channels.add_ai_voltage_chan(self.device_name + '/' + self.read_channel, min_val=0, max_val=10.0)
 
                 output = vread.read()
 

From f0d9a423ec1c6da6fa2c7c5ca8ec0bd9b251060b Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Tue, 26 Dec 2023 21:01:47 -0800
Subject: [PATCH 09/32] VControl no longer inherits from nipiezojenapy's base
 control

---
 src/qt3utils/nidaq/customcontrollers.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/qt3utils/nidaq/customcontrollers.py b/src/qt3utils/nidaq/customcontrollers.py
index c71047d8..bdecb750 100644
--- a/src/qt3utils/nidaq/customcontrollers.py
+++ b/src/qt3utils/nidaq/customcontrollers.py
@@ -1,11 +1,9 @@
 import nidaqmx
-import nipiezojenapy
-from typing import List
 import time
 import logging
 
 logger = logging.getLogger(__name__)
-class VControl(nipiezojenapy.BaseControl):
+class VControl():
 
     def __init__(self, device_name: str,
                  write_channel: str = 'ao0',

From 49ff40f6b8fd0e79d370fb10c10974c852457f29 Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Tue, 26 Dec 2023 21:47:52 -0800
Subject: [PATCH 10/32] Removed extraneous goto() inner function

---
 src/qt3utils/nidaq/customcontrollers.py | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/src/qt3utils/nidaq/customcontrollers.py b/src/qt3utils/nidaq/customcontrollers.py
index bdecb750..efb269da 100644
--- a/src/qt3utils/nidaq/customcontrollers.py
+++ b/src/qt3utils/nidaq/customcontrollers.py
@@ -30,21 +30,15 @@ def go_to_voltage(self, v: float = None) -> None:
         !//Sets the voltage
         raises ValueError if try to set position out of bounds.
         '''
-
-        def goto(val):
-            self._validate_value(val)
-            with nidaqmx.Task() as task:
-                task.ao_channels.add_ao_voltage_chan(self.device_name + '/' + self.write_channel)
-                task.write(self._nm_to_volts(nm=val))
-                self.last_write_value = val
-
         debug_string = []
         if v is not None:
-            goto(v)
+            self._validate_value(v)
+            with nidaqmx.Task() as task:
+                task.ao_channels.add_ao_voltage_chan(self.device_name + '/' + self.write_channel)
+                task.write(self._nm_to_volts(nm=v))
+                self.last_write_value = v
             debug_string.append(f'v: {v:.2f}')
-
         logger.info(f'go to voltage {" ".join(debug_string)}')
-
         time.sleep(self.settling_time_in_seconds) #wait to ensure piezo actuator has settled into position.
         logger.debug(f'last write: {self.last_write_value}')
 

From 81505bd8cc74869510d54e92bdb1523a02ddeb29 Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Tue, 26 Dec 2023 22:04:08 -0800
Subject: [PATCH 11/32] Added type hinting for all new classes

---
 src/applications/plescan.py               | 32 +++++++++++------------
 src/qt3utils/datagenerators/plescanner.py | 30 ++++++++++-----------
 2 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/src/applications/plescan.py b/src/applications/plescan.py
index e5546eea..8e4c7137 100644
--- a/src/applications/plescan.py
+++ b/src/applications/plescan.py
@@ -72,7 +72,7 @@
 
 
 class ScanImage:
-    def __init__(self, mplcolormap = 'gray'):
+    def __init__(self, mplcolormap = 'gray') -> None:
         self.fig, self.ax = plt.subplots()
         self.cbar = None
         self.cmap = mplcolormap
@@ -80,7 +80,7 @@ def __init__(self, mplcolormap = 'gray'):
         self.ax.set_xlabel('Voltage')
         self.log_data = False
 
-    def update(self, model):
+    def update(self, model) -> None:
 
         if self.log_data:
             data = np.log10(model.scanned_count_rate)
@@ -106,18 +106,18 @@ def update(self, model):
         self.ax.set_ylabel('Voltage (V)')
 
 
-    def reset(self):
+    def reset(self) -> None:
         self.ax.cla()
 
-    def set_onclick_callback(self, f):
+    def set_onclick_callback(self, f) -> None:
         self.onclick_callback = f
 
 
-    def onclick(self, event):
+    def onclick(self, event) -> None:
         pass
 
 class SidePanel():
-    def __init__(self, root, scan_range):
+    def __init__(self, root, scan_range) -> None:
         frame = tk.Frame(root)
         frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
 
@@ -177,7 +177,7 @@ def __init__(self, root, scan_range):
 
 
 class MainApplicationView():
-    def __init__(self, main_frame, scan_range = [-3, 5]):
+    def __init__(self, main_frame, scan_range = [-3, 5]) -> None:
         frame = tk.Frame(main_frame)
         frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
 
@@ -195,7 +195,7 @@ def __init__(self, main_frame, scan_range = [-3, 5]):
 
 class MainTkApplication():
 
-    def __init__(self, counter_scanner):
+    def __init__(self, counter_scanner) -> None:
         self.counter_scanner = counter_scanner
         self.root = tk.Tk()
         self.view = MainApplicationView(self.root)
@@ -203,7 +203,7 @@ def __init__(self, counter_scanner):
         self.view.sidepanel.GotoButton.bind("<Button>", self.go_to_voltage)
         self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
 
-    def go_to_voltage(self, event = None):
+    def go_to_voltage(self, event = None) -> None:
         self.view.sidepanel.startButton['state'] = 'disabled'
         self.view.sidepanel.GotoButton['state'] = 'disabled'
         self.counter_scanner.go_to_v(float(self.view.sidepanel.v_entry.get()))
@@ -211,7 +211,7 @@ def go_to_voltage(self, event = None):
         self.view.sidepanel.GotoButton['state'] = 'normal'
 
     #TODO: add device/channel name, change functionality to nidaq, add sweep loop and sleep() with settling time
-    def start_scan(self, event = None):
+    def start_scan(self, event = None) -> None:
         self.view.sidepanel.startButton['state'] = 'disabled'
         self.view.sidepanel.GotoButton['state'] = 'disabled'
 
@@ -235,15 +235,15 @@ def start_scan(self, event = None):
         #    task.ao_channels.add_ao_voltage_chan("Dev1/ai0")
         #    task.write(xmin)
 
-    def run(self):
+    def run(self) -> None:
         self.root.title("QT3PLE: Run PLE scan")
         self.root.deiconify()
         self.root.mainloop()
 
-    def stop_scan(self, event = None):
+    def stop_scan(self, event = None) -> None:
         self.counter_scanner.stop()
 
-    def on_closing(self):
+    def on_closing(self) -> None:
         try:
             self.stop_scan()
             self.root.quit()
@@ -252,7 +252,7 @@ def on_closing(self):
             logger.debug(e)
             pass
 
-    def scan_thread_function(self, vmin, vmax, step_size, N):
+    def scan_thread_function(self, vmin, vmax, step_size, N) -> None:
 
         self.counter_scanner.set_scan_range(vmin, vmax)
         self.counter_scanner.step_size = step_size
@@ -278,7 +278,7 @@ def scan_thread_function(self, vmin, vmax, step_size, N):
         self.view.sidepanel.startButton['state'] = 'normal'
         self.view.sidepanel.GotoButton['state'] = 'normal'
 
-def build_data_scanner():
+def build_data_scanner() -> None:
 
     if args.randomtest:
         data_acq = datasources.RandomRateCounter(simulate_single_light_source=True,
@@ -303,7 +303,7 @@ def build_data_scanner():
 
     return scanner
 
-def main():
+def main() -> None:
     tkapp = MainTkApplication(build_data_scanner())
     tkapp.run()
 
diff --git a/src/qt3utils/datagenerators/plescanner.py b/src/qt3utils/datagenerators/plescanner.py
index f2d3ff2b..3a86f348 100644
--- a/src/qt3utils/datagenerators/plescanner.py
+++ b/src/qt3utils/datagenerators/plescanner.py
@@ -6,7 +6,7 @@
 
 
 class CounterAndScanner:
-    def __init__(self, rate_counter, wavelength_controller):
+    def __init__(self, rate_counter, wavelength_controller) -> None:
 
         self.running = False
         self.current_t = 0
@@ -23,34 +23,34 @@ def __init__(self, rate_counter, wavelength_controller):
         self.rate_counter = rate_counter
         self.num_daq_batches = 1  # could change to 10 if want 10x more samples for each position
 
-    def stop(self):
+    def stop(self) -> None:
         self.rate_counter.stop()
         self.running = False
 
-    def start(self):
+    def start(self) -> None:
         self.running = True
         self.rate_counter.start()
 
-    def set_to_starting_position(self):
+    def set_to_starting_position(self) -> None:
         self.current_v = self.vmin
         if self.wavelength_controller:
             self.wavelength_controller.go_to_voltage(v=self.vmin)
 
-    def close(self):
+    def close(self) -> None:
         self.rate_counter.close()
 
-    def set_num_data_samples_per_batch(self, N):
+    def set_num_data_samples_per_batch(self, N) -> None:
         self.rate_counter.num_data_samples_per_batch = N
 
-    def sample_counts(self):
+    def sample_counts(self) -> np.ndarray:
         return self.rate_counter.sample_counts(self.num_daq_batches)
 
-    def sample_count_rate(self, data_counts=None):
+    def sample_count_rate(self, data_counts=None) -> np.floating:
         if data_counts is None:
             data_counts = self.sample_counts()
         return self.rate_counter.sample_count_rate(data_counts)
 
-    def set_scan_range(self, vmin, vmax):
+    def set_scan_range(self, vmin, vmax) -> None:
         if self.wavelength_controller:
             self.wavelength_controller.check_allowed_position(vmin, vmin)
         self.vmin = vmin
@@ -70,7 +70,7 @@ def get_completed_scan_range(self) -> tuple:
         """
         return self.xmin, self.xmax, self.current_v
 
-    def still_scanning(self):
+    def still_scanning(self) -> None:
         if self.running == False:  # this allows external process to stop scan
             return False
 
@@ -80,7 +80,7 @@ def still_scanning(self):
             self.running = False
             return False
 
-    def move_v(self):
+    def move_v(self) -> None:
         self.current_v += self._step_size
         if self.wavelength_controller and self.current_v <= self.vmax:
             try:
@@ -88,14 +88,14 @@ def move_v(self):
             except ValueError as e:
                 logger.info(f'out of range\n\n{e}')
 
-    def go_to_v(self, desired_voltage):
+    def go_to_v(self, desired_voltage) -> None:
         if self.wavelength_controller and desired_voltage <= self.vmax and desired_voltage >= self.vmin:
             try:
                 self.wavelength_controller.go_to_voltage(v=desired_voltage)
             except ValueError as e:
                 logger.info(f'out of range\n\n{e}')
 
-    def scan_v(self):
+    def scan_v(self) -> None:
         """
         Scans the wavelengths from vmin to vmax in steps of step_size.
 
@@ -106,7 +106,7 @@ def scan_v(self):
         self.scanned_count_rate.append([self.sample_count_rate(raw_counts) for raw_counts in raw_counts_for_axis])
         self.current_t = self.current_t + 1
 
-    def scan_axis(self, axis, min, max, step_size):
+    def scan_axis(self, axis, min, max, step_size) -> list:
         """
         Moves the stage along the specified axis from min to max in steps of step_size.
         Returns a list of raw counts from the scan in the shape
@@ -128,7 +128,7 @@ def scan_axis(self, axis, min, max, step_size):
 
         return raw_counts
 
-    def reset(self):
+    def reset(self) -> None:
         self.scanned_raw_counts = []
         self.scanned_count_rate = []
 

From b553d39964287ad0453abde6dde0c4b415986484 Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Sun, 7 Jan 2024 17:05:43 -0800
Subject: [PATCH 12/32] Movd plescan.py to its own application directory

---
 .../plescan.py => qt3utils/applications/qt3ple/main.py}          | 1 -
 1 file changed, 1 deletion(-)
 rename src/{applications/plescan.py => qt3utils/applications/qt3ple/main.py} (99%)

diff --git a/src/applications/plescan.py b/src/qt3utils/applications/qt3ple/main.py
similarity index 99%
rename from src/applications/plescan.py
rename to src/qt3utils/applications/qt3ple/main.py
index 8e4c7137..f6d5996a 100644
--- a/src/applications/plescan.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -210,7 +210,6 @@ def go_to_voltage(self, event = None) -> None:
         self.view.sidepanel.startButton['state'] = 'normal'
         self.view.sidepanel.GotoButton['state'] = 'normal'
 
-    #TODO: add device/channel name, change functionality to nidaq, add sweep loop and sleep() with settling time
     def start_scan(self, event = None) -> None:
         self.view.sidepanel.startButton['state'] = 'disabled'
         self.view.sidepanel.GotoButton['state'] = 'disabled'

From 80265ec8aeb105c67bc11f7758fbca8ca1be44c1 Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Sun, 7 Jan 2024 17:10:49 -0800
Subject: [PATCH 13/32] Added qt3ple to pyproject.toml

---
 pyproject.toml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index ff6a86d5..8fe9f99f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -10,7 +10,7 @@ description = "A package for performing experiments in the QT3 lab at UW."
 readme = "README.md"
 requires-python = ">=3.8"
 license = {file = "LICENSE"}
-keywords = ["qt3", "confocal scan", "nidaqmx", "piezo", "stage", "control", "electron spin control"]
+keywords = ["qt3", "confocal scan", "nidaqmx", "piezo", "stage", "control", "electron spin control", "ple"]
 
 authors = [
     {name = "G. Adam Cox", email = "gadamc@gmail.com" },
@@ -64,6 +64,7 @@ dependencies = [
 [project.scripts]
 qt3scope = "qt3utils.applications.qt3scope.main:main"
 qt3scan = "qt3utils.applications.qt3scan.main:main"
+qt3ple = "qt3utils.applications.qt3ple.main:main"
 
 [tool.setuptools.package-data]
 "qt3utils.applications.controllers" = ["*.yaml"]

From 2929b236db24a57f640e77747d77b9b534d28ebd Mon Sep 17 00:00:00 2001
From: Lane <laneb88@uw.edu>
Date: Wed, 10 Jan 2024 18:42:02 -0800
Subject: [PATCH 14/32] Reformatted PLE's main.py for readability. Reintroduced
 check_allowed_position back into VControl after incidental removal when
 inheritance was removed.

---
 src/qt3utils/applications/qt3ple/main.py  | 74 +++++++++++------------
 src/qt3utils/datagenerators/plescanner.py |  3 +-
 src/qt3utils/nidaq/customcontrollers.py   | 11 ++++
 3 files changed, 49 insertions(+), 39 deletions(-)

diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index f6d5996a..5f8faedf 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -15,22 +15,21 @@
 
 matplotlib.use('Agg')
 
-
 parser = argparse.ArgumentParser(description='NI DAQ (PCIx 6363) / PLE Scanner',
                                  formatter_class=argparse.ArgumentDefaultsHelpFormatter)
 
-parser.add_argument('-d', '--daq-name', default = 'Dev1', type=str, metavar = 'daq_name',
+parser.add_argument('-d', '--daq-name', default='Dev1', type=str, metavar='daq_name',
                     help='NI DAQ Device Name')
-parser.add_argument('-st', '--signal-terminal', metavar = 'terminal', default = 'PFI0', type=str,
+parser.add_argument('-st', '--signal-terminal', metavar='terminal', default='PFI0', type=str,
                     help='NI DAQ terminal connected to input digital TTL signal')
-parser.add_argument('-c', '--clock-rate', metavar = 'rate (Hz)', default = 100000, type=int,
+parser.add_argument('-c', '--clock-rate', metavar='rate (Hz)', default=100000, type=int,
                     help='''Specifies the clock rate in Hz. If using an external clock,
                     you should specifiy the clock rate here so that the correct counts per
                     second are displayed. If using the internal NI DAQ clock (default behavior),
                     this value specifies the clock rate to use. Per the NI DAQ manual,
                     use a suitable clock rate for the device for best performance, which is an integer
                     multiple downsample of the digital sample clock.''')
-parser.add_argument('-n', '--num-data-samples-per-batch', metavar = 'N', default = 250, type=int,
+parser.add_argument('-n', '--num-data-samples-per-batch', metavar='N', default=250, type=int,
                     help='''Number of data points to acquire per DAQ batch request.
                            Note that only ONE data point is shown in the scope.
                            After each request to the NI DAQ for data, the mean count
@@ -38,28 +37,28 @@
                            the "num-data-samples-per-batch" should reduce your noise, but
                            slow the response of the scope. Increase this value if the
                            scope appears too noisy.''')
-parser.add_argument('-ct', '--clock-terminal', metavar = 'terminal', default = None, type=str,
+parser.add_argument('-ct', '--clock-terminal', metavar='terminal', default=None, type=str,
                     help='''Specifies the digital input terminal to the NI DAQ to use for a clock.
                             If None, which is the default, the internal NI DAQ clock is used.''')
-parser.add_argument('-to', '--rwtimeout', metavar = 'seconds', default = 10, type=int,
+parser.add_argument('-to', '--rwtimeout', metavar='seconds', default=10, type=int,
                     help='NI DAQ read/write timeout in seconds.')
-parser.add_argument('-sc', '--signal-counter', metavar = 'ctrN', default = 'ctr2', type=str,
+parser.add_argument('-sc', '--signal-counter', metavar='ctrN', default='ctr2', type=str,
                     help='NI DAQ interal counter (ctr1, ctr2, ctr3, ctr4)')
-parser.add_argument('--wavelength-write-channel', metavar = 'ch0', default = 'ao0', type=str,
+parser.add_argument('--wavelength-write-channel', metavar='ch0', default='ao0', type=str,
                     help='Analog output channel used to control the wavelength of the laser')
-parser.add_argument('--wavelength-read-channel', metavar = 'ch0', default = 'ai0', type=str,
+parser.add_argument('--wavelength-read-channel', metavar='ch0', default='ai0', type=str,
                     help='Analog input channels used to read the instantaneous wavelength')
-parser.add_argument('-lmin', '--wavelength-min-position', metavar = 'voltage', default = -10, type=float,
+parser.add_argument('-lmin', '--wavelength-min-position', metavar='voltage', default=-10, type=float,
                     help='sets min allowed voltage on PLE controller.')
-parser.add_argument('-lmax', '--wavelength-max-position', metavar = 'voltage', default = 10, type=float,
+parser.add_argument('-lmax', '--wavelength-max-position', metavar='voltage', default=10, type=float,
                     help='sets min allowed voltage on PLE controller.')
-parser.add_argument('-lscale', '--wavelength-scale-nm-per-volt', default = 1, type=float,
+parser.add_argument('-lscale', '--wavelength-scale-nm-per-volt', default=1, type=float,
                     help='sets nanometer to volt scale for PLE controller.')
-parser.add_argument('-r', '--randomtest', action = 'store_true',
+parser.add_argument('-r', '--randomtest', action='store_true',
                     help='When true, program will run showing random numbers. This is for development testing.')
-parser.add_argument('-q', '--quiet', action = 'store_true',
+parser.add_argument('-q', '--quiet', action='store_true',
                     help='When true,logger level will be set to warning. Otherwise, set to "info".')
-parser.add_argument('-cmap', metavar = '<MPL color>', default = 'gray',
+parser.add_argument('-cmap', metavar='<MPL color>', default='gray',
                     help='Set the MatplotLib colormap scale')
 
 args = parser.parse_args()
@@ -72,7 +71,7 @@
 
 
 class ScanImage:
-    def __init__(self, mplcolormap = 'gray') -> None:
+    def __init__(self, mplcolormap='gray') -> None:
         self.fig, self.ax = plt.subplots()
         self.cbar = None
         self.cmap = mplcolormap
@@ -84,7 +83,7 @@ def update(self, model) -> None:
 
         if self.log_data:
             data = np.log10(model.scanned_count_rate)
-            data[np.isinf(data)] = 0 #protect against +-inf
+            data[np.isinf(data)] = 0  # protect against +-inf
         else:
             data = model.scanned_count_rate
         data = np.array(data).T.tolist()
@@ -105,24 +104,23 @@ def update(self, model) -> None:
         self.ax.set_xlabel('Pixels')
         self.ax.set_ylabel('Voltage (V)')
 
-
     def reset(self) -> None:
         self.ax.cla()
 
     def set_onclick_callback(self, f) -> None:
         self.onclick_callback = f
 
-
     def onclick(self, event) -> None:
         pass
 
+
 class SidePanel():
     def __init__(self, root, scan_range) -> None:
         frame = tk.Frame(root)
         frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
 
         row = 0
-        tk.Label(frame, text="Scan Settings", font='Helvetica 16').grid(row=row, column=0,pady=10)
+        tk.Label(frame, text="Scan Settings", font='Helvetica 16').grid(row=row, column=0, pady=10)
         row += 1
         self.startButton = tk.Button(frame, text="Start Scan")
         self.startButton.grid(row=row, column=0)
@@ -137,7 +135,7 @@ def __init__(self, root, scan_range) -> None:
 
         row += 1
         tk.Label(frame, text="Number of Pixels").grid(row=row, column=0)
-        self.num_pixels= tk.Entry(frame, width=10)
+        self.num_pixels = tk.Entry(frame, width=10)
         self.num_pixels.insert(10, 150)
         self.num_pixels.grid(row=row, column=1)
 
@@ -154,7 +152,7 @@ def __init__(self, root, scan_range) -> None:
         self.sweep_time_entry.grid(row=row, column=1)
 
         row += 1
-        tk.Label(frame, text="DAQ Settings", font='Helvetica 16').grid(row=row, column=0,pady=10)
+        tk.Label(frame, text="DAQ Settings", font='Helvetica 16').grid(row=row, column=0, pady=10)
 
         row += 1
         self.GotoButton = tk.Button(frame, text="Go To Voltage")
@@ -175,9 +173,8 @@ def __init__(self, root, scan_range) -> None:
         self.v_lmax_entry.grid(row=row, column=2)
 
 
-
 class MainApplicationView():
-    def __init__(self, main_frame, scan_range = [-3, 5]) -> None:
+    def __init__(self, main_frame, scan_range=[-3, 5]) -> None:
         frame = tk.Frame(main_frame)
         frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
 
@@ -193,6 +190,7 @@ def __init__(self, main_frame, scan_range = [-3, 5]) -> None:
 
         self.canvas.draw()
 
+
 class MainTkApplication():
 
     def __init__(self, counter_scanner) -> None:
@@ -203,14 +201,14 @@ def __init__(self, counter_scanner) -> None:
         self.view.sidepanel.GotoButton.bind("<Button>", self.go_to_voltage)
         self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
 
-    def go_to_voltage(self, event = None) -> None:
+    def go_to_voltage(self, event=None) -> None:
         self.view.sidepanel.startButton['state'] = 'disabled'
         self.view.sidepanel.GotoButton['state'] = 'disabled'
         self.counter_scanner.go_to_v(float(self.view.sidepanel.v_entry.get()))
         self.view.sidepanel.startButton['state'] = 'normal'
         self.view.sidepanel.GotoButton['state'] = 'normal'
 
-    def start_scan(self, event = None) -> None:
+    def start_scan(self, event=None) -> None:
         self.view.sidepanel.startButton['state'] = 'disabled'
         self.view.sidepanel.GotoButton['state'] = 'disabled'
 
@@ -226,11 +224,10 @@ def start_scan(self, event = None) -> None:
         settling_time = sweep_time_entry / n_sample_size
         self.counter_scanner.wavelength_controller.settling_time_in_seconds = settling_time
 
-        self.scan_thread = Thread(target=self.scan_thread_function, args = args)
+        self.scan_thread = Thread(target=self.scan_thread_function, args=args)
         self.scan_thread.start()
 
-
-        #with nidaqmx.Task() as task:
+        # with nidaqmx.Task() as task:
         #    task.ao_channels.add_ao_voltage_chan("Dev1/ai0")
         #    task.write(xmin)
 
@@ -239,7 +236,7 @@ def run(self) -> None:
         self.root.deiconify()
         self.root.mainloop()
 
-    def stop_scan(self, event = None) -> None:
+    def stop_scan(self, event=None) -> None:
         self.counter_scanner.stop()
 
     def on_closing(self) -> None:
@@ -277,8 +274,8 @@ def scan_thread_function(self, vmin, vmax, step_size, N) -> None:
         self.view.sidepanel.startButton['state'] = 'normal'
         self.view.sidepanel.GotoButton['state'] = 'normal'
 
-def build_data_scanner() -> None:
 
+def build_data_scanner() -> None:
     if args.randomtest:
         data_acq = datasources.RandomRateCounter(simulate_single_light_source=True,
                                                  num_data_samples_per_batch=args.num_data_samples_per_batch)
@@ -291,17 +288,18 @@ def build_data_scanner() -> None:
                                                             args.rwtimeout,
                                                             args.signal_counter)
 
-    voltage_controller = VControl(device_name = args.daq_name,
-                                  write_channel = args.wavelength_write_channel,
-                                  read_channel = args.wavelength_read_channel,
-                                  min_position = args.wavelength_min_position,
-                                  max_position = args.wavelength_max_position,
-                                  scale_nm_per_volt = args.wavelength_scale_nm_per_volt)
+    voltage_controller = VControl(device_name=args.daq_name,
+                                  write_channel=args.wavelength_write_channel,
+                                  read_channel=args.wavelength_read_channel,
+                                  min_position=args.wavelength_min_position,
+                                  max_position=args.wavelength_max_position,
+                                  scale_nm_per_volt=args.wavelength_scale_nm_per_volt)
 
     scanner = plescanner.CounterAndScanner(data_acq, voltage_controller)
 
     return scanner
 
+
 def main() -> None:
     tkapp = MainTkApplication(build_data_scanner())
     tkapp.run()
diff --git a/src/qt3utils/datagenerators/plescanner.py b/src/qt3utils/datagenerators/plescanner.py
index 3a86f348..b35591ad 100644
--- a/src/qt3utils/datagenerators/plescanner.py
+++ b/src/qt3utils/datagenerators/plescanner.py
@@ -52,7 +52,8 @@ def sample_count_rate(self, data_counts=None) -> np.floating:
 
     def set_scan_range(self, vmin, vmax) -> None:
         if self.wavelength_controller:
-            self.wavelength_controller.check_allowed_position(vmin, vmin)
+            self.wavelength_controller.check_allowed_position(vmin)
+            self.wavelength_controller.check_allowed_position(vmax)
         self.vmin = vmin
         self.vmax = vmax
 
diff --git a/src/qt3utils/nidaq/customcontrollers.py b/src/qt3utils/nidaq/customcontrollers.py
index efb269da..a0440590 100644
--- a/src/qt3utils/nidaq/customcontrollers.py
+++ b/src/qt3utils/nidaq/customcontrollers.py
@@ -59,6 +59,17 @@ def get_current_voltage(self) -> float:
 
         return output
 
+    def check_allowed_position(self, v: float = None) -> None:
+        if v is not None: self._validate_value(v)
+
+    def _validate_value(self, voltage: float) -> None:
+        voltage = float(voltage)
+        if type(voltage) not in [type(1.0), type(1)]:
+            raise TypeError(f'value {voltage} is not a valid type.')
+        if voltage < self.minimum_allowed_position:
+            raise ValueError(f'value {voltage} is less than {self.minimum_allowed_position: .3f}.')
+        if voltage > self.maximum_allowed_position:
+            raise ValueError(f'value {voltage} is greater than {self.maximum_allowed_position: .3f}.')
     def _nm_to_volts(self, nm: float) -> float:
         return nm / self.scale_nm_per_volt
 

From e63e588585002ea46a85fc2473f333a8368d619d Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Fri, 12 Jan 2024 18:18:58 -0800
Subject: [PATCH 15/32] Added Save Scan and Stop Scan buttons

---
 src/qt3utils/applications/qt3ple/main.py  | 37 +++++++++++++++++++++++
 src/qt3utils/datagenerators/plescanner.py |  2 +-
 2 files changed, 38 insertions(+), 1 deletion(-)

diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index 5f8faedf..c60f0121 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -7,6 +7,7 @@
 import matplotlib.pyplot as plt
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
 import matplotlib
+import h5py
 import nidaqmx
 from qt3utils.nidaq.customcontrollers import VControl
 from qt3utils.datagenerators import plescanner
@@ -124,6 +125,10 @@ def __init__(self, root, scan_range) -> None:
         row += 1
         self.startButton = tk.Button(frame, text="Start Scan")
         self.startButton.grid(row=row, column=0)
+        self.stopButton = tk.Button(frame, text="Stop Scan")
+        self.stopButton.grid(row=row, column=1)
+        self.saveScanButton = tk.Button(frame, text="Save Scan")
+        self.saveScanButton.grid(row=row, column=2)
         row += 1
         tk.Label(frame, text="Voltage Range (V)").grid(row=row, column=0)
         self.v_min_entry = tk.Entry(frame, width=10)
@@ -173,6 +178,8 @@ def __init__(self, root, scan_range) -> None:
         self.v_lmax_entry.grid(row=row, column=2)
 
 
+
+
 class MainApplicationView():
     def __init__(self, main_frame, scan_range=[-3, 5]) -> None:
         frame = tk.Frame(main_frame)
@@ -198,6 +205,8 @@ def __init__(self, counter_scanner) -> None:
         self.root = tk.Tk()
         self.view = MainApplicationView(self.root)
         self.view.sidepanel.startButton.bind("<Button>", self.start_scan)
+        self.view.sidepanel.saveScanButton.bind("<Button>", self.save_scan)
+        self.view.sidepanel.stopButton.bind("<Button>", self.stop_scan)
         self.view.sidepanel.GotoButton.bind("<Button>", self.go_to_voltage)
         self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
 
@@ -274,6 +283,34 @@ def scan_thread_function(self, vmin, vmax, step_size, N) -> None:
         self.view.sidepanel.startButton['state'] = 'normal'
         self.view.sidepanel.GotoButton['state'] = 'normal'
 
+    def save_scan(self, event = None):
+        myformats = [('Compressed Numpy MultiArray', '*.npz'), ('Numpy Array (count rate only)', '*.npy'), ('HDF5', '*.h5')]
+        afile = tk.filedialog.asksaveasfilename(filetypes=myformats, defaultextension='.npz')
+        logger.info(afile)
+        file_type = afile.split('.')[-1]
+        if afile is None or afile == '':
+            return # selection was canceled.
+
+        data = dict(
+            raw_counts=self.counter_scanner.scanned_raw_counts,
+            count_rate=self.counter_scanner.scanned_count_rate,
+            scan_range=self.counter_scanner.get_completed_scan_range(),
+            step_size=self.counter_scanner.step_size,
+            daq_clock_rate=self.counter_scanner.rate_counter.clock_rate,
+        )
+
+        if file_type == 'npy':
+            np.save(afile, data['count_rate'])
+
+        if file_type == 'npz':
+            np.savez_compressed(afile, **data)
+
+        elif file_type == 'h5':
+            h5file = h5py.File(afile, 'w')
+            for key, value in data.items():
+                h5file.create_dataset(key, data=value)
+            h5file.close()
+
 
 def build_data_scanner() -> None:
     if args.randomtest:
diff --git a/src/qt3utils/datagenerators/plescanner.py b/src/qt3utils/datagenerators/plescanner.py
index b35591ad..ae3ab387 100644
--- a/src/qt3utils/datagenerators/plescanner.py
+++ b/src/qt3utils/datagenerators/plescanner.py
@@ -69,7 +69,7 @@ def get_completed_scan_range(self) -> tuple:
         Returns a tuple of the scan range that has been completed
         :return: xmin, xmax, ymin, current_y
         """
-        return self.xmin, self.xmax, self.current_v
+        return self.vmin, self.vmax, self.current_v
 
     def still_scanning(self) -> None:
         if self.running == False:  # this allows external process to stop scan

From 6c6b85fd757a822166c1919c10b10f0cb14cb790 Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Mon, 15 Jan 2024 19:06:47 -0800
Subject: [PATCH 16/32] Changed QT3PLE to run off of YAML files (untested)

---
 .../controllers/nidaq_rate_counter.yaml       |  37 +++
 src/qt3utils/applications/qt3ple/main.py      | 289 ++++++++++++++----
 2 files changed, 261 insertions(+), 65 deletions(-)
 create mode 100644 src/qt3utils/applications/controllers/nidaq_rate_counter.yaml

diff --git a/src/qt3utils/applications/controllers/nidaq_rate_counter.yaml b/src/qt3utils/applications/controllers/nidaq_rate_counter.yaml
new file mode 100644
index 00000000..6baefa7a
--- /dev/null
+++ b/src/qt3utils/applications/controllers/nidaq_rate_counter.yaml
@@ -0,0 +1,37 @@
+QT3PLE:
+  DAQCounter:
+    import_path : qt3utils.applications.controllers.nidaqedgecounter
+    class_name  : QT3ScopeNIDAQEdgeCounterController
+    configure :
+      daq_name : Dev1  # NI DAQ Device Name
+      signal_terminal : PFI0  # NI DAQ terminal connected to input digital TTL signal
+      clock_terminal :    # Specifies the digital input terminal to the NI DAQ to use for a clock. If left blank, interprets as None or NULL
+      clock_rate: 100000  # NI DAQ clock rate in Hz
+      num_data_samples_per_batch : 1000
+      read_write_timeout : 10  # timeout in seconds for read/write operations
+      signal_counter : ctr2  # NI DAQ counter to use for counting the input signal, e.g. ctr0, ctr1, ctr2, or ctr3
+# notes
+
+# clock_rate:
+#   Specifies the clock rate in Hz. If using an external clock,
+#   you should specifiy the clock rate here so that the correct counts per
+#   second are displayed. If using the internal NI DAQ clock (default behavior),
+#   this value specifies the clock rate to use. Per the NI DAQ manual,
+#   use a suitable clock rate for the device for best performance, which is an integer
+#   multiple downsample of the digital sample clock.
+
+# clock_terminal:
+#   Specifies the digital input terminal to the NI DAQ to use for a clock.
+#   If None, the internal NI DAQ clock is used. Otherwise, a string value
+#   specifies the terminal to use for the clock.
+
+  VoltageController:
+    import_path : qt3utils.nidaq.customcontrollers
+    class_name  : VControl
+    configure :
+      daq_name : Dev1  # NI DAQ Device Name
+      write_channels : ao0  # NI DAQ analog output channels to use for writing position
+      read_channels : ai0  # NI DAQ analog input channels to use for reading position
+      min_position: -10  # conversion factor from volts to microns, can also supply a list [8,8,8] or [6,4.2,5]
+      max_position: 10  # the voltage value that defines the position 0,0,0, can also supply a list [0,0,0] or [5,5,5]
+      scale_nm_per_volt: 1  # microns
\ No newline at end of file
diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index c60f0121..1523d89a 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -2,6 +2,10 @@
 import tkinter as tk
 import logging
 from threading import Thread
+import yaml
+import importlib
+import importlib.resources
+from typing import Any, Protocol
 
 import numpy as np
 import matplotlib.pyplot as plt
@@ -11,7 +15,7 @@
 import nidaqmx
 from qt3utils.nidaq.customcontrollers import VControl
 from qt3utils.datagenerators import plescanner
-
+from qt3utils.applications.controllers.nidaqedgecounter import QT3ScopeNIDAQEdgeCounterController
 import qt3utils.datagenerators as datasources
 
 matplotlib.use('Agg')
@@ -19,44 +23,6 @@
 parser = argparse.ArgumentParser(description='NI DAQ (PCIx 6363) / PLE Scanner',
                                  formatter_class=argparse.ArgumentDefaultsHelpFormatter)
 
-parser.add_argument('-d', '--daq-name', default='Dev1', type=str, metavar='daq_name',
-                    help='NI DAQ Device Name')
-parser.add_argument('-st', '--signal-terminal', metavar='terminal', default='PFI0', type=str,
-                    help='NI DAQ terminal connected to input digital TTL signal')
-parser.add_argument('-c', '--clock-rate', metavar='rate (Hz)', default=100000, type=int,
-                    help='''Specifies the clock rate in Hz. If using an external clock,
-                    you should specifiy the clock rate here so that the correct counts per
-                    second are displayed. If using the internal NI DAQ clock (default behavior),
-                    this value specifies the clock rate to use. Per the NI DAQ manual,
-                    use a suitable clock rate for the device for best performance, which is an integer
-                    multiple downsample of the digital sample clock.''')
-parser.add_argument('-n', '--num-data-samples-per-batch', metavar='N', default=250, type=int,
-                    help='''Number of data points to acquire per DAQ batch request.
-                           Note that only ONE data point is shown in the scope.
-                           After each request to the NI DAQ for data, the mean count
-                           rate from the batch is computed and displayed. Increasing
-                           the "num-data-samples-per-batch" should reduce your noise, but
-                           slow the response of the scope. Increase this value if the
-                           scope appears too noisy.''')
-parser.add_argument('-ct', '--clock-terminal', metavar='terminal', default=None, type=str,
-                    help='''Specifies the digital input terminal to the NI DAQ to use for a clock.
-                            If None, which is the default, the internal NI DAQ clock is used.''')
-parser.add_argument('-to', '--rwtimeout', metavar='seconds', default=10, type=int,
-                    help='NI DAQ read/write timeout in seconds.')
-parser.add_argument('-sc', '--signal-counter', metavar='ctrN', default='ctr2', type=str,
-                    help='NI DAQ interal counter (ctr1, ctr2, ctr3, ctr4)')
-parser.add_argument('--wavelength-write-channel', metavar='ch0', default='ao0', type=str,
-                    help='Analog output channel used to control the wavelength of the laser')
-parser.add_argument('--wavelength-read-channel', metavar='ch0', default='ai0', type=str,
-                    help='Analog input channels used to read the instantaneous wavelength')
-parser.add_argument('-lmin', '--wavelength-min-position', metavar='voltage', default=-10, type=float,
-                    help='sets min allowed voltage on PLE controller.')
-parser.add_argument('-lmax', '--wavelength-max-position', metavar='voltage', default=10, type=float,
-                    help='sets min allowed voltage on PLE controller.')
-parser.add_argument('-lscale', '--wavelength-scale-nm-per-volt', default=1, type=float,
-                    help='sets nanometer to volt scale for PLE controller.')
-parser.add_argument('-r', '--randomtest', action='store_true',
-                    help='When true, program will run showing random numbers. This is for development testing.')
 parser.add_argument('-q', '--quiet', action='store_true',
                     help='When true,logger level will be set to warning. Otherwise, set to "info".')
 parser.add_argument('-cmap', metavar='<MPL color>', default='gray',
@@ -70,6 +36,21 @@
 if args.quiet is False:
     logger.setLevel(logging.INFO)
 
+NIDAQ_DEVICE_NAME = 'NIDAQ Rate Counter'
+RANDOM_DAQ_DEVICE_NAME = 'Random Data Generator'
+
+DEFAULT_DAQ_DEVICE_NAME = NIDAQ_DEVICE_NAME
+
+CONTROLLER_PATH = 'qt3utils.applications.controllers'
+SUPPORTED_CONTROLLERS = {NIDAQ_DEVICE_NAME: 'nidaq_rate_counter.yaml'
+                         }
+STANDARD_CONTROLLERS = {NIDAQ_DEVICE_NAME: {'yaml': 'nidaq_rate_counter.yaml',
+                                                'application_controller_class': VControl}
+                        }
+CONFIG_FILE_APPLICATION_NAME = 'QT3PLE'
+CONFIG_FILE_DAQ_DEVICE = 'DAQCounter'
+CONFIG_FILE_VOLTAGE_CONTROLLER = 'VoltageController'
+CONFIG_FILE_DAQ_CONTROLLER = 'DAQController'
 
 class ScanImage:
     def __init__(self, mplcolormap='gray') -> None:
@@ -117,7 +98,7 @@ def onclick(self, event) -> None:
 
 class SidePanel():
     def __init__(self, root, scan_range) -> None:
-        frame = tk.Frame(root)
+        frame = tk.Frame(root.root)
         frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
 
         row = 0
@@ -172,17 +153,40 @@ def __init__(self, root, scan_range) -> None:
         tk.Label(frame, text="Voltage Limits (V)").grid(row=row, column=0)
         self.v_lmin_entry = tk.Entry(frame, width=10)
         self.v_lmax_entry = tk.Entry(frame, width=10)
-        self.v_lmin_entry.insert(10, float(args.wavelength_min_position))
-        self.v_lmax_entry.insert(10, float(args.wavelength_max_position))
+        self.v_lmin_entry.insert(10, float(scan_range[0]))
+        self.v_lmax_entry.insert(10, float(scan_range[1]))
         self.v_lmin_entry.grid(row=row, column=1)
         self.v_lmax_entry.grid(row=row, column=2)
 
+        row+=1
+        self.controller_option = tk.StringVar(frame)
+        self.controller_option.set(DEFAULT_DAQ_DEVICE_NAME)  # setting the default value
+
+        #self.controller_menu = tk.OptionMenu(frame,
+        #                                     self.controller_option,
+        #                                     *STANDARD_CONTROLLERS.keys(),
+        #                                     command=root.load_daq_from_config_dict)
+        self.controller_menu = tk.OptionMenu(frame,
+                                             self.controller_option,
+                                             *STANDARD_CONTROLLERS.keys(),
+                                             command=root.load_controller_from_name)
+
+        self.controller_menu.grid(row=row, column=0, columnspan=3)
 
+        row += 1
+        self.daq_config_button = tk.Button(frame, text="Data Acquisition Config")
+        self.daq_config_button.grid(row=row, column=0, columnspan=3)
+        row += 1
+        self.hardware_config_button = tk.Button(frame, text="Configure Hardware")
+        self.hardware_config_button.grid(row=row, column=0, columnspan=3)
+        row += 1
+        self.hardware_config_from_yaml_button = tk.Button(frame, text="Load YAML Config")
+        self.hardware_config_from_yaml_button.grid(row=row, column=0, columnspan=3)
 
 
 class MainApplicationView():
     def __init__(self, main_frame, scan_range=[-3, 5]) -> None:
-        frame = tk.Frame(main_frame)
+        frame = tk.Frame(main_frame.root)
         frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
 
         self.scan_view = ScanImage(args.cmap)
@@ -197,29 +201,49 @@ def __init__(self, main_frame, scan_range=[-3, 5]) -> None:
 
         self.canvas.draw()
 
+    @property
+    def hardware_config_button(self) -> tk.Button:
+        return self.sidepanel.hardware_config_button
+
 
 class MainTkApplication():
 
-    def __init__(self, counter_scanner) -> None:
-        self.counter_scanner = counter_scanner
+    def __init__(self, controller_name) -> None:
+        #self.counter_scanner = counter_scanner
         self.root = tk.Tk()
-        self.view = MainApplicationView(self.root)
+        self.view = MainApplicationView(self)
+        self.view.controller_option = controller_name
+        # data acquisition model that is used to acquire data
+        self.data_acquisition_model = None
+        # load the data acquisition model
+        self.load_daq_from_config_dict(controller_name)
         self.view.sidepanel.startButton.bind("<Button>", self.start_scan)
         self.view.sidepanel.saveScanButton.bind("<Button>", self.save_scan)
         self.view.sidepanel.stopButton.bind("<Button>", self.stop_scan)
         self.view.sidepanel.GotoButton.bind("<Button>", self.go_to_voltage)
+        self.view.sidepanel.hardware_config_from_yaml_button.bind("<Button>", lambda e: self.configure_from_yaml())
         self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
 
     def go_to_voltage(self, event=None) -> None:
         self.view.sidepanel.startButton['state'] = 'disabled'
         self.view.sidepanel.GotoButton['state'] = 'disabled'
-        self.counter_scanner.go_to_v(float(self.view.sidepanel.v_entry.get()))
+        self.view.controller_menu.config(state=tk.DISABLED)
+        self.view.daq_config_button.config(state=tk.DISABLED)
+        self.view.hardware_config_button.config(state=tk.DISABLED)
+        self.view.hardware_config_from_yaml_button.config(state=Tk.DISABLED)
+        self.application_controller.go_to_v(float(self.view.sidepanel.v_entry.get()))
         self.view.sidepanel.startButton['state'] = 'normal'
         self.view.sidepanel.GotoButton['state'] = 'normal'
+        self.view.controller_menu.config(state=tk.NORMAL)
+        self.view.daq_config_button.config(state=tk.NORMAL)
+        self.view.hardware_config_button.config(state=tk.NORMAL)
 
     def start_scan(self, event=None) -> None:
         self.view.sidepanel.startButton['state'] = 'disabled'
         self.view.sidepanel.GotoButton['state'] = 'disabled'
+        self.view.controller_menu.config(state=tk.DISABLED)
+        self.view.daq_config_button.config(state=tk.DISABLED)
+        self.view.hardware_config_button.config(state=tk.DISABLED)
 
         n_sample_size = int(self.view.sidepanel.num_pixels.get())
         sweep_time_entry = float(self.view.sidepanel.sweep_time_entry.get())
@@ -231,7 +255,7 @@ def start_scan(self, event=None) -> None:
         args.append(n_sample_size)
 
         settling_time = sweep_time_entry / n_sample_size
-        self.counter_scanner.wavelength_controller.settling_time_in_seconds = settling_time
+        self.application_controller.wavelength_controller.settling_time_in_seconds = settling_time
 
         self.scan_thread = Thread(target=self.scan_thread_function, args=args)
         self.scan_thread.start()
@@ -246,7 +270,12 @@ def run(self) -> None:
         self.root.mainloop()
 
     def stop_scan(self, event=None) -> None:
-        self.counter_scanner.stop()
+        self.application_controller.stop()
+        self.view.sidepanel.startButton['state'] = 'normal'
+        self.view.sidepanel.GotoButton['state'] = 'normal'
+        self.view.controller_menu.config(state=tk.NORMAL)
+        self.view.daq_config_button.config(state=tk.NORMAL)
+        self.view.hardware_config_button.config(state=tk.NORMAL)
 
     def on_closing(self) -> None:
         try:
@@ -259,21 +288,21 @@ def on_closing(self) -> None:
 
     def scan_thread_function(self, vmin, vmax, step_size, N) -> None:
 
-        self.counter_scanner.set_scan_range(vmin, vmax)
-        self.counter_scanner.step_size = step_size
-        self.counter_scanner.set_num_data_samples_per_batch(N)
+        self.application_controller.set_scan_range(vmin, vmax)
+        self.application_controller.step_size = step_size
+        self.application_controller.set_num_data_samples_per_batch(N)
 
         try:
-            self.counter_scanner.reset()  # clears the data
-            self.counter_scanner.start()  # starts the DAQ
-            self.counter_scanner.set_to_starting_position()  # moves the stage to starting position
+            self.application_controller.reset()  # clears the data
+            self.application_controller.start()  # starts the DAQ
+            self.application_controller.set_to_starting_position()  # moves the stage to starting position
 
-            while self.counter_scanner.still_scanning():
-                self.counter_scanner.scan_v()
-                self.view.scan_view.update(self.counter_scanner)
+            while self.application_controller.still_scanning():
+                self.application_controller.scan_v()
+                self.view.scan_view.update(self.application_controller)
                 self.view.canvas.draw()
 
-            self.counter_scanner.stop()
+            self.application_controller.stop()
 
         except nidaqmx.errors.DaqError as e:
             logger.info(e)
@@ -282,6 +311,9 @@ def scan_thread_function(self, vmin, vmax, step_size, N) -> None:
 
         self.view.sidepanel.startButton['state'] = 'normal'
         self.view.sidepanel.GotoButton['state'] = 'normal'
+        self.view.controller_menu.config(state=tk.NORMAL)
+        self.view.daq_config_button.config(state=tk.NORMAL)
+        self.view.hardware_config_button.config(state=tk.NORMAL)
 
     def save_scan(self, event = None):
         myformats = [('Compressed Numpy MultiArray', '*.npz'), ('Numpy Array (count rate only)', '*.npy'), ('HDF5', '*.h5')]
@@ -292,11 +324,11 @@ def save_scan(self, event = None):
             return # selection was canceled.
 
         data = dict(
-            raw_counts=self.counter_scanner.scanned_raw_counts,
-            count_rate=self.counter_scanner.scanned_count_rate,
-            scan_range=self.counter_scanner.get_completed_scan_range(),
-            step_size=self.counter_scanner.step_size,
-            daq_clock_rate=self.counter_scanner.rate_counter.clock_rate,
+            raw_counts=self.application_controller.scanned_raw_counts,
+            count_rate=self.application_controller.scanned_count_rate,
+            scan_range=self.application_controller.get_completed_scan_range(),
+            step_size=self.application_controller.step_size,
+            daq_clock_rate=self.application_controller.rate_counter.clock_rate,
         )
 
         if file_type == 'npy':
@@ -311,6 +343,133 @@ def save_scan(self, event = None):
                 h5file.create_dataset(key, data=value)
             h5file.close()
 
+    def configure_from_yaml(self) -> None:
+        """
+        This method launches a GUI window to allow the user to select a yaml file to configure the data controller.
+
+        This does not instantiate a new hardware controller class. It only configures the existing one.
+        """
+        filetypes = (
+            ('YAML', '*.yaml'),
+        )
+        afile = tk.filedialog.askopenfile(filetypes=filetypes, defaultextension='.yaml')
+        if afile is None:
+            return  # selection was canceled.
+
+        config = yaml.safe_load(afile)
+        afile.close()
+
+        counter_config = config[CONFIG_FILE_APPLICATION_NAME][CONFIG_FILE_DAQ_DEVICE]
+
+        same_daq_name = self.data_acquisition_model.__class__.__name__ == counter_config['class_name']
+        same_daq_module = self.data_acquisition_model.__class__.__module__ == counter_config['import_path']
+
+        if same_daq_name is False or same_daq_module is False:
+            msg = f"""\nCurrent data acquisition object is not of type found in YAML
+Found in YAML: {counter_config['import_path']}.{counter_config['class_name']}.
+Current data acquistion object: {self.data_acquisition_model.__class__.__module__}.{self.data_acquisition_model.__class__.__name__}
+Configuration not loaded. Please select approprate controller from the pull-down menu
+or check your YAML file to ensure configuration of supported hardware controller.
+"""
+            logger.warning(msg)
+        else:
+            logger.info("load settings from yaml")
+            logger.info(counter_config['configure'])
+            self.data_acquisition_model.configure(counter_config['configure'])
+
+    def _open_config_for_hardware(self, hardware_name: str) -> dict:
+        with importlib.resources.path(CONTROLLER_PATH, SUPPORTED_CONTROLLERS[hardware_name]) as yaml_path:
+            logger.info(f"opening config file: {yaml_path}")
+            with open(yaml_path, 'r') as yaml_file:
+                config = yaml.safe_load(yaml_file)
+
+        return config
+
+    def load_daq_from_config_dict(self, controller_name: str) -> None:
+
+        config = self._open_config_for_hardware(controller_name)
+
+        counter_config = config[CONFIG_FILE_APPLICATION_NAME][CONFIG_FILE_DAQ_DEVICE]
+
+        logger.info("loading from configuration")
+        logger.info(counter_config)
+
+        # Dynamically import the module
+        module = importlib.import_module(counter_config['import_path'])
+
+        # Dynamically instantiate the class
+        cls = getattr(module, counter_config['class_name'])
+        # cls should be instance of QT3ScopeDAQControllerInterface
+        self.data_acquisition_model = cls(logger.level)
+        assert isinstance(self.data_acquisition_model, QT3ScopeNIDAQEdgeCounterController)
+
+        # configure the data acquisition model
+        self.data_acquisition_model.configure(counter_config['configure'])
+        self.view.hardware_config_button.bind("<Button>", lambda e: self.data_acquisition_model.configure_view(self.root))
+        self.animation = None  # reset the animation
+
+    def _open_yaml_config_for_controller(self, controller_name: str) -> dict:
+        with importlib.resources.path(CONTROLLER_PATH, STANDARD_CONTROLLERS[controller_name]['yaml']) as yaml_path:
+            logger.info(f"opening config file: {yaml_path}")
+            with open(yaml_path, 'r') as yaml_file:
+                config = yaml.safe_load(yaml_file)
+
+        return config
+
+    def _load_controller_from_dict(self, config: dict, a_protocol: Protocol) -> Any:
+        """
+        Dynamically imports the module and instantiates the class specified in the config dictionary.
+        Class the class configure method if it exists.
+        """
+        # Dynamically import the module
+        module = importlib.import_module(config['import_path'])
+        logger.debug(f"loading {config['import_path']}")
+
+        # Dynamically instantiate the class
+        cls = getattr(module, config['class_name'])
+        logger.debug(f"instantiating {config['class_name']}")
+
+        controller = cls(logger.level)
+
+        logger.debug(f"asserting {config['class_name']} of proper type {a_protocol}")
+        assert isinstance(controller, a_protocol)
+
+        # configure the controller
+        # all controllers *should* have a configure method
+        logger.debug(f"calling {a_protocol} configure method")
+        controller.configure(config['configure'])
+
+        return controller
+
+    def load_controller_from_name(self, application_controller_name: str) -> None:
+        """
+        Loads the default yaml configuration file for the application controller.
+
+        Should be called during instantiation of this class and should be the callback
+        function for the support controller pull-down menu in the side panel
+        """
+        logger.info(f"loading {application_controller_name}")
+        config = self._open_yaml_config_for_controller(application_controller_name)
+        self._build_controllers_from_config_dict(config, application_controller_name)
+
+    def _build_controllers_from_config_dict(self, config: dict, controller_name: str) -> None:
+
+        # load the position controller from dict
+        pos_config = config[CONFIG_FILE_APPLICATION_NAME][CONFIG_FILE_VOLTAGE_CONTROLLER]
+        voltage_controller = self._load_controller_from_dict(pos_config, VControl)
+
+        # load the data acquisition model from dict
+        daq_config = config[CONFIG_FILE_APPLICATION_NAME][CONFIG_FILE_DAQ_DEVICE]
+        daq_controller = self._load_controller_from_dict(daq_config, datasources.NiDaqDigitalInputRateCounter)
+
+        ControllerClass = STANDARD_CONTROLLERS[controller_name]['application_controller_class']
+        self.application_controller = plescanner.CounterAndScanner(daq_controller, voltage_controller, logger.level)
+
+        # bind buttons to controllers
+        self.view.scan_view.set_rightclick_callback(self.application_controller.scan_image_rightclick_event)
+        self.view.voltage_controller_config_button.bind("<Button>", lambda e: self.application_controller.voltage_controller.configure_view(self.root))
+        self.view.daq_config_button.bind("<Button>", lambda e: self.application_controller.daq_controller.configure_view(self.root))
+
 
 def build_data_scanner() -> None:
     if args.randomtest:
@@ -338,7 +497,7 @@ def build_data_scanner() -> None:
 
 
 def main() -> None:
-    tkapp = MainTkApplication(build_data_scanner())
+    tkapp = MainTkApplication(DEFAULT_DAQ_DEVICE_NAME)
     tkapp.run()
 
 

From 14fa1a93e5ca2cf7ef9da934a988727187819679 Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Wed, 17 Jan 2024 16:26:35 -0800
Subject: [PATCH 17/32] Removed redundant config button. Changed controller to
 plescanner.py

---
 src/qt3utils/applications/qt3ple/main.py  | 30 +++++++++++------------
 src/qt3utils/datagenerators/plescanner.py |  7 ++++++
 2 files changed, 22 insertions(+), 15 deletions(-)

diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index 1523d89a..47df5bab 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -45,7 +45,7 @@
 SUPPORTED_CONTROLLERS = {NIDAQ_DEVICE_NAME: 'nidaq_rate_counter.yaml'
                          }
 STANDARD_CONTROLLERS = {NIDAQ_DEVICE_NAME: {'yaml': 'nidaq_rate_counter.yaml',
-                                                'application_controller_class': VControl}
+                                                'application_controller_class': plescanner.CounterAndScanner}
                         }
 CONFIG_FILE_APPLICATION_NAME = 'QT3PLE'
 CONFIG_FILE_DAQ_DEVICE = 'DAQCounter'
@@ -176,9 +176,9 @@ def __init__(self, root, scan_range) -> None:
         row += 1
         self.daq_config_button = tk.Button(frame, text="Data Acquisition Config")
         self.daq_config_button.grid(row=row, column=0, columnspan=3)
-        row += 1
-        self.hardware_config_button = tk.Button(frame, text="Configure Hardware")
-        self.hardware_config_button.grid(row=row, column=0, columnspan=3)
+        #row += 1
+        #self.hardware_config_button = tk.Button(frame, text="Configure Hardware")
+        #self.hardware_config_button.grid(row=row, column=0, columnspan=3)
         row += 1
         self.hardware_config_from_yaml_button = tk.Button(frame, text="Load YAML Config")
         self.hardware_config_from_yaml_button.grid(row=row, column=0, columnspan=3)
@@ -201,9 +201,9 @@ def __init__(self, main_frame, scan_range=[-3, 5]) -> None:
 
         self.canvas.draw()
 
-    @property
-    def hardware_config_button(self) -> tk.Button:
-        return self.sidepanel.hardware_config_button
+    #@property
+    #def hardware_config_button(self) -> tk.Button:
+    #    return self.sidepanel.hardware_config_button
 
 
 class MainTkApplication():
@@ -222,28 +222,28 @@ def __init__(self, controller_name) -> None:
         self.view.sidepanel.stopButton.bind("<Button>", self.stop_scan)
         self.view.sidepanel.GotoButton.bind("<Button>", self.go_to_voltage)
         self.view.sidepanel.hardware_config_from_yaml_button.bind("<Button>", lambda e: self.configure_from_yaml())
-        self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
+        self.root.protocol("WM_DELETE_WINDOWwait_visibility()", self.on_closing)
 
     def go_to_voltage(self, event=None) -> None:
         self.view.sidepanel.startButton['state'] = 'disabled'
         self.view.sidepanel.GotoButton['state'] = 'disabled'
         self.view.controller_menu.config(state=tk.DISABLED)
         self.view.daq_config_button.config(state=tk.DISABLED)
-        self.view.hardware_config_button.config(state=tk.DISABLED)
-        self.view.hardware_config_from_yaml_button.config(state=Tk.DISABLED)
+        #self.view.hardware_config_button.config(state=tk.DISABLED)
+        #self.view.hardware_config_from_yaml_button.config(state=Tk.DISABLED)
         self.application_controller.go_to_v(float(self.view.sidepanel.v_entry.get()))
         self.view.sidepanel.startButton['state'] = 'normal'
         self.view.sidepanel.GotoButton['state'] = 'normal'
         self.view.controller_menu.config(state=tk.NORMAL)
         self.view.daq_config_button.config(state=tk.NORMAL)
-        self.view.hardware_config_button.config(state=tk.NORMAL)
+        #self.view.hardware_config_button.config(state=tk.NORMAL)
 
     def start_scan(self, event=None) -> None:
         self.view.sidepanel.startButton['state'] = 'disabled'
         self.view.sidepanel.GotoButton['state'] = 'disabled'
         self.view.controller_menu.config(state=tk.DISABLED)
         self.view.daq_config_button.config(state=tk.DISABLED)
-        self.view.hardware_config_button.config(state=tk.DISABLED)
+        #self.view.hardware_config_button.config(state=tk.DISABLED)
 
         n_sample_size = int(self.view.sidepanel.num_pixels.get())
         sweep_time_entry = float(self.view.sidepanel.sweep_time_entry.get())
@@ -275,7 +275,7 @@ def stop_scan(self, event=None) -> None:
         self.view.sidepanel.GotoButton['state'] = 'normal'
         self.view.controller_menu.config(state=tk.NORMAL)
         self.view.daq_config_button.config(state=tk.NORMAL)
-        self.view.hardware_config_button.config(state=tk.NORMAL)
+        #self.view.hardware_config_button.config(state=tk.NORMAL)
 
     def on_closing(self) -> None:
         try:
@@ -313,7 +313,7 @@ def scan_thread_function(self, vmin, vmax, step_size, N) -> None:
         self.view.sidepanel.GotoButton['state'] = 'normal'
         self.view.controller_menu.config(state=tk.NORMAL)
         self.view.daq_config_button.config(state=tk.NORMAL)
-        self.view.hardware_config_button.config(state=tk.NORMAL)
+        #self.view.hardware_config_button.config(state=tk.NORMAL)
 
     def save_scan(self, event = None):
         myformats = [('Compressed Numpy MultiArray', '*.npz'), ('Numpy Array (count rate only)', '*.npy'), ('HDF5', '*.h5')]
@@ -405,7 +405,7 @@ def load_daq_from_config_dict(self, controller_name: str) -> None:
 
         # configure the data acquisition model
         self.data_acquisition_model.configure(counter_config['configure'])
-        self.view.hardware_config_button.bind("<Button>", lambda e: self.data_acquisition_model.configure_view(self.root))
+        #self.view.hardware_config_button.bind("<Button>", lambda e: self.data_acquisition_model.configure_view(self.root))
         self.animation = None  # reset the animation
 
     def _open_yaml_config_for_controller(self, controller_name: str) -> dict:
diff --git a/src/qt3utils/datagenerators/plescanner.py b/src/qt3utils/datagenerators/plescanner.py
index ae3ab387..71889372 100644
--- a/src/qt3utils/datagenerators/plescanner.py
+++ b/src/qt3utils/datagenerators/plescanner.py
@@ -1,3 +1,4 @@
+import tkinter as tk
 import numpy as np
 import time
 import logging
@@ -133,6 +134,12 @@ def reset(self) -> None:
         self.scanned_raw_counts = []
         self.scanned_count_rate = []
 
+    def configure_view(self, gui_root: tk.Toplevel) -> None:
+        """
+        This method launches a GUI window to configure the controller.
+        """
+        pass
+
     @property
     def step_size(self):
         return self._step_size

From f29c60a87556b10da4f4165b388000326e922236 Mon Sep 17 00:00:00 2001
From: Fu Lab NV PC <laneb88@uw.edu>
Date: Wed, 17 Jan 2024 19:42:13 -0800
Subject: [PATCH 18/32] Added changes to make yaml configuration functional.
 Removed extraneous functions.

---
 src/qt3utils/applications/qt3ple/main.py | 89 ++++++------------------
 src/qt3utils/nidaq/customcontrollers.py  | 11 +++
 2 files changed, 34 insertions(+), 66 deletions(-)

diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index 47df5bab..d3c386a0 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -16,7 +16,6 @@
 from qt3utils.nidaq.customcontrollers import VControl
 from qt3utils.datagenerators import plescanner
 from qt3utils.applications.controllers.nidaqedgecounter import QT3ScopeNIDAQEdgeCounterController
-import qt3utils.datagenerators as datasources
 
 matplotlib.use('Agg')
 
@@ -162,10 +161,10 @@ def __init__(self, root, scan_range) -> None:
         self.controller_option = tk.StringVar(frame)
         self.controller_option.set(DEFAULT_DAQ_DEVICE_NAME)  # setting the default value
 
-        #self.controller_menu = tk.OptionMenu(frame,
-        #                                     self.controller_option,
-        #                                     *STANDARD_CONTROLLERS.keys(),
-        #                                     command=root.load_daq_from_config_dict)
+        self.controller_menu = tk.OptionMenu(frame,
+                                             self.controller_option,
+                                             *STANDARD_CONTROLLERS.keys(),
+                                             command=root.load_daq_from_config_dict)
         self.controller_menu = tk.OptionMenu(frame,
                                              self.controller_option,
                                              *STANDARD_CONTROLLERS.keys(),
@@ -173,12 +172,6 @@ def __init__(self, root, scan_range) -> None:
 
         self.controller_menu.grid(row=row, column=0, columnspan=3)
 
-        row += 1
-        self.daq_config_button = tk.Button(frame, text="Data Acquisition Config")
-        self.daq_config_button.grid(row=row, column=0, columnspan=3)
-        #row += 1
-        #self.hardware_config_button = tk.Button(frame, text="Configure Hardware")
-        #self.hardware_config_button.grid(row=row, column=0, columnspan=3)
         row += 1
         self.hardware_config_from_yaml_button = tk.Button(frame, text="Load YAML Config")
         self.hardware_config_from_yaml_button.grid(row=row, column=0, columnspan=3)
@@ -227,23 +220,19 @@ def __init__(self, controller_name) -> None:
     def go_to_voltage(self, event=None) -> None:
         self.view.sidepanel.startButton['state'] = 'disabled'
         self.view.sidepanel.GotoButton['state'] = 'disabled'
-        self.view.controller_menu.config(state=tk.DISABLED)
-        self.view.daq_config_button.config(state=tk.DISABLED)
-        #self.view.hardware_config_button.config(state=tk.DISABLED)
-        #self.view.hardware_config_from_yaml_button.config(state=Tk.DISABLED)
+        self.view.sidepanel.controller_menu.config(state=tk.DISABLED)
+        self.view.sidepanel.saveScanButton.config(state=tk.DISABLED)
         self.application_controller.go_to_v(float(self.view.sidepanel.v_entry.get()))
         self.view.sidepanel.startButton['state'] = 'normal'
         self.view.sidepanel.GotoButton['state'] = 'normal'
-        self.view.controller_menu.config(state=tk.NORMAL)
-        self.view.daq_config_button.config(state=tk.NORMAL)
-        #self.view.hardware_config_button.config(state=tk.NORMAL)
+        self.view.sidepanel.controller_menu.config(state=tk.NORMAL)
+        self.view.sidepanel.saveScanButton.config(state=tk.NORMAL)
 
     def start_scan(self, event=None) -> None:
         self.view.sidepanel.startButton['state'] = 'disabled'
         self.view.sidepanel.GotoButton['state'] = 'disabled'
-        self.view.controller_menu.config(state=tk.DISABLED)
-        self.view.daq_config_button.config(state=tk.DISABLED)
-        #self.view.hardware_config_button.config(state=tk.DISABLED)
+        self.view.sidepanel.controller_menu.config(state=tk.DISABLED)
+        self.view.sidepanel.saveScanButton.config(state=tk.DISABLED)
 
         n_sample_size = int(self.view.sidepanel.num_pixels.get())
         sweep_time_entry = float(self.view.sidepanel.sweep_time_entry.get())
@@ -260,10 +249,6 @@ def start_scan(self, event=None) -> None:
         self.scan_thread = Thread(target=self.scan_thread_function, args=args)
         self.scan_thread.start()
 
-        # with nidaqmx.Task() as task:
-        #    task.ao_channels.add_ao_voltage_chan("Dev1/ai0")
-        #    task.write(xmin)
-
     def run(self) -> None:
         self.root.title("QT3PLE: Run PLE scan")
         self.root.deiconify()
@@ -273,10 +258,8 @@ def stop_scan(self, event=None) -> None:
         self.application_controller.stop()
         self.view.sidepanel.startButton['state'] = 'normal'
         self.view.sidepanel.GotoButton['state'] = 'normal'
-        self.view.controller_menu.config(state=tk.NORMAL)
-        self.view.daq_config_button.config(state=tk.NORMAL)
-        #self.view.hardware_config_button.config(state=tk.NORMAL)
-
+        self.view.sidepanel.controller_menu.config(state=tk.NORMAL)
+        self.view.sidepanel.saveScanButton.config(state=tk.NORMAL)
     def on_closing(self) -> None:
         try:
             self.stop_scan()
@@ -311,9 +294,8 @@ def scan_thread_function(self, vmin, vmax, step_size, N) -> None:
 
         self.view.sidepanel.startButton['state'] = 'normal'
         self.view.sidepanel.GotoButton['state'] = 'normal'
-        self.view.controller_menu.config(state=tk.NORMAL)
-        self.view.daq_config_button.config(state=tk.NORMAL)
-        #self.view.hardware_config_button.config(state=tk.NORMAL)
+        self.view.sidepanel.controller_menu.config(state=tk.NORMAL)
+        self.view.sidepanel.saveScanButton.config(state=tk.NORMAL)
 
     def save_scan(self, event = None):
         myformats = [('Compressed Numpy MultiArray', '*.npz'), ('Numpy Array (count rate only)', '*.npy'), ('HDF5', '*.h5')]
@@ -342,6 +324,7 @@ def save_scan(self, event = None):
             for key, value in data.items():
                 h5file.create_dataset(key, data=value)
             h5file.close()
+        self.view.sidepanel.saveScanButton.config(state=tk.NORMAL)
 
     def configure_from_yaml(self) -> None:
         """
@@ -368,7 +351,7 @@ def configure_from_yaml(self) -> None:
             msg = f"""\nCurrent data acquisition object is not of type found in YAML
 Found in YAML: {counter_config['import_path']}.{counter_config['class_name']}.
 Current data acquistion object: {self.data_acquisition_model.__class__.__module__}.{self.data_acquisition_model.__class__.__name__}
-Configuration not loaded. Please select approprate controller from the pull-down menu
+Configuration not loaded. Please select appropriate controller from the pull-down menu
 or check your YAML file to ensure configuration of supported hardware controller.
 """
             logger.warning(msg)
@@ -377,6 +360,7 @@ def configure_from_yaml(self) -> None:
             logger.info(counter_config['configure'])
             self.data_acquisition_model.configure(counter_config['configure'])
 
+
     def _open_config_for_hardware(self, hardware_name: str) -> dict:
         with importlib.resources.path(CONTROLLER_PATH, SUPPORTED_CONTROLLERS[hardware_name]) as yaml_path:
             logger.info(f"opening config file: {yaml_path}")
@@ -399,7 +383,7 @@ def load_daq_from_config_dict(self, controller_name: str) -> None:
 
         # Dynamically instantiate the class
         cls = getattr(module, counter_config['class_name'])
-        # cls should be instance of QT3ScopeDAQControllerInterface
+        # cls should be instance of QT3ScopeNIDAQEdgeCounterController
         self.data_acquisition_model = cls(logger.level)
         assert isinstance(self.data_acquisition_model, QT3ScopeNIDAQEdgeCounterController)
 
@@ -460,42 +444,15 @@ def _build_controllers_from_config_dict(self, config: dict, controller_name: str
 
         # load the data acquisition model from dict
         daq_config = config[CONFIG_FILE_APPLICATION_NAME][CONFIG_FILE_DAQ_DEVICE]
-        daq_controller = self._load_controller_from_dict(daq_config, datasources.NiDaqDigitalInputRateCounter)
+        daq_controller = self._load_controller_from_dict(daq_config, QT3ScopeNIDAQEdgeCounterController)
 
         ControllerClass = STANDARD_CONTROLLERS[controller_name]['application_controller_class']
-        self.application_controller = plescanner.CounterAndScanner(daq_controller, voltage_controller, logger.level)
+        self.application_controller = plescanner.CounterAndScanner(daq_controller.data_generator, voltage_controller)
 
         # bind buttons to controllers
-        self.view.scan_view.set_rightclick_callback(self.application_controller.scan_image_rightclick_event)
-        self.view.voltage_controller_config_button.bind("<Button>", lambda e: self.application_controller.voltage_controller.configure_view(self.root))
-        self.view.daq_config_button.bind("<Button>", lambda e: self.application_controller.daq_controller.configure_view(self.root))
-
-
-def build_data_scanner() -> None:
-    if args.randomtest:
-        data_acq = datasources.RandomRateCounter(simulate_single_light_source=True,
-                                                 num_data_samples_per_batch=args.num_data_samples_per_batch)
-    else:
-        data_acq = datasources.NiDaqDigitalInputRateCounter(args.daq_name,
-                                                            args.signal_terminal,
-                                                            args.clock_rate,
-                                                            args.num_data_samples_per_batch,
-                                                            args.clock_terminal,
-                                                            args.rwtimeout,
-                                                            args.signal_counter)
-
-    voltage_controller = VControl(device_name=args.daq_name,
-                                  write_channel=args.wavelength_write_channel,
-                                  read_channel=args.wavelength_read_channel,
-                                  min_position=args.wavelength_min_position,
-                                  max_position=args.wavelength_max_position,
-                                  scale_nm_per_volt=args.wavelength_scale_nm_per_volt)
-
-    scanner = plescanner.CounterAndScanner(data_acq, voltage_controller)
-
-    return scanner
-
-
+        #self.view.scan_view.set_rightclick_callback(self.application_controller.scan_image_rightclick_event)
+        #self.view.voltage_controller_config_button.bind("<Button>", lambda e: self.application_controller.wavelength_controller.configure_view(self.root))
+        #self.view.daq_config_button.bind("<Button>", lambda e: self.application_controller.rate_counter.configure_view(self.root))
 def main() -> None:
     tkapp = MainTkApplication(DEFAULT_DAQ_DEVICE_NAME)
     tkapp.run()
diff --git a/src/qt3utils/nidaq/customcontrollers.py b/src/qt3utils/nidaq/customcontrollers.py
index a0440590..73e0b25a 100644
--- a/src/qt3utils/nidaq/customcontrollers.py
+++ b/src/qt3utils/nidaq/customcontrollers.py
@@ -59,6 +59,17 @@ def get_current_voltage(self) -> float:
 
         return output
 
+    def configure(self, config_dict: dict) -> None:
+        """
+        This method is used to configure the data controller.
+        """
+        self.device_name = config_dict.get('daq_name', self.device_name)
+        self.write_channel = config_dict.get('write_channels', self.write_channel)
+        self.read_channel = config_dict.get('read_channels', self.read_channel)
+        self.scale_nm_per_volt = config_dict.get('scale_nm_per_volt', self.scale_nm_per_volt)
+        self.minimum_allowed_position = config_dict.get('min_position', self.minimum_allowed_position)
+        self.maximum_allowed_position = config_dict.get('max_position', self.maximum_allowed_position)
+
     def check_allowed_position(self, v: float = None) -> None:
         if v is not None: self._validate_value(v)
 

From fe4bd63d815f5def2f27cce88ee25a0ed429cca6 Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Sun, 4 Feb 2024 11:50:10 -0800
Subject: [PATCH 19/32] Added wavemeter controller.

---
 .../controllers/wavemeter_controller.py       | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 src/qt3utils/applications/controllers/wavemeter_controller.py

diff --git a/src/qt3utils/applications/controllers/wavemeter_controller.py b/src/qt3utils/applications/controllers/wavemeter_controller.py
new file mode 100644
index 00000000..0ff31b2a
--- /dev/null
+++ b/src/qt3utils/applications/controllers/wavemeter_controller.py
@@ -0,0 +1,20 @@
+import ctypes
+
+class WavemeterController
+    def __init__(self, dll_path):
+        self._mydll = ctypes.cdll.LoadLibrary(dll_path)
+        self._mydll.CLGetLambdaReading.restype = ctypes.c_double
+        self._dh = self._mydll.CLOpenUSBSerialDevice(4)
+        if self._dh == -1:
+            raise Exception("Failed to connect to wave meter.")
+
+    def read_wavemeter(self):
+        return self._mydll.CLGetLambdaReading(self._dh)
+
+    def close_wavemeter(self) -> None:
+        ending = self._mydll.CLCloseDevice(self._dh)
+        if ending == -1:
+            raise Exception("Failed to properly close connection to wave meter.")
+        else:
+            device_handle=None
+

From c81d809a00dc00203bb46548a00fe4441f061de7 Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Wed, 7 Feb 2024 16:04:00 -0800
Subject: [PATCH 20/32] Added WavemeterAndScanner for experiment to interface
 with hardware.

---
 .../controllers/nidaq_rate_counter.yaml       |  57 ++++++--
 .../controllers/wavemeter_controller.py       |  18 ++-
 src/qt3utils/applications/qt3ple/main.py      |   1 +
 src/qt3utils/datagenerators/plescanner.py     | 125 +++++++++++++-----
 4 files changed, 155 insertions(+), 46 deletions(-)

diff --git a/src/qt3utils/applications/controllers/nidaq_rate_counter.yaml b/src/qt3utils/applications/controllers/nidaq_rate_counter.yaml
index 6baefa7a..03977683 100644
--- a/src/qt3utils/applications/controllers/nidaq_rate_counter.yaml
+++ b/src/qt3utils/applications/controllers/nidaq_rate_counter.yaml
@@ -1,4 +1,5 @@
 QT3PLE:
+
   DAQCounter:
     import_path : qt3utils.applications.controllers.nidaqedgecounter
     class_name  : QT3ScopeNIDAQEdgeCounterController
@@ -10,6 +11,51 @@ QT3PLE:
       num_data_samples_per_batch : 1000
       read_write_timeout : 10  # timeout in seconds for read/write operations
       signal_counter : ctr2  # NI DAQ counter to use for counting the input signal, e.g. ctr0, ctr1, ctr2, or ctr3
+
+  DAQReader1:
+    import_path: qt3utils.applications.controllers.nidaqedgecounter
+    class_name: QT3ScopeNIDAQEdgeCounterController
+    configure:
+      daq_name: Dev1  # NI DAQ Device Name
+      signal_terminal: PFI0  # NI DAQ terminal connected to input digital TTL signal
+      clock_terminal:    # Specifies the digital input terminal to the NI DAQ to use for a clock. If left blank, interprets as None or NULL
+      clock_rate: 100000  # NI DAQ clock rate in Hz
+      num_data_samples_per_batch: 1000
+      read_write_timeout: 10  # timeout in seconds for read/write operations
+      signal_counter: ctr2  # NI DAQ counter to use for counting the input signal, e.g. ctr0, ctr1, ctr2, or ctr3
+
+  DAQReader2:
+    import_path: qt3utils.applications.controllers.nidaqedgecounter
+    class_name: QT3ScopeNIDAQEdgeCounterController
+    configure:
+      daq_name: Dev1  # NI DAQ Device Name
+      signal_terminal: PFI0  # NI DAQ terminal connected to input digital TTL signal
+      clock_terminal:    # Specifies the digital input terminal to the NI DAQ to use for a clock. If left blank, interprets as None or NULL
+      clock_rate: 100000  # NI DAQ clock rate in Hz
+      num_data_samples_per_batch: 1000
+      read_write_timeout: 10  # timeout in seconds for read/write operations
+      signal_counter: ctr2  # NI DAQ counter to use for counting the input signal, e.g. ctr0, ctr1, ctr2, or ctr3
+
+
+  VoltageController:
+    import_path : qt3utils.nidaq.customcontrollers
+    class_name  : VControl
+    configure :
+      daq_name : Dev1  # NI DAQ Device Name
+      write_channels : ao0  # NI DAQ analog output channels to use for writing position
+      read_channels : ai0  # NI DAQ analog input channels to use for reading position
+      min_position: -10  # conversion factor from volts to microns, can also supply a list [8,8,8] or [6,4.2,5]
+      max_position: 10  # the voltage value that defines the position 0,0,0, can also supply a list [0,0,0] or [5,5,5]
+      scale_nm_per_volt: 1  # microns
+
+  WavemeterController:
+    import_path : qt3utils.applications.controllers.wavemeter_controller
+    class_name  : WavemeterController
+    configure :
+      dll_path : C:\\\\Users\\\\Fulab\\\\Downloads\\\\00392-2-06-A_CustomerCD621\\\\00392-2-06-A_Customer CD 621\\\\Programming Interface\\\\x64\\\\CLDevIFace.dll\
+
+
+
 # notes
 
 # clock_rate:
@@ -24,14 +70,3 @@ QT3PLE:
 #   Specifies the digital input terminal to the NI DAQ to use for a clock.
 #   If None, the internal NI DAQ clock is used. Otherwise, a string value
 #   specifies the terminal to use for the clock.
-
-  VoltageController:
-    import_path : qt3utils.nidaq.customcontrollers
-    class_name  : VControl
-    configure :
-      daq_name : Dev1  # NI DAQ Device Name
-      write_channels : ao0  # NI DAQ analog output channels to use for writing position
-      read_channels : ai0  # NI DAQ analog input channels to use for reading position
-      min_position: -10  # conversion factor from volts to microns, can also supply a list [8,8,8] or [6,4.2,5]
-      max_position: 10  # the voltage value that defines the position 0,0,0, can also supply a list [0,0,0] or [5,5,5]
-      scale_nm_per_volt: 1  # microns
\ No newline at end of file
diff --git a/src/qt3utils/applications/controllers/wavemeter_controller.py b/src/qt3utils/applications/controllers/wavemeter_controller.py
index 0ff31b2a..1e57cff8 100644
--- a/src/qt3utils/applications/controllers/wavemeter_controller.py
+++ b/src/qt3utils/applications/controllers/wavemeter_controller.py
@@ -1,7 +1,13 @@
 import ctypes
 
 class WavemeterController
-    def __init__(self, dll_path):
+    def __init__(self, dll_path=""):
+        if not dll_path == "":
+            self.init_dll()
+        self.dll_path = dll_path
+        self.last_config_dict = {}
+
+    def init_dll(self, dll_path):
         self._mydll = ctypes.cdll.LoadLibrary(dll_path)
         self._mydll.CLGetLambdaReading.restype = ctypes.c_double
         self._dh = self._mydll.CLOpenUSBSerialDevice(4)
@@ -18,3 +24,13 @@ def close_wavemeter(self) -> None:
         else:
             device_handle=None
 
+    def configure(self, config_dict: dict) -> None:
+        """
+        This method is used to configure the data controller.
+        """
+        self.logger.debug("calling configure on the wave meter controller")
+        self.last_config_dict.update(config_dict)
+
+        self.dll_path = config_dict.get('daq_name', self.data_generator.daq_name)
+        self.init_dll(self.dll_path)
+
diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index d3c386a0..d4c47e1b 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -47,6 +47,7 @@
                                                 'application_controller_class': plescanner.CounterAndScanner}
                         }
 CONFIG_FILE_APPLICATION_NAME = 'QT3PLE'
+CONFIG_FILE_EXPERIMENT = 'Experiment'
 CONFIG_FILE_DAQ_DEVICE = 'DAQCounter'
 CONFIG_FILE_VOLTAGE_CONTROLLER = 'VoltageController'
 CONFIG_FILE_DAQ_CONTROLLER = 'DAQController'
diff --git a/src/qt3utils/datagenerators/plescanner.py b/src/qt3utils/datagenerators/plescanner.py
index 71889372..19c87d76 100644
--- a/src/qt3utils/datagenerators/plescanner.py
+++ b/src/qt3utils/datagenerators/plescanner.py
@@ -5,10 +5,9 @@
 
 logger = logging.getLogger(__name__)
 
+class PleScanner:
 
-class CounterAndScanner:
-    def __init__(self, rate_counter, wavelength_controller) -> None:
-
+    def __init__(self, wavelength_controller):
         self.running = False
         self.current_t = 0
         self.vmin = float(wavelength_controller.minimum_allowed_position)
@@ -16,21 +15,14 @@ def __init__(self, rate_counter, wavelength_controller) -> None:
         self.tmax = 100
         self._step_size = 0.5
         self.raster_line_pause = 0.150  # wait 150ms for the voltage to settle before a line scan
-
-        self.scanned_raw_counts = []
-        self.scanned_count_rate = []
-
         self.wavelength_controller = wavelength_controller
-        self.rate_counter = rate_counter
         self.num_daq_batches = 1  # could change to 10 if want 10x more samples for each position
 
     def stop(self) -> None:
-        self.rate_counter.stop()
         self.running = False
 
     def start(self) -> None:
         self.running = True
-        self.rate_counter.start()
 
     def set_to_starting_position(self) -> None:
         self.current_v = self.vmin
@@ -38,18 +30,7 @@ def set_to_starting_position(self) -> None:
             self.wavelength_controller.go_to_voltage(v=self.vmin)
 
     def close(self) -> None:
-        self.rate_counter.close()
-
-    def set_num_data_samples_per_batch(self, N) -> None:
-        self.rate_counter.num_data_samples_per_batch = N
-
-    def sample_counts(self) -> np.ndarray:
-        return self.rate_counter.sample_counts(self.num_daq_batches)
-
-    def sample_count_rate(self, data_counts=None) -> np.floating:
-        if data_counts is None:
-            data_counts = self.sample_counts()
-        return self.rate_counter.sample_count_rate(data_counts)
+        pass
 
     def set_scan_range(self, vmin, vmax) -> None:
         if self.wavelength_controller:
@@ -97,6 +78,58 @@ def go_to_v(self, desired_voltage) -> None:
             except ValueError as e:
                 logger.info(f'out of range\n\n{e}')
 
+    def scan_v(self) -> None:
+        pass
+
+    def scan_axis(self, axis, min, max, step_size) -> list:
+        pass
+
+    def reset(self) -> None:
+        pass
+
+    def configure_view(self, gui_root: tk.Toplevel) -> None:
+        """
+        This method launches a GUI window to configure the controller.
+        """
+        pass
+
+    @property
+    def step_size(self):
+        return self._step_size
+    @step_size.setter
+    def step_size(self, val):
+        self._step_size = val
+
+class CounterAndScanner(PleScanner):
+    def __init__(self, rate_counter, wavelength_controller) -> None:
+        super(CounterAndScanner, self).__init__(wavelength_controller)
+        self.scanned_raw_counts = []
+        self.scanned_count_rate = []
+        self.rate_counter = rate_counter
+
+    def stop(self) -> None:
+        self.rate_counter.stop()
+        self.running = False
+
+    def start(self) -> None:
+        self.running = True
+        self.rate_counter.start()
+
+
+    def close(self) -> None:
+        self.rate_counter.close()
+
+    def set_num_data_samples_per_batch(self, N) -> None:
+        self.rate_counter.num_data_samples_per_batch = N
+
+    def sample_counts(self) -> np.ndarray:
+        return self.rate_counter.sample_counts(self.num_daq_batches)
+
+    def sample_count_rate(self, data_counts=None) -> np.floating:
+        if data_counts is None:
+            data_counts = self.sample_counts()
+        return self.rate_counter.sample_count_rate(data_counts)
+
     def scan_v(self) -> None:
         """
         Scans the wavelengths from vmin to vmax in steps of step_size.
@@ -110,10 +143,8 @@ def scan_v(self) -> None:
 
     def scan_axis(self, axis, min, max, step_size) -> list:
         """
-        Moves the stage along the specified axis from min to max in steps of step_size.
+        Moves the voltage from min to max in steps of step_size.
         Returns a list of raw counts from the scan in the shape
-        [[[counts, clock_samples]], [[counts, clock_samples]], ...] where each [[counts, clock_samples]] is the
-        result of a single call to sample_counts at each scan position along the axis.
         """
         raw_counts = []
         self.wavelength_controller.go_to_voltage(**{axis: min})
@@ -134,18 +165,44 @@ def reset(self) -> None:
         self.scanned_raw_counts = []
         self.scanned_count_rate = []
 
-    def configure_view(self, gui_root: tk.Toplevel) -> None:
+
+
+class WavemeterAndScanner(CounterAndScanner):
+    def __init__(self, wm_reader, wavelength_controller):
+        super(WavemeterAndScanner, self).__init__(wavelength_controller)
+        self.wm_reader = wm_reader
+        self.scanned_raw_counts = []
+        self.scanned_wm = []
+
+    def scan_v(self) -> None:
         """
-        This method launches a GUI window to configure the controller.
+        Scans the wavelengths from vmin to vmax in steps of step_size.
         """
-        pass
+        _wm_scan = self.scan_axis('v', self.vmin, self.vmax, self._step_size)
+        self.scanned_wm.append(_wm_scan)
+        self.current_t = self.current_t + 1
+
+    def read_wavemeter(self):
+        self.wavelength_controller.read_wavemeter()
+
+    def scan_axis(self, axis, min, max, step_size) -> list:
+        """
+        Moves the voltage from min to max in steps of step_size.
+        Returns a list of readings from the wave meter for each scan
+        """
+        wm_scan = []
+        self.wavelength_controller.go_to_voltage(**{axis: min})
+        time.sleep(self.raster_line_pause)
+        for val in np.arange(min, max, step_size):
+            if self.wavelength_controller:
+                logger.info(f'go to voltage {axis}: {val:.2f}')
+                self.wavelength_controller.go_to_voltage(**{axis: val})
+            _wm_reading = self.read_wavemeter()
+            wm_scan.append(_wm_reading)
+            if self.wavelength_controller:
+                logger.info(f'current voltage: {self.wavelength_controller.get_current_voltage()}')
+        return wm_scan
 
-    @property
-    def step_size(self):
-        return self._step_size
-    @step_size.setter
-    def step_size(self, val):
-        self._step_size = val
 
 
 

From c48cbecfe97b488ea608e0c9d9b94e85d02a1152 Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Thu, 8 Feb 2024 00:49:11 -0800
Subject: [PATCH 21/32] Integrated way to switch between PLE hardware from Yaml
 file only

---
 .../controllers/nidaq_rate_counter.yaml       |  43 ++--
 .../controllers/nidaq_wm_ple.yaml             |  53 +++++
 .../controllers/wavemeter_controller.py       |   8 +-
 src/qt3utils/applications/qt3ple/main.py      | 185 ++++++------------
 src/qt3utils/datagenerators/plescanner.py     |  28 ++-
 src/qt3utils/nidaq/customcontrollers.py       |   2 +-
 6 files changed, 149 insertions(+), 170 deletions(-)
 create mode 100644 src/qt3utils/applications/controllers/nidaq_wm_ple.yaml

diff --git a/src/qt3utils/applications/controllers/nidaq_rate_counter.yaml b/src/qt3utils/applications/controllers/nidaq_rate_counter.yaml
index 03977683..2e151ffe 100644
--- a/src/qt3utils/applications/controllers/nidaq_rate_counter.yaml
+++ b/src/qt3utils/applications/controllers/nidaq_rate_counter.yaml
@@ -1,4 +1,15 @@
 QT3PLE:
+  ApplicationController:
+    import_path : qt3utils.datagenerators.plescanner
+    class_name : CounterAndScanner
+    configure :
+      controllers:
+        daq_writers:
+          daq_writer : VoltageController
+      readers :
+        daq_readers:
+          daq_reader : DAQCounter
+        wm_readers:
 
   DAQCounter:
     import_path : qt3utils.applications.controllers.nidaqedgecounter
@@ -12,31 +23,6 @@ QT3PLE:
       read_write_timeout : 10  # timeout in seconds for read/write operations
       signal_counter : ctr2  # NI DAQ counter to use for counting the input signal, e.g. ctr0, ctr1, ctr2, or ctr3
 
-  DAQReader1:
-    import_path: qt3utils.applications.controllers.nidaqedgecounter
-    class_name: QT3ScopeNIDAQEdgeCounterController
-    configure:
-      daq_name: Dev1  # NI DAQ Device Name
-      signal_terminal: PFI0  # NI DAQ terminal connected to input digital TTL signal
-      clock_terminal:    # Specifies the digital input terminal to the NI DAQ to use for a clock. If left blank, interprets as None or NULL
-      clock_rate: 100000  # NI DAQ clock rate in Hz
-      num_data_samples_per_batch: 1000
-      read_write_timeout: 10  # timeout in seconds for read/write operations
-      signal_counter: ctr2  # NI DAQ counter to use for counting the input signal, e.g. ctr0, ctr1, ctr2, or ctr3
-
-  DAQReader2:
-    import_path: qt3utils.applications.controllers.nidaqedgecounter
-    class_name: QT3ScopeNIDAQEdgeCounterController
-    configure:
-      daq_name: Dev1  # NI DAQ Device Name
-      signal_terminal: PFI0  # NI DAQ terminal connected to input digital TTL signal
-      clock_terminal:    # Specifies the digital input terminal to the NI DAQ to use for a clock. If left blank, interprets as None or NULL
-      clock_rate: 100000  # NI DAQ clock rate in Hz
-      num_data_samples_per_batch: 1000
-      read_write_timeout: 10  # timeout in seconds for read/write operations
-      signal_counter: ctr2  # NI DAQ counter to use for counting the input signal, e.g. ctr0, ctr1, ctr2, or ctr3
-
-
   VoltageController:
     import_path : qt3utils.nidaq.customcontrollers
     class_name  : VControl
@@ -48,13 +34,6 @@ QT3PLE:
       max_position: 10  # the voltage value that defines the position 0,0,0, can also supply a list [0,0,0] or [5,5,5]
       scale_nm_per_volt: 1  # microns
 
-  WavemeterController:
-    import_path : qt3utils.applications.controllers.wavemeter_controller
-    class_name  : WavemeterController
-    configure :
-      dll_path : C:\\\\Users\\\\Fulab\\\\Downloads\\\\00392-2-06-A_CustomerCD621\\\\00392-2-06-A_Customer CD 621\\\\Programming Interface\\\\x64\\\\CLDevIFace.dll\
-
-
 
 # notes
 
diff --git a/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml b/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
new file mode 100644
index 00000000..d70126cb
--- /dev/null
+++ b/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
@@ -0,0 +1,53 @@
+QT3PLE:
+  ApplicationController:
+    import_path : qt3utils.datagenerators.plescanner
+    class_name : WavemeterAndScanner
+    configure :
+      controllers:
+        daq_writers:
+          daq_writer : VoltageController
+      readers :
+        daq_readers:
+          daq_reader : DAQReader
+          daq_reader2 : DAQReader2
+        wm_readers:
+          wm_reader : WavemeterController
+
+  DAQReader:
+    import_path : qt3utils.nidaq.customcontrollers
+    class_name  : VControl
+    configure :
+      daq_name : Silicon_DAQ  # NI DAQ Device Name
+      write_channels : ao3 # NI DAQ analog output channels to use for writing position
+      read_channels : ai3  # NI DAQ analog input channels to use for reading position
+      min_position: -10  # conversion factor from volts to microns, can also supply a list [8,8,8] or [6,4.2,5]
+      max_position: 10  # the voltage value that defines the position 0,0,0, can also supply a list [0,0,0] or [5,5,5]
+      scale_nm_per_volt: 1  # microns
+
+  DAQReader2:
+    import_path : qt3utils.nidaq.customcontrollers
+    class_name  : VControl
+    configure :
+      daq_name : Silicon_DAQ # NI DAQ Device Name
+      write_channels : ao2 # NI DAQ analog output channels to use for writing position
+      read_channels : ai2  # NI DAQ analog input channels to use for reading position
+      min_position: -10  # conversion factor from volts to microns, can also supply a list [8,8,8] or [6,4.2,5]
+      max_position: 10  # the voltage value that defines the position 0,0,0, can also supply a list [0,0,0] or [5,5,5]
+      scale_nm_per_volt: 1  # microns
+
+  VoltageController:
+    import_path : qt3utils.nidaq.customcontrollers
+    class_name  : VControl
+    configure :
+      daq_name : Silicon_DAQ # NI DAQ Device Name
+      write_channels : ao0 # NI DAQ analog output channels to use for writing position
+      read_channels : ai0  # NI DAQ analog input channels to use for reading position
+      min_position: -10  # conversion factor from volts to microns, can also supply a list [8,8,8] or [6,4.2,5]
+      max_position: 10  # the voltage value that defines the position 0,0,0, can also supply a list [0,0,0] or [5,5,5]
+      scale_nm_per_volt: 1  # microns
+
+  WavemeterController:
+    import_path : qt3utils.applications.controllers.wavemeter_controller
+    class_name  : WavemeterController
+    configure :
+      dll_path : C:\\\\Users\\\\Fulab\\\\Downloads\\\\00392-2-06-A_CustomerCD621\\\\00392-2-06-A_Customer CD 621\\\\Programming Interface\\\\x64\\\\CLDevIFace.dll\
\ No newline at end of file
diff --git a/src/qt3utils/applications/controllers/wavemeter_controller.py b/src/qt3utils/applications/controllers/wavemeter_controller.py
index 1e57cff8..b2708c0d 100644
--- a/src/qt3utils/applications/controllers/wavemeter_controller.py
+++ b/src/qt3utils/applications/controllers/wavemeter_controller.py
@@ -1,9 +1,11 @@
 import ctypes
+import logging
 
-class WavemeterController
+class WavemeterController:
     def __init__(self, dll_path=""):
+        self.logger = logging.getLogger(__name__)
         if not dll_path == "":
-            self.init_dll()
+            self.init_dll(dll_path)
         self.dll_path = dll_path
         self.last_config_dict = {}
 
@@ -31,6 +33,6 @@ def configure(self, config_dict: dict) -> None:
         self.logger.debug("calling configure on the wave meter controller")
         self.last_config_dict.update(config_dict)
 
-        self.dll_path = config_dict.get('daq_name', self.data_generator.daq_name)
+        self.dll_path = config_dict.get('daq_name', self.dll_path)
         self.init_dll(self.dll_path)
 
diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index d4c47e1b..cb0adcff 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -35,22 +35,14 @@
 if args.quiet is False:
     logger.setLevel(logging.INFO)
 
-NIDAQ_DEVICE_NAME = 'NIDAQ Rate Counter'
+NIDAQ_DEVICE_NAMES = ['NIDAQ Rate Counter', "Lockin & Wavemeter"]
 RANDOM_DAQ_DEVICE_NAME = 'Random Data Generator'
 
-DEFAULT_DAQ_DEVICE_NAME = NIDAQ_DEVICE_NAME
+DEFAULT_DAQ_DEVICE_NAME = NIDAQ_DEVICE_NAMES[0]
 
 CONTROLLER_PATH = 'qt3utils.applications.controllers'
-SUPPORTED_CONTROLLERS = {NIDAQ_DEVICE_NAME: 'nidaq_rate_counter.yaml'
-                         }
-STANDARD_CONTROLLERS = {NIDAQ_DEVICE_NAME: {'yaml': 'nidaq_rate_counter.yaml',
-                                                'application_controller_class': plescanner.CounterAndScanner}
-                        }
-CONFIG_FILE_APPLICATION_NAME = 'QT3PLE'
-CONFIG_FILE_EXPERIMENT = 'Experiment'
-CONFIG_FILE_DAQ_DEVICE = 'DAQCounter'
-CONFIG_FILE_VOLTAGE_CONTROLLER = 'VoltageController'
-CONFIG_FILE_DAQ_CONTROLLER = 'DAQController'
+STANDARD_CONTROLLERS = {NIDAQ_DEVICE_NAMES[0] : 'nidaq_rate_counter.yaml',
+                        NIDAQ_DEVICE_NAMES[1] : 'nidaq_wm_ple.yaml'}
 
 class ScanImage:
     def __init__(self, mplcolormap='gray') -> None:
@@ -162,10 +154,6 @@ def __init__(self, root, scan_range) -> None:
         self.controller_option = tk.StringVar(frame)
         self.controller_option.set(DEFAULT_DAQ_DEVICE_NAME)  # setting the default value
 
-        self.controller_menu = tk.OptionMenu(frame,
-                                             self.controller_option,
-                                             *STANDARD_CONTROLLERS.keys(),
-                                             command=root.load_daq_from_config_dict)
         self.controller_menu = tk.OptionMenu(frame,
                                              self.controller_option,
                                              *STANDARD_CONTROLLERS.keys(),
@@ -208,9 +196,9 @@ def __init__(self, controller_name) -> None:
         self.view = MainApplicationView(self)
         self.view.controller_option = controller_name
         # data acquisition model that is used to acquire data
-        self.data_acquisition_model = None
+        self.data_acquisition_models = {}
+        self.controller_models = {}
         # load the data acquisition model
-        self.load_daq_from_config_dict(controller_name)
         self.view.sidepanel.startButton.bind("<Button>", self.start_scan)
         self.view.sidepanel.saveScanButton.bind("<Button>", self.save_scan)
         self.view.sidepanel.stopButton.bind("<Button>", self.stop_scan)
@@ -327,7 +315,7 @@ def save_scan(self, event = None):
             h5file.close()
         self.view.sidepanel.saveScanButton.config(state=tk.NORMAL)
 
-    def configure_from_yaml(self) -> None:
+    def configure_from_yaml(self, afile=None) -> None:
         """
         This method launches a GUI window to allow the user to select a yaml file to configure the data controller.
 
@@ -336,95 +324,55 @@ def configure_from_yaml(self) -> None:
         filetypes = (
             ('YAML', '*.yaml'),
         )
-        afile = tk.filedialog.askopenfile(filetypes=filetypes, defaultextension='.yaml')
-        if afile is None:
-            return  # selection was canceled.
-
-        config = yaml.safe_load(afile)
-        afile.close()
-
-        counter_config = config[CONFIG_FILE_APPLICATION_NAME][CONFIG_FILE_DAQ_DEVICE]
-
-        same_daq_name = self.data_acquisition_model.__class__.__name__ == counter_config['class_name']
-        same_daq_module = self.data_acquisition_model.__class__.__module__ == counter_config['import_path']
-
-        if same_daq_name is False or same_daq_module is False:
-            msg = f"""\nCurrent data acquisition object is not of type found in YAML
-Found in YAML: {counter_config['import_path']}.{counter_config['class_name']}.
-Current data acquistion object: {self.data_acquisition_model.__class__.__module__}.{self.data_acquisition_model.__class__.__name__}
-Configuration not loaded. Please select appropriate controller from the pull-down menu
-or check your YAML file to ensure configuration of supported hardware controller.
-"""
-            logger.warning(msg)
+        if not afile:
+            afile = tk.filedialog.askopenfile(filetypes=filetypes, defaultextension='.yaml')
+            if afile is None:
+                return  # selection was canceled.
+            config = yaml.safe_load(afile)
+            afile.close()
         else:
-            logger.info("load settings from yaml")
-            logger.info(counter_config['configure'])
-            self.data_acquisition_model.configure(counter_config['configure'])
-
-
-    def _open_config_for_hardware(self, hardware_name: str) -> dict:
-        with importlib.resources.path(CONTROLLER_PATH, SUPPORTED_CONTROLLERS[hardware_name]) as yaml_path:
-            logger.info(f"opening config file: {yaml_path}")
-            with open(yaml_path, 'r') as yaml_file:
-                config = yaml.safe_load(yaml_file)
-
-        return config
-
-    def load_daq_from_config_dict(self, controller_name: str) -> None:
-
-        config = self._open_config_for_hardware(controller_name)
-
-        counter_config = config[CONFIG_FILE_APPLICATION_NAME][CONFIG_FILE_DAQ_DEVICE]
-
-        logger.info("loading from configuration")
-        logger.info(counter_config)
-
-        # Dynamically import the module
-        module = importlib.import_module(counter_config['import_path'])
-
-        # Dynamically instantiate the class
-        cls = getattr(module, counter_config['class_name'])
-        # cls should be instance of QT3ScopeNIDAQEdgeCounterController
-        self.data_acquisition_model = cls(logger.level)
-        assert isinstance(self.data_acquisition_model, QT3ScopeNIDAQEdgeCounterController)
-
-        # configure the data acquisition model
-        self.data_acquisition_model.configure(counter_config['configure'])
-        #self.view.hardware_config_button.bind("<Button>", lambda e: self.data_acquisition_model.configure_view(self.root))
-        self.animation = None  # reset the animation
-
-    def _open_yaml_config_for_controller(self, controller_name: str) -> dict:
-        with importlib.resources.path(CONTROLLER_PATH, STANDARD_CONTROLLERS[controller_name]['yaml']) as yaml_path:
-            logger.info(f"opening config file: {yaml_path}")
-            with open(yaml_path, 'r') as yaml_file:
-                config = yaml.safe_load(yaml_file)
-
-        return config
-
-    def _load_controller_from_dict(self, config: dict, a_protocol: Protocol) -> Any:
-        """
-        Dynamically imports the module and instantiates the class specified in the config dictionary.
-        Class the class configure method if it exists.
-        """
-        # Dynamically import the module
-        module = importlib.import_module(config['import_path'])
-        logger.debug(f"loading {config['import_path']}")
-
-        # Dynamically instantiate the class
-        cls = getattr(module, config['class_name'])
-        logger.debug(f"instantiating {config['class_name']}")
-
-        controller = cls(logger.level)
-
-        logger.debug(f"asserting {config['class_name']} of proper type {a_protocol}")
-        assert isinstance(controller, a_protocol)
-
-        # configure the controller
-        # all controllers *should* have a configure method
-        logger.debug(f"calling {a_protocol} configure method")
-        controller.configure(config['configure'])
-
-        return controller
+            with open(afile, 'r') as file:
+                config = yaml.safe_load(file)
+
+        CONFIG_FILE_APPLICATION_NAME = list(config.keys())[0]
+
+        self.app_controller_config = config[CONFIG_FILE_APPLICATION_NAME]["ApplicationController"]
+        self.app_config = self.app_controller_config["configure"]
+        logger.info("load settings from yaml")
+        daq_readers = self.app_config["readers"]["daq_readers"]
+        if daq_readers is not None:
+            for daq_reader in daq_readers:
+                daq_reader_name = daq_readers[daq_reader]
+                daq_reader_config = config[CONFIG_FILE_APPLICATION_NAME][daq_reader_name]
+                module = importlib.import_module(daq_reader_config['import_path'])
+                logger.debug(f"loading {daq_reader_config['import_path']}")
+                cls = getattr(module, daq_reader_config['class_name'])
+                self.data_acquisition_models[daq_reader] = cls()
+                self.data_acquisition_models[daq_reader].configure(daq_reader_config['configure'])
+        wm_readers = self.app_config["readers"]["wm_readers"]
+        if wm_readers is not None:
+            for wm_reader in wm_readers:
+                wm_reader_name = wm_readers[wm_reader]
+                wm_reader_config = config[CONFIG_FILE_APPLICATION_NAME][wm_reader_name]
+                module = importlib.import_module(wm_reader_config['import_path'])
+                logger.debug(f"loading {wm_reader_config['import_path']}")
+                cls = getattr(module, wm_reader_config['class_name'])
+                self.data_acquisition_models[wm_reader] = cls()
+                self.data_acquisition_models[wm_reader].configure(wm_reader_config['configure'])
+        daq_controllers = self.app_config["controllers"]["daq_writers"]
+        if daq_controllers is not None:
+            for daq_controller in daq_controllers:
+                daq_controller_name = daq_controllers[daq_controller]
+                daq_controller_config = config[CONFIG_FILE_APPLICATION_NAME][daq_controller_name]
+                module = importlib.import_module(daq_controller_config['import_path'])
+                logger.debug(f"loading {daq_controller_config['import_path']}")
+                cls = getattr(module, daq_controller_config['class_name'])
+                self.controller_models[daq_controller] = cls(logger.level)
+                self.controller_models[daq_controller].configure(daq_controller_config['configure'])
+        app_module = importlib.import_module(self.app_controller_config['import_path'])
+        logger.debug(f"loading {self.app_controller_config['import_path']}")
+        app_cls = getattr(app_module, self.app_controller_config["class_name"])
+        self.application_controller = plescanner.GetApplicationControllerInstance(app_cls, self.data_acquisition_models, self.controller_models)
 
     def load_controller_from_name(self, application_controller_name: str) -> None:
         """
@@ -433,27 +381,10 @@ def load_controller_from_name(self, application_controller_name: str) -> None:
         Should be called during instantiation of this class and should be the callback
         function for the support controller pull-down menu in the side panel
         """
-        logger.info(f"loading {application_controller_name}")
-        config = self._open_yaml_config_for_controller(application_controller_name)
-        self._build_controllers_from_config_dict(config, application_controller_name)
-
-    def _build_controllers_from_config_dict(self, config: dict, controller_name: str) -> None:
-
-        # load the position controller from dict
-        pos_config = config[CONFIG_FILE_APPLICATION_NAME][CONFIG_FILE_VOLTAGE_CONTROLLER]
-        voltage_controller = self._load_controller_from_dict(pos_config, VControl)
-
-        # load the data acquisition model from dict
-        daq_config = config[CONFIG_FILE_APPLICATION_NAME][CONFIG_FILE_DAQ_DEVICE]
-        daq_controller = self._load_controller_from_dict(daq_config, QT3ScopeNIDAQEdgeCounterController)
-
-        ControllerClass = STANDARD_CONTROLLERS[controller_name]['application_controller_class']
-        self.application_controller = plescanner.CounterAndScanner(daq_controller.data_generator, voltage_controller)
+        #yaml_path = importlib.resources.path(CONTROLLER_PATH, STANDARD_CONTROLLERS[application_controller_name])
+        yaml_path = importlib.resources.files(CONTROLLER_PATH).joinpath(STANDARD_CONTROLLERS[application_controller_name])
+        self.configure_from_yaml(str(yaml_path))
 
-        # bind buttons to controllers
-        #self.view.scan_view.set_rightclick_callback(self.application_controller.scan_image_rightclick_event)
-        #self.view.voltage_controller_config_button.bind("<Button>", lambda e: self.application_controller.wavelength_controller.configure_view(self.root))
-        #self.view.daq_config_button.bind("<Button>", lambda e: self.application_controller.rate_counter.configure_view(self.root))
 def main() -> None:
     tkapp = MainTkApplication(DEFAULT_DAQ_DEVICE_NAME)
     tkapp.run()
diff --git a/src/qt3utils/datagenerators/plescanner.py b/src/qt3utils/datagenerators/plescanner.py
index 19c87d76..7c7c21b1 100644
--- a/src/qt3utils/datagenerators/plescanner.py
+++ b/src/qt3utils/datagenerators/plescanner.py
@@ -2,9 +2,13 @@
 import numpy as np
 import time
 import logging
+from qt3utils.applications.controllers.nidaqedgecounter import QT3ScopeNIDAQEdgeCounterController
+from qt3utils.nidaq.customcontrollers import VControl
+from qt3utils.applications.controllers.wavemeter_controller import WavemeterController
 
 logger = logging.getLogger(__name__)
 
+
 class PleScanner:
 
     def __init__(self, wavelength_controller):
@@ -96,10 +100,12 @@ def configure_view(self, gui_root: tk.Toplevel) -> None:
     @property
     def step_size(self):
         return self._step_size
+
     @step_size.setter
     def step_size(self, val):
         self._step_size = val
 
+
 class CounterAndScanner(PleScanner):
     def __init__(self, rate_counter, wavelength_controller) -> None:
         super(CounterAndScanner, self).__init__(wavelength_controller)
@@ -115,7 +121,6 @@ def start(self) -> None:
         self.running = True
         self.rate_counter.start()
 
-
     def close(self) -> None:
         self.rate_counter.close()
 
@@ -166,11 +171,11 @@ def reset(self) -> None:
         self.scanned_count_rate = []
 
 
-
-class WavemeterAndScanner(CounterAndScanner):
-    def __init__(self, wm_reader, wavelength_controller):
+class WavemeterAndScanner(PleScanner):
+    def __init__(self, wm_reader, v_readers, wavelength_controller):
         super(WavemeterAndScanner, self).__init__(wavelength_controller)
         self.wm_reader = wm_reader
+        self.v_readers = v_readers
         self.scanned_raw_counts = []
         self.scanned_wm = []
 
@@ -191,6 +196,9 @@ def scan_axis(self, axis, min, max, step_size) -> list:
         Returns a list of readings from the wave meter for each scan
         """
         wm_scan = []
+        vs_scans = {}
+        for v_reader in self.v_readers:
+            vs_scans[v_reader.read_channel] = []
         self.wavelength_controller.go_to_voltage(**{axis: min})
         time.sleep(self.raster_line_pause)
         for val in np.arange(min, max, step_size):
@@ -201,8 +209,14 @@ def scan_axis(self, axis, min, max, step_size) -> list:
             wm_scan.append(_wm_reading)
             if self.wavelength_controller:
                 logger.info(f'current voltage: {self.wavelength_controller.get_current_voltage()}')
-        return wm_scan
-
-
+            for v_reader in self.v_readers:
+                v_reading = v_reader.get_current_voltage()
+                vs_scans[v_reader.read_channel].append(v_reading)
+        return wm_scan, vs_scans
 
 
+def GetApplicationControllerInstance(classtype, readers, controllers):
+    if classtype == WavemeterAndScanner:
+        return classtype(list(readers.values())[-1], list(readers.values())[0:-1], list(controllers.values())[0])
+    elif classtype == CounterAndScanner:
+        return classtype(list(readers.values())[0], list(controllers.values())[0])
diff --git a/src/qt3utils/nidaq/customcontrollers.py b/src/qt3utils/nidaq/customcontrollers.py
index 73e0b25a..3fcdac97 100644
--- a/src/qt3utils/nidaq/customcontrollers.py
+++ b/src/qt3utils/nidaq/customcontrollers.py
@@ -5,7 +5,7 @@
 logger = logging.getLogger(__name__)
 class VControl():
 
-    def __init__(self, device_name: str,
+    def __init__(self, device_name: str = "",
                  write_channel: str = 'ao0',
                  read_channel: str = None,
                  scale_nm_per_volt: float = 8,

From 020df1cbcfc8e4f8445be88d75ac77aa026d78f5 Mon Sep 17 00:00:00 2001
From: LimeBasil&Mandarin <yunzhao.wang1996@gmail.com>
Date: Thu, 8 Feb 2024 17:25:54 -0800
Subject: [PATCH 22/32] Fixed issues connecting to wavemeter

---
 src/qt3utils/applications/controllers/nidaq_wm_ple.yaml      | 2 +-
 .../applications/controllers/wavemeter_controller.py         | 4 ++--
 src/qt3utils/applications/qt3ple/main.py                     | 3 ++-
 src/qt3utils/datagenerators/plescanner.py                    | 5 +++--
 4 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml b/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
index d70126cb..423e6963 100644
--- a/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
+++ b/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
@@ -50,4 +50,4 @@ QT3PLE:
     import_path : qt3utils.applications.controllers.wavemeter_controller
     class_name  : WavemeterController
     configure :
-      dll_path : C:\\\\Users\\\\Fulab\\\\Downloads\\\\00392-2-06-A_CustomerCD621\\\\00392-2-06-A_Customer CD 621\\\\Programming Interface\\\\x64\\\\CLDevIFace.dll\
\ No newline at end of file
+      dll_path : C:/Users/Fulab/Downloads/00392-2-06-A_CustomerCD621/00392-2-06-A_Customer CD 621/Programming Interface/x64/CLDevIFace.dll
\ No newline at end of file
diff --git a/src/qt3utils/applications/controllers/wavemeter_controller.py b/src/qt3utils/applications/controllers/wavemeter_controller.py
index b2708c0d..1fad1d8d 100644
--- a/src/qt3utils/applications/controllers/wavemeter_controller.py
+++ b/src/qt3utils/applications/controllers/wavemeter_controller.py
@@ -31,8 +31,8 @@ def configure(self, config_dict: dict) -> None:
         This method is used to configure the data controller.
         """
         self.logger.debug("calling configure on the wave meter controller")
-        self.last_config_dict.update(config_dict)
+        #self.last_config_dict.update(config_dict)
 
-        self.dll_path = config_dict.get('daq_name', self.dll_path)
+        self.dll_path = config_dict.get('dll_path', self.dll_path)
         self.init_dll(self.dll_path)
 
diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index cb0adcff..20ecdc41 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -262,7 +262,8 @@ def scan_thread_function(self, vmin, vmax, step_size, N) -> None:
 
         self.application_controller.set_scan_range(vmin, vmax)
         self.application_controller.step_size = step_size
-        self.application_controller.set_num_data_samples_per_batch(N)
+        if isinstance(self.application_controller, plescanner.CounterAndScanner):
+            self.application_controller.set_num_data_samples_per_batch(N)
 
         try:
             self.application_controller.reset()  # clears the data
diff --git a/src/qt3utils/datagenerators/plescanner.py b/src/qt3utils/datagenerators/plescanner.py
index 7c7c21b1..078a4d14 100644
--- a/src/qt3utils/datagenerators/plescanner.py
+++ b/src/qt3utils/datagenerators/plescanner.py
@@ -183,12 +183,13 @@ def scan_v(self) -> None:
         """
         Scans the wavelengths from vmin to vmax in steps of step_size.
         """
-        _wm_scan = self.scan_axis('v', self.vmin, self.vmax, self._step_size)
+        _wm_scan, _vs_scan = self.scan_axis('v', self.vmin, self.vmax, self._step_size)
         self.scanned_wm.append(_wm_scan)
+        self.scanned_raw_counts.append(_vs_scan)
         self.current_t = self.current_t + 1
 
     def read_wavemeter(self):
-        self.wavelength_controller.read_wavemeter()
+        return self.wm_reader.read_wavemeter()
 
     def scan_axis(self, axis, min, max, step_size) -> list:
         """

From b38a8d857a24c9239801306727bbb69375f59d2b Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Fri, 9 Feb 2024 09:20:53 -0800
Subject: [PATCH 23/32] Added comments to new functionality

---
 .../controllers/wavemeter_controller.py       | 10 +++++--
 src/qt3utils/applications/qt3ple/main.py      |  4 +--
 src/qt3utils/datagenerators/plescanner.py     | 29 ++++++++++++++++---
 3 files changed, 35 insertions(+), 8 deletions(-)

diff --git a/src/qt3utils/applications/controllers/wavemeter_controller.py b/src/qt3utils/applications/controllers/wavemeter_controller.py
index 1fad1d8d..a9d5c725 100644
--- a/src/qt3utils/applications/controllers/wavemeter_controller.py
+++ b/src/qt3utils/applications/controllers/wavemeter_controller.py
@@ -2,6 +2,9 @@
 import logging
 
 class WavemeterController:
+    """
+    Class for interfacing with wavemeter hardware
+    """
     def __init__(self, dll_path=""):
         self.logger = logging.getLogger(__name__)
         if not dll_path == "":
@@ -9,14 +12,17 @@ def __init__(self, dll_path=""):
         self.dll_path = dll_path
         self.last_config_dict = {}
 
-    def init_dll(self, dll_path):
+    def init_dll(self, dll_path) -> None:
+        """
+        Set the path to the dll used for interfacing with the wavemeter
+        """
         self._mydll = ctypes.cdll.LoadLibrary(dll_path)
         self._mydll.CLGetLambdaReading.restype = ctypes.c_double
         self._dh = self._mydll.CLOpenUSBSerialDevice(4)
         if self._dh == -1:
             raise Exception("Failed to connect to wave meter.")
 
-    def read_wavemeter(self):
+    def read_wavemeter(self) -> float:
         return self._mydll.CLGetLambdaReading(self._dh)
 
     def close_wavemeter(self) -> None:
diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index 20ecdc41..77cb65eb 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -319,8 +319,8 @@ def save_scan(self, event = None):
     def configure_from_yaml(self, afile=None) -> None:
         """
         This method launches a GUI window to allow the user to select a yaml file to configure the data controller.
-
-        This does not instantiate a new hardware controller class. It only configures the existing one.
+        Or it loads a specified configuration yaml file.
+        It will attempt to configure the hardware specified in the configuration file and instantiate a controller class
         """
         filetypes = (
             ('YAML', '*.yaml'),
diff --git a/src/qt3utils/datagenerators/plescanner.py b/src/qt3utils/datagenerators/plescanner.py
index 078a4d14..8a638a89 100644
--- a/src/qt3utils/datagenerators/plescanner.py
+++ b/src/qt3utils/datagenerators/plescanner.py
@@ -10,6 +10,10 @@
 
 
 class PleScanner:
+    """
+    Base class with function methods which any PLE experiment will need to operate
+    Override this class for specific types of PLE experiments
+    """
 
     def __init__(self, wavelength_controller):
         self.running = False
@@ -107,6 +111,10 @@ def step_size(self, val):
 
 
 class CounterAndScanner(PleScanner):
+    """
+    Inherits from PleScanner base class
+    Adds a rate counter for the SPCM and correlates counts with scans
+    """
     def __init__(self, rate_counter, wavelength_controller) -> None:
         super(CounterAndScanner, self).__init__(wavelength_controller)
         self.scanned_raw_counts = []
@@ -172,11 +180,15 @@ def reset(self) -> None:
 
 
 class WavemeterAndScanner(PleScanner):
+    """
+    Inherits from PleScanner base class
+    Adds a wavemeter and daq readings to the correlated voltage sweeps
+    """
     def __init__(self, wm_reader, v_readers, wavelength_controller):
         super(WavemeterAndScanner, self).__init__(wavelength_controller)
         self.wm_reader = wm_reader
         self.v_readers = v_readers
-        self.scanned_raw_counts = []
+        self.scanned_count_rate = []
         self.scanned_wm = []
 
     def scan_v(self) -> None:
@@ -185,7 +197,7 @@ def scan_v(self) -> None:
         """
         _wm_scan, _vs_scan = self.scan_axis('v', self.vmin, self.vmax, self._step_size)
         self.scanned_wm.append(_wm_scan)
-        self.scanned_raw_counts.append(_vs_scan)
+        self.scanned_count_rate.append(_vs_scan)
         self.current_t = self.current_t + 1
 
     def read_wavemeter(self):
@@ -194,7 +206,7 @@ def read_wavemeter(self):
     def scan_axis(self, axis, min, max, step_size) -> list:
         """
         Moves the voltage from min to max in steps of step_size.
-        Returns a list of readings from the wave meter for each scan
+        Returns a list of readings from the wave meter and DAQ for each scan
         """
         wm_scan = []
         vs_scans = {}
@@ -216,7 +228,16 @@ def scan_axis(self, axis, min, max, step_size) -> list:
         return wm_scan, vs_scans
 
 
-def GetApplicationControllerInstance(classtype, readers, controllers):
+def GetApplicationControllerInstance(classtype, readers: dict, controllers: dict):
+    """
+    Create an instance of the application controller depending on the type
+    classtype : class
+        - either WavemeterAndScanner or CounterAndScanner
+    readers : dict
+        - dict of readers this class uses. For WaveMeterAndScanner, wavemeter is first, then DAQs
+    controllers : dict
+        - dict of controllers this class uses. This will always be a VControl class
+    """
     if classtype == WavemeterAndScanner:
         return classtype(list(readers.values())[-1], list(readers.values())[0:-1], list(controllers.values())[0])
     elif classtype == CounterAndScanner:

From cb48d033d05a50870d0b812b2b83c3b590e3ecdb Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Sat, 10 Feb 2024 23:17:54 -0800
Subject: [PATCH 24/32] Added pythonic docstrings, variable names, and import
 order

---
 .../controllers/wavemeter_controller.py       |   2 -
 src/qt3utils/applications/qt3ple/main.py      | 119 ++++++++----------
 src/qt3utils/datagenerators/plescanner.py     |  13 +-
 src/qt3utils/nidaq/customcontrollers.py       |  26 ++--
 4 files changed, 75 insertions(+), 85 deletions(-)

diff --git a/src/qt3utils/applications/controllers/wavemeter_controller.py b/src/qt3utils/applications/controllers/wavemeter_controller.py
index a9d5c725..b4a13a0e 100644
--- a/src/qt3utils/applications/controllers/wavemeter_controller.py
+++ b/src/qt3utils/applications/controllers/wavemeter_controller.py
@@ -37,8 +37,6 @@ def configure(self, config_dict: dict) -> None:
         This method is used to configure the data controller.
         """
         self.logger.debug("calling configure on the wave meter controller")
-        #self.last_config_dict.update(config_dict)
-
         self.dll_path = config_dict.get('dll_path', self.dll_path)
         self.init_dll(self.dll_path)
 
diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index 77cb65eb..d662a894 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -1,32 +1,27 @@
 import argparse
-import tkinter as tk
-import logging
-from threading import Thread
-import yaml
+import h5py
 import importlib
 import importlib.resources
-from typing import Any, Protocol
-
-import numpy as np
+import logging
 import matplotlib.pyplot as plt
-from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
 import matplotlib
-import h5py
 import nidaqmx
-from qt3utils.nidaq.customcontrollers import VControl
+import numpy as np
+import tkinter as tk
+import yaml
+
+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
 from qt3utils.datagenerators import plescanner
-from qt3utils.applications.controllers.nidaqedgecounter import QT3ScopeNIDAQEdgeCounterController
+from threading import Thread
 
 matplotlib.use('Agg')
 
 parser = argparse.ArgumentParser(description='NI DAQ (PCIx 6363) / PLE Scanner',
                                  formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-
 parser.add_argument('-q', '--quiet', action='store_true',
                     help='When true,logger level will be set to warning. Otherwise, set to "info".')
 parser.add_argument('-cmap', metavar='<MPL color>', default='gray',
                     help='Set the MatplotLib colormap scale')
-
 args = parser.parse_args()
 
 logger = logging.getLogger(__name__)
@@ -96,20 +91,20 @@ def __init__(self, root, scan_range) -> None:
         row = 0
         tk.Label(frame, text="Scan Settings", font='Helvetica 16').grid(row=row, column=0, pady=10)
         row += 1
-        self.startButton = tk.Button(frame, text="Start Scan")
-        self.startButton.grid(row=row, column=0)
-        self.stopButton = tk.Button(frame, text="Stop Scan")
-        self.stopButton.grid(row=row, column=1)
-        self.saveScanButton = tk.Button(frame, text="Save Scan")
-        self.saveScanButton.grid(row=row, column=2)
+        self.start_button = tk.Button(frame, text="Start Scan")
+        self.start_button.grid(row=row, column=0)
+        self.stop_button = tk.Button(frame, text="Stop Scan")
+        self.stop_button.grid(row=row, column=1)
+        self.save_scan_button = tk.Button(frame, text="Save Scan")
+        self.save_scan_button.grid(row=row, column=2)
         row += 1
         tk.Label(frame, text="Voltage Range (V)").grid(row=row, column=0)
-        self.v_min_entry = tk.Entry(frame, width=10)
-        self.v_max_entry = tk.Entry(frame, width=10)
-        self.v_min_entry.insert(10, scan_range[0])
-        self.v_max_entry.insert(10, scan_range[1])
-        self.v_min_entry.grid(row=row, column=1)
-        self.v_max_entry.grid(row=row, column=2)
+        self.voltage_min_entry = tk.Entry(frame, width=10)
+        self.voltage_max_entry = tk.Entry(frame, width=10)
+        self.voltage_min_entry.insert(10, scan_range[0])
+        self.voltage_max_entry.insert(10, scan_range[1])
+        self.voltage_min_entry.grid(row=row, column=1)
+        self.voltage_max_entry.grid(row=row, column=2)
 
         row += 1
         tk.Label(frame, text="Number of Pixels").grid(row=row, column=0)
@@ -133,22 +128,22 @@ def __init__(self, root, scan_range) -> None:
         tk.Label(frame, text="DAQ Settings", font='Helvetica 16').grid(row=row, column=0, pady=10)
 
         row += 1
-        self.GotoButton = tk.Button(frame, text="Go To Voltage")
-        self.GotoButton.grid(row=row, column=0)
+        self.goto_button = tk.Button(frame, text="Go To Voltage")
+        self.goto_button.grid(row=row, column=0)
         row += 1
         tk.Label(frame, text="Voltage (V)").grid(row=row, column=0)
-        self.v_entry = tk.Entry(frame, width=10)
-        self.v_entry.insert(10, 0)
-        self.v_entry.grid(row=row, column=1)
+        self.voltage_entry = tk.Entry(frame, width=10)
+        self.voltage_entry.insert(10, 0)
+        self.voltage_entry.grid(row=row, column=1)
 
         row += 1
         tk.Label(frame, text="Voltage Limits (V)").grid(row=row, column=0)
-        self.v_lmin_entry = tk.Entry(frame, width=10)
-        self.v_lmax_entry = tk.Entry(frame, width=10)
-        self.v_lmin_entry.insert(10, float(scan_range[0]))
-        self.v_lmax_entry.insert(10, float(scan_range[1]))
-        self.v_lmin_entry.grid(row=row, column=1)
-        self.v_lmax_entry.grid(row=row, column=2)
+        self.voltage_lmin_entry = tk.Entry(frame, width=10)
+        self.voltage_lmax_entry = tk.Entry(frame, width=10)
+        self.voltage_lmin_entry.insert(10, float(scan_range[0]))
+        self.voltage_lmax_entry.insert(10, float(scan_range[1]))
+        self.voltage_lmin_entry.grid(row=row, column=1)
+        self.voltage_lmax_entry.grid(row=row, column=2)
 
         row+=1
         self.controller_option = tk.StringVar(frame)
@@ -183,11 +178,6 @@ def __init__(self, main_frame, scan_range=[-3, 5]) -> None:
 
         self.canvas.draw()
 
-    #@property
-    #def hardware_config_button(self) -> tk.Button:
-    #    return self.sidepanel.hardware_config_button
-
-
 class MainTkApplication():
 
     def __init__(self, controller_name) -> None:
@@ -199,34 +189,34 @@ def __init__(self, controller_name) -> None:
         self.data_acquisition_models = {}
         self.controller_models = {}
         # load the data acquisition model
-        self.view.sidepanel.startButton.bind("<Button>", self.start_scan)
-        self.view.sidepanel.saveScanButton.bind("<Button>", self.save_scan)
-        self.view.sidepanel.stopButton.bind("<Button>", self.stop_scan)
-        self.view.sidepanel.GotoButton.bind("<Button>", self.go_to_voltage)
+        self.view.sidepanel.start_button.bind("<Button>", self.start_scan)
+        self.view.sidepanel.save_scan_button.bind("<Button>", self.save_scan)
+        self.view.sidepanel.stop_button.bind("<Button>", self.stop_scan)
+        self.view.sidepanel.goto_button.bind("<Button>", self.go_to_voltage)
         self.view.sidepanel.hardware_config_from_yaml_button.bind("<Button>", lambda e: self.configure_from_yaml())
         self.root.protocol("WM_DELETE_WINDOWwait_visibility()", self.on_closing)
 
     def go_to_voltage(self, event=None) -> None:
-        self.view.sidepanel.startButton['state'] = 'disabled'
-        self.view.sidepanel.GotoButton['state'] = 'disabled'
+        self.view.sidepanel.start_button['state'] = 'disabled'
+        self.view.sidepanel.goto_button['state'] = 'disabled'
         self.view.sidepanel.controller_menu.config(state=tk.DISABLED)
-        self.view.sidepanel.saveScanButton.config(state=tk.DISABLED)
-        self.application_controller.go_to_v(float(self.view.sidepanel.v_entry.get()))
-        self.view.sidepanel.startButton['state'] = 'normal'
-        self.view.sidepanel.GotoButton['state'] = 'normal'
+        self.view.sidepanel.save_scan_button.config(state=tk.DISABLED)
+        self.application_controller.go_to_v(float(self.view.sidepanel.voltage_entry.get()))
+        self.view.sidepanel.start_button['state'] = 'normal'
+        self.view.sidepanel.goto_button['state'] = 'normal'
         self.view.sidepanel.controller_menu.config(state=tk.NORMAL)
-        self.view.sidepanel.saveScanButton.config(state=tk.NORMAL)
+        self.view.sidepanel.save_scan_button.config(state=tk.NORMAL)
 
     def start_scan(self, event=None) -> None:
-        self.view.sidepanel.startButton['state'] = 'disabled'
-        self.view.sidepanel.GotoButton['state'] = 'disabled'
+        self.view.sidepanel.start_button['state'] = 'disabled'
+        self.view.sidepanel.goto_button['state'] = 'disabled'
         self.view.sidepanel.controller_menu.config(state=tk.DISABLED)
-        self.view.sidepanel.saveScanButton.config(state=tk.DISABLED)
+        self.view.sidepanel.save_scan_button.config(state=tk.DISABLED)
 
         n_sample_size = int(self.view.sidepanel.num_pixels.get())
         sweep_time_entry = float(self.view.sidepanel.sweep_time_entry.get())
-        vmin = float(self.view.sidepanel.v_min_entry.get())
-        vmax = float(self.view.sidepanel.v_max_entry.get())
+        vmin = float(self.view.sidepanel.voltage_min_entry.get())
+        vmax = float(self.view.sidepanel.voltage_max_entry.get())
         step_size = (vmax - vmin) / float(n_sample_size)
         args = [vmin, vmax]
         args.append(step_size)
@@ -245,10 +235,10 @@ def run(self) -> None:
 
     def stop_scan(self, event=None) -> None:
         self.application_controller.stop()
-        self.view.sidepanel.startButton['state'] = 'normal'
-        self.view.sidepanel.GotoButton['state'] = 'normal'
+        self.view.sidepanel.start_button['state'] = 'normal'
+        self.view.sidepanel.goto_button['state'] = 'normal'
         self.view.sidepanel.controller_menu.config(state=tk.NORMAL)
-        self.view.sidepanel.saveScanButton.config(state=tk.NORMAL)
+        self.view.sidepanel.save_scan_button.config(state=tk.NORMAL)
     def on_closing(self) -> None:
         try:
             self.stop_scan()
@@ -282,10 +272,10 @@ def scan_thread_function(self, vmin, vmax, step_size, N) -> None:
             logger.info(
                 'Check for other applications using resources. If not, you may need to restart the application.')
 
-        self.view.sidepanel.startButton['state'] = 'normal'
-        self.view.sidepanel.GotoButton['state'] = 'normal'
+        self.view.sidepanel.start_button['state'] = 'normal'
+        self.view.sidepanel.goto_button['state'] = 'normal'
         self.view.sidepanel.controller_menu.config(state=tk.NORMAL)
-        self.view.sidepanel.saveScanButton.config(state=tk.NORMAL)
+        self.view.sidepanel.save_scan_button.config(state=tk.NORMAL)
 
     def save_scan(self, event = None):
         myformats = [('Compressed Numpy MultiArray', '*.npz'), ('Numpy Array (count rate only)', '*.npy'), ('HDF5', '*.h5')]
@@ -314,7 +304,7 @@ def save_scan(self, event = None):
             for key, value in data.items():
                 h5file.create_dataset(key, data=value)
             h5file.close()
-        self.view.sidepanel.saveScanButton.config(state=tk.NORMAL)
+        self.view.sidepanel.save_scan_button.config(state=tk.NORMAL)
 
     def configure_from_yaml(self, afile=None) -> None:
         """
@@ -382,7 +372,6 @@ def load_controller_from_name(self, application_controller_name: str) -> None:
         Should be called during instantiation of this class and should be the callback
         function for the support controller pull-down menu in the side panel
         """
-        #yaml_path = importlib.resources.path(CONTROLLER_PATH, STANDARD_CONTROLLERS[application_controller_name])
         yaml_path = importlib.resources.files(CONTROLLER_PATH).joinpath(STANDARD_CONTROLLERS[application_controller_name])
         self.configure_from_yaml(str(yaml_path))
 
diff --git a/src/qt3utils/datagenerators/plescanner.py b/src/qt3utils/datagenerators/plescanner.py
index 8a638a89..490f882a 100644
--- a/src/qt3utils/datagenerators/plescanner.py
+++ b/src/qt3utils/datagenerators/plescanner.py
@@ -1,14 +1,10 @@
-import tkinter as tk
+import logging
 import numpy as np
 import time
-import logging
-from qt3utils.applications.controllers.nidaqedgecounter import QT3ScopeNIDAQEdgeCounterController
-from qt3utils.nidaq.customcontrollers import VControl
-from qt3utils.applications.controllers.wavemeter_controller import WavemeterController
+import tkinter as tk
 
 logger = logging.getLogger(__name__)
 
-
 class PleScanner:
     """
     Base class with function methods which any PLE experiment will need to operate
@@ -200,7 +196,10 @@ def scan_v(self) -> None:
         self.scanned_count_rate.append(_vs_scan)
         self.current_t = self.current_t + 1
 
-    def read_wavemeter(self):
+    def read_wavemeter(self) -> float:
+        """
+        Returns the reading from the wavemeter
+        """
         return self.wm_reader.read_wavemeter()
 
     def scan_axis(self, axis, min, max, step_size) -> list:
diff --git a/src/qt3utils/nidaq/customcontrollers.py b/src/qt3utils/nidaq/customcontrollers.py
index 3fcdac97..fadd82b6 100644
--- a/src/qt3utils/nidaq/customcontrollers.py
+++ b/src/qt3utils/nidaq/customcontrollers.py
@@ -1,9 +1,13 @@
+import logging
 import nidaqmx
 import time
-import logging
 
 logger = logging.getLogger(__name__)
 class VControl():
+    """
+    Class for interfacing with DAQ hardware with the express purpose of
+    controlling and/or reading the voltage at the DAQ that sets the wavelength of a laser
+    """
 
     def __init__(self, device_name: str = "",
                  write_channel: str = 'ao0',
@@ -20,26 +24,26 @@ def __init__(self, device_name: str = "",
         self.scale_nm_per_volt = scale_nm_per_volt
         self.minimum_allowed_position = min_position
         self.maximum_allowed_position = max_position
-        self._settling_time_in_seconds = move_settle_time #10 millisecond settle time
+        self._settling_time_in_seconds = move_settle_time  # 10 millisecond settle time
         self.last_write_value = None
 
 
 
-    def go_to_voltage(self, v: float = None) -> None:
+    def go_to_voltage(self, voltage: float = None) -> None:
         '''
-        !//Sets the voltage
+        Sets the voltage
         raises ValueError if try to set position out of bounds.
         '''
         debug_string = []
-        if v is not None:
-            self._validate_value(v)
+        if voltage is not None:
+            self._validate_value(voltage)
             with nidaqmx.Task() as task:
-                task.ao_channels.add_ao_voltage_chan(self.device_name + '/' + self.write_channel)
-                task.write(self._nm_to_volts(nm=v))
-                self.last_write_value = v
-            debug_string.append(f'v: {v:.2f}')
+                task.ao_channels.add_ao_voltage_chan(f"{self.device_name}/{self.write_channel}")
+                task.write(self._nm_to_volts(nm=voltage))
+                self.last_write_value = voltage
+            debug_string.append(f'voltage: {voltage:.2f}')
         logger.info(f'go to voltage {" ".join(debug_string)}')
-        time.sleep(self.settling_time_in_seconds) #wait to ensure piezo actuator has settled into position.
+        time.sleep(self.settling_time_in_seconds)  # wait to ensure piezo actuator has settled into position.
         logger.debug(f'last write: {self.last_write_value}')
 
     def get_current_voltage(self) -> float:

From aee149f0476bb27cab55f8a70a8aeba6bb4e7da6 Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Sun, 11 Feb 2024 18:59:10 -0800
Subject: [PATCH 25/32] Addressed PR requests by changing many style and
 clarity

---
 .../controllers/nidaq_wm_ple.yaml             |   4 +-
 .../controllers/wavemeter_controller.py       |  48 ++++-
 src/qt3utils/applications/qt3ple/main.py      |  95 ++++-----
 src/qt3utils/datagenerators/plescanner.py     | 182 +++++++++++++-----
 src/qt3utils/nidaq/customcontrollers.py       |  53 ++---
 5 files changed, 252 insertions(+), 130 deletions(-)

diff --git a/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml b/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
index 423e6963..fb2b51cb 100644
--- a/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
+++ b/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
@@ -11,7 +11,7 @@ QT3PLE:
           daq_reader : DAQReader
           daq_reader2 : DAQReader2
         wm_readers:
-          wm_reader : WavemeterController
+          wm_reader : WavemeterDllController
 
   DAQReader:
     import_path : qt3utils.nidaq.customcontrollers
@@ -48,6 +48,6 @@ QT3PLE:
 
   WavemeterController:
     import_path : qt3utils.applications.controllers.wavemeter_controller
-    class_name  : WavemeterController
+    class_name  : WavemeterDllController
     configure :
       dll_path : C:/Users/Fulab/Downloads/00392-2-06-A_CustomerCD621/00392-2-06-A_Customer CD 621/Programming Interface/x64/CLDevIFace.dll
\ No newline at end of file
diff --git a/src/qt3utils/applications/controllers/wavemeter_controller.py b/src/qt3utils/applications/controllers/wavemeter_controller.py
index b4a13a0e..6cee2ceb 100644
--- a/src/qt3utils/applications/controllers/wavemeter_controller.py
+++ b/src/qt3utils/applications/controllers/wavemeter_controller.py
@@ -3,16 +3,48 @@
 
 class WavemeterController:
     """
-    Class for interfacing with wavemeter hardware
+    Base class for other types of wavemeter controllers to inherit from
     """
-    def __init__(self, dll_path=""):
+    def __init__(self, logger_level):
         self.logger = logging.getLogger(__name__)
+        self.logger.setLevel(logger_level)
+
+    def open(self):
+        """
+        Override this method to open and initialize wavemeter
+        """
+        pass
+
+    def read_wavemeter(self):
+        """
+        Override this method to read the value from the wavemeter
+        """
+        pass
+
+    def close_wavemeter(self):
+        """
+        Override this method to close the connection to the wavemeter
+        """
+        pass
+
+    def configure(self):
+        """
+        Override this method to configure the wavemeter from a dict set via yaml file
+        """
+        pass
+
+class WavemeterDllController(WavemeterController):
+    """
+    Class for interfacing with wavemeter hardware
+    """
+    def __init__(self, logger_level, dll_path=""):
+        super(WavemeterDllController, self).__init__(logger_level)
         if not dll_path == "":
-            self.init_dll(dll_path)
+            self.open(dll_path)
         self.dll_path = dll_path
         self.last_config_dict = {}
 
-    def init_dll(self, dll_path) -> None:
+    def open(self, dll_path) -> None:
         """
         Set the path to the dll used for interfacing with the wavemeter
         """
@@ -23,9 +55,15 @@ def init_dll(self, dll_path) -> None:
             raise Exception("Failed to connect to wave meter.")
 
     def read_wavemeter(self) -> float:
+        """
+        Return the value from the wavemeter via the dll
+        """
         return self._mydll.CLGetLambdaReading(self._dh)
 
     def close_wavemeter(self) -> None:
+        """
+        Close the connection to the wavemeter via the dll
+        """
         ending = self._mydll.CLCloseDevice(self._dh)
         if ending == -1:
             raise Exception("Failed to properly close connection to wave meter.")
@@ -38,5 +76,5 @@ def configure(self, config_dict: dict) -> None:
         """
         self.logger.debug("calling configure on the wave meter controller")
         self.dll_path = config_dict.get('dll_path', self.dll_path)
-        self.init_dll(self.dll_path)
+        self.open(self.dll_path)
 
diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index d662a894..6b5b4a5c 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -3,16 +3,17 @@
 import importlib
 import importlib.resources
 import logging
-import matplotlib.pyplot as plt
+from threading import Thread
+
 import matplotlib
+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
+import matplotlib.pyplot as plt
 import nidaqmx
 import numpy as np
 import tkinter as tk
 import yaml
 
-from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
 from qt3utils.datagenerators import plescanner
-from threading import Thread
 
 matplotlib.use('Agg')
 
@@ -57,10 +58,10 @@ def update(self, model) -> None:
             data = model.scanned_count_rate
         data = np.array(data).T.tolist()
 
-        self.artist = self.ax.imshow(data, cmap=self.cmap, extent=[model.current_t + model.raster_line_pause,
+        self.artist = self.ax.imshow(data, cmap=self.cmap, extent=[model.current_frame + model.raster_line_pause,
                                                                    0,
-                                                                   model.vmin,
-                                                                   model.vmax + model.step_size
+                                                                   model.vstart,
+                                                                   model.vend + model.step_size
                                                                    ])
         if self.cbar is None:
             self.cbar = self.fig.colorbar(self.artist, ax=self.ax)
@@ -99,12 +100,12 @@ def __init__(self, root, scan_range) -> None:
         self.save_scan_button.grid(row=row, column=2)
         row += 1
         tk.Label(frame, text="Voltage Range (V)").grid(row=row, column=0)
-        self.voltage_min_entry = tk.Entry(frame, width=10)
-        self.voltage_max_entry = tk.Entry(frame, width=10)
-        self.voltage_min_entry.insert(10, scan_range[0])
-        self.voltage_max_entry.insert(10, scan_range[1])
-        self.voltage_min_entry.grid(row=row, column=1)
-        self.voltage_max_entry.grid(row=row, column=2)
+        self.voltage_start_entry = tk.Entry(frame, width=10)
+        self.voltage_end_entry = tk.Entry(frame, width=10)
+        self.voltage_start_entry.insert(10, scan_range[0])
+        self.voltage_end_entry.insert(10, scan_range[1])
+        self.voltage_start_entry.grid(row=row, column=1)
+        self.voltage_end_entry.grid(row=row, column=2)
 
         row += 1
         tk.Label(frame, text="Number of Pixels").grid(row=row, column=0)
@@ -197,30 +198,23 @@ def __init__(self, controller_name) -> None:
         self.root.protocol("WM_DELETE_WINDOWwait_visibility()", self.on_closing)
 
     def go_to_voltage(self, event=None) -> None:
-        self.view.sidepanel.start_button['state'] = 'disabled'
-        self.view.sidepanel.goto_button['state'] = 'disabled'
-        self.view.sidepanel.controller_menu.config(state=tk.DISABLED)
-        self.view.sidepanel.save_scan_button.config(state=tk.DISABLED)
-        self.application_controller.go_to_v(float(self.view.sidepanel.voltage_entry.get()))
-        self.view.sidepanel.start_button['state'] = 'normal'
-        self.view.sidepanel.goto_button['state'] = 'normal'
-        self.view.sidepanel.controller_menu.config(state=tk.NORMAL)
-        self.view.sidepanel.save_scan_button.config(state=tk.NORMAL)
+        self.disable_buttons()
+        self.application_controller.go_to_voltage(float(self.view.sidepanel.voltage_entry.get()))
+        self.enable_buttons()
 
     def start_scan(self, event=None) -> None:
-        self.view.sidepanel.start_button['state'] = 'disabled'
-        self.view.sidepanel.goto_button['state'] = 'disabled'
-        self.view.sidepanel.controller_menu.config(state=tk.DISABLED)
-        self.view.sidepanel.save_scan_button.config(state=tk.DISABLED)
+        self.disable_buttons()
 
         n_sample_size = int(self.view.sidepanel.num_pixels.get())
+        n_scans = int(self.view.sidepanel.scan_num_entry.get())
         sweep_time_entry = float(self.view.sidepanel.sweep_time_entry.get())
-        vmin = float(self.view.sidepanel.voltage_min_entry.get())
-        vmax = float(self.view.sidepanel.voltage_max_entry.get())
-        step_size = (vmax - vmin) / float(n_sample_size)
-        args = [vmin, vmax]
+        vstart= float(self.view.sidepanel.voltage_start_entry.get())
+        vend = float(self.view.sidepanel.voltage_end_entry.get())
+        step_size = (vend - vstart) / float(n_sample_size)
+        args = [vstart, vend]
         args.append(step_size)
         args.append(n_sample_size)
+        args.append(n_scans)
 
         settling_time = sweep_time_entry / n_sample_size
         self.application_controller.wavelength_controller.settling_time_in_seconds = settling_time
@@ -235,10 +229,7 @@ def run(self) -> None:
 
     def stop_scan(self, event=None) -> None:
         self.application_controller.stop()
-        self.view.sidepanel.start_button['state'] = 'normal'
-        self.view.sidepanel.goto_button['state'] = 'normal'
-        self.view.sidepanel.controller_menu.config(state=tk.NORMAL)
-        self.view.sidepanel.save_scan_button.config(state=tk.NORMAL)
+        self.enable_buttons()
     def on_closing(self) -> None:
         try:
             self.stop_scan()
@@ -248,20 +239,26 @@ def on_closing(self) -> None:
             logger.debug(e)
             pass
 
-    def scan_thread_function(self, vmin, vmax, step_size, N) -> None:
+    def scan_thread_function(self, vstart: float, vend: float, step_size: float, n_sample_size: int, n_scans: int) -> None:
+        """
+        Function to be called in background thread
+        Scans the voltage from vstart to vend in increments of step_size
+        for a total of n_sample_size data points n_scans number of times
+        """
 
-        self.application_controller.set_scan_range(vmin, vmax)
+        self.application_controller.set_scan_range(vstart, vend)
         self.application_controller.step_size = step_size
+        self.application_controller.tmax = n_scans
         if isinstance(self.application_controller, plescanner.CounterAndScanner):
-            self.application_controller.set_num_data_samples_per_batch(N)
+            self.application_controller.set_num_data_samples_per_batch(n_sample_size)
 
         try:
             self.application_controller.reset()  # clears the data
             self.application_controller.start()  # starts the DAQ
-            self.application_controller.set_to_starting_position()  # moves the stage to starting position
+            self.application_controller.set_to_starting_voltage()  # moves the stage to starting voltage
 
             while self.application_controller.still_scanning():
-                self.application_controller.scan_v()
+                self.application_controller.scan_voltage()
                 self.view.scan_view.update(self.application_controller)
                 self.view.canvas.draw()
 
@@ -272,10 +269,7 @@ def scan_thread_function(self, vmin, vmax, step_size, N) -> None:
             logger.info(
                 'Check for other applications using resources. If not, you may need to restart the application.')
 
-        self.view.sidepanel.start_button['state'] = 'normal'
-        self.view.sidepanel.goto_button['state'] = 'normal'
-        self.view.sidepanel.controller_menu.config(state=tk.NORMAL)
-        self.view.sidepanel.save_scan_button.config(state=tk.NORMAL)
+        self.enable_buttons()
 
     def save_scan(self, event = None):
         myformats = [('Compressed Numpy MultiArray', '*.npz'), ('Numpy Array (count rate only)', '*.npy'), ('HDF5', '*.h5')]
@@ -304,7 +298,6 @@ def save_scan(self, event = None):
             for key, value in data.items():
                 h5file.create_dataset(key, data=value)
             h5file.close()
-        self.view.sidepanel.save_scan_button.config(state=tk.NORMAL)
 
     def configure_from_yaml(self, afile=None) -> None:
         """
@@ -338,7 +331,7 @@ def configure_from_yaml(self, afile=None) -> None:
                 module = importlib.import_module(daq_reader_config['import_path'])
                 logger.debug(f"loading {daq_reader_config['import_path']}")
                 cls = getattr(module, daq_reader_config['class_name'])
-                self.data_acquisition_models[daq_reader] = cls()
+                self.data_acquisition_models[daq_reader] = cls(logger.level)
                 self.data_acquisition_models[daq_reader].configure(daq_reader_config['configure'])
         wm_readers = self.app_config["readers"]["wm_readers"]
         if wm_readers is not None:
@@ -348,7 +341,7 @@ def configure_from_yaml(self, afile=None) -> None:
                 module = importlib.import_module(wm_reader_config['import_path'])
                 logger.debug(f"loading {wm_reader_config['import_path']}")
                 cls = getattr(module, wm_reader_config['class_name'])
-                self.data_acquisition_models[wm_reader] = cls()
+                self.data_acquisition_models[wm_reader] = cls(logger.level)
                 self.data_acquisition_models[wm_reader].configure(wm_reader_config['configure'])
         daq_controllers = self.app_config["controllers"]["daq_writers"]
         if daq_controllers is not None:
@@ -375,6 +368,18 @@ def load_controller_from_name(self, application_controller_name: str) -> None:
         yaml_path = importlib.resources.files(CONTROLLER_PATH).joinpath(STANDARD_CONTROLLERS[application_controller_name])
         self.configure_from_yaml(str(yaml_path))
 
+    def disable_buttons(self):
+        self.view.sidepanel.start_button['state'] = 'disabled'
+        self.view.sidepanel.goto_button['state'] = 'disabled'
+        self.view.sidepanel.controller_menu.config(state=tk.DISABLED)
+        self.view.sidepanel.save_scan_button.config(state=tk.DISABLED)
+
+    def enable_buttons(self):
+        self.view.sidepanel.start_button['state'] = 'normal'
+        self.view.sidepanel.goto_button['state'] = 'normal'
+        self.view.sidepanel.controller_menu.config(state=tk.NORMAL)
+        self.view.sidepanel.save_scan_button.config(state=tk.NORMAL)
+
 def main() -> None:
     tkapp = MainTkApplication(DEFAULT_DAQ_DEVICE_NAME)
     tkapp.run()
diff --git a/src/qt3utils/datagenerators/plescanner.py b/src/qt3utils/datagenerators/plescanner.py
index 490f882a..518333e0 100644
--- a/src/qt3utils/datagenerators/plescanner.py
+++ b/src/qt3utils/datagenerators/plescanner.py
@@ -1,7 +1,13 @@
 import logging
-import numpy as np
 import time
 import tkinter as tk
+from typing import Type
+
+import numpy as np
+
+from qt3utils.applications.controllers.nidaqedgecounter import QT3ScopeNIDAQEdgeCounterController
+from qt3utils.applications.controllers.wavemeter_controller import WavemeterController
+from qt3utils.nidaq.customcontrollers import VControl
 
 logger = logging.getLogger(__name__)
 
@@ -11,84 +17,128 @@ class PleScanner:
     Override this class for specific types of PLE experiments
     """
 
-    def __init__(self, wavelength_controller):
+    def __init__(self, wavelength_controller: Type[VControl]):
+        """
+        self.running: boolean true when scan thread is running
+        self.current_frame: current pixel (or time) number in sweep
+        self.v_start: minimum allowed voltage for voltage controlling the laser wavelength
+        self.v_end: maximum allowe voltage for voltage controlling the laser wavelength
+        self.tmax: maximum number of pixels (or time) for sweep
+        self._step_size: size between voltage steps as it is swept
+        self.wavelength_controller: the voltage controller class instance
+        """
         self.running = False
-        self.current_t = 0
-        self.vmin = float(wavelength_controller.minimum_allowed_position)
-        self.vmax = float(wavelength_controller.maximum_allowed_position)
-        self.tmax = 100
-        self._step_size = 0.5
-        self.raster_line_pause = 0.150  # wait 150ms for the voltage to settle before a line scan
+        self.current_frame = 0
+        self.v_start = float(wavelength_controller.minimum_allowed_position)
+        self.v_end= float(wavelength_controller.maximum_allowed_position)
+        self.tmax = None
+        self._step_size = None
         self.wavelength_controller = wavelength_controller
-        self.num_daq_batches = 1  # could change to 10 if want 10x more samples for each position
 
     def stop(self) -> None:
+        """
+        stop running scan
+        """
         self.running = False
 
     def start(self) -> None:
+        """
+        start running scan
+        """
         self.running = True
 
-    def set_to_starting_position(self) -> None:
-        self.current_v = self.vmin
+    def set_to_starting_voltage(self) -> None:
+        """
+        Set the voltage to the original voltage start value
+        Does nothing if the wavelength controller is not initialized.
+        """
+        self.current_v = self.v_start
         if self.wavelength_controller:
-            self.wavelength_controller.go_to_voltage(v=self.vmin)
+            self.wavelength_controller.go_to_voltage(v=self.v_start)
 
     def close(self) -> None:
+        """
+        close connection to daq.
+        """
         pass
 
-    def set_scan_range(self, vmin, vmax) -> None:
+    def set_scan_range(self, v_start: float, v_end: float) -> None:
+        """
+        Set the voltage minimum and maximum for the PLE scan
+        """
         if self.wavelength_controller:
-            self.wavelength_controller.check_allowed_position(vmin)
-            self.wavelength_controller.check_allowed_position(vmax)
-        self.vmin = vmin
-        self.vmax = vmax
+            self.wavelength_controller.check_allowed_voltage(v_start)
+            self.wavelength_controller.check_allowed_voltage(v_end)
+        self.v_start = v_start
+        self.v_end = v_end
 
-    def get_scan_range(self) -> tuple:
+    def get_scan_range(self) -> tuple[float, float]:
         """
         Returns a tuple of the full scan range
-        :return: xmin, xmax, ymin, ymax
+        :return: v_start, v_end
         """
-        return self.vmin, self.vmax,
+        return self.v_start, self.v_end,
 
-    def get_completed_scan_range(self) -> tuple:
+    def get_completed_scan_range(self) -> tuple[float, float, float]:
         """
         Returns a tuple of the scan range that has been completed
-        :return: xmin, xmax, ymin, current_y
+        :return: starting voltage, ending voltage, voltage set at daq
         """
-        return self.vmin, self.vmax, self.current_v
+        return self.v_start, self.v_end, self.current_v
 
     def still_scanning(self) -> None:
+        """
+        Return boolean to determine of the scan should continue
+        returning True means the scan should continue
+        returning False means the scan should stop
+        """
         if self.running == False:  # this allows external process to stop scan
             return False
 
-        if self.current_t <= self.tmax:  # stops scan when reaches final position
+        if self.current_frame <= self.tmax:  # stops scan when reaches final position
             return True
         else:
             self.running = False
             return False
 
     def move_v(self) -> None:
+        """
+        Move the voltage one _step_size from current voltage towards maximum voltage
+        """
         self.current_v += self._step_size
-        if self.wavelength_controller and self.current_v <= self.vmax:
+        if self.wavelength_controller and self.current_v <= self.v_end:
             try:
                 self.wavelength_controller.go_to_position(v=self.current_v)
             except ValueError as e:
                 logger.info(f'out of range\n\n{e}')
 
-    def go_to_v(self, desired_voltage) -> None:
-        if self.wavelength_controller and desired_voltage <= self.vmax and desired_voltage >= self.vmin:
+    def go_to_voltage(self, desired_voltage: float) -> None:
+        """
+        Set the wavelength controller to set the daq to a desired voltage
+        """
+        if self.wavelength_controller and desired_voltage <= self.v_end and desired_voltage >= self.v_start:
             try:
-                self.wavelength_controller.go_to_voltage(v=desired_voltage)
+                self.wavelength_controller.go_to_voltage(voltage=desired_voltage)
             except ValueError as e:
                 logger.info(f'out of range\n\n{e}')
 
-    def scan_v(self) -> None:
+    def scan_voltage(self) -> None:
+        """
+        Scans the wavelengths from v_start to v_end in steps of step_size.
+        """
         pass
 
-    def scan_axis(self, axis, min, max, step_size) -> list:
+    def scan_axis(self, axis: str, min: float, max: float, step_size: float) -> list:
+        """
+        Moves the voltage from min to max in steps of step_size.
+        Returns data
+        """
         pass
 
     def reset(self) -> None:
+        """
+        Reset all data from scans
+        """
         pass
 
     def configure_view(self, gui_root: tk.Toplevel) -> None:
@@ -102,8 +152,8 @@ def step_size(self):
         return self._step_size
 
     @step_size.setter
-    def step_size(self, val):
-        self._step_size = val
+    def step_size(self, value: float):
+        self._step_size = value
 
 
 class CounterAndScanner(PleScanner):
@@ -111,53 +161,75 @@ class CounterAndScanner(PleScanner):
     Inherits from PleScanner base class
     Adds a rate counter for the SPCM and correlates counts with scans
     """
-    def __init__(self, rate_counter, wavelength_controller) -> None:
+    def __init__(self, rate_counter: Type[QT3ScopeNIDAQEdgeCounterController], wavelength_controller: Type[VControl]) -> None:
+        """
+        self.scanned_raw_counts: raw counts in scan
+        selfscanned_count_rate: counts summed according to number of counts per batch
+        self.rate_counter: class instance for counting from the SPCM
+        """
         super(CounterAndScanner, self).__init__(wavelength_controller)
         self.scanned_raw_counts = []
         self.scanned_count_rate = []
         self.rate_counter = rate_counter
 
     def stop(self) -> None:
+        """
+        stop scan
+        """
+        super().stop()
         self.rate_counter.stop()
-        self.running = False
 
     def start(self) -> None:
-        self.running = True
+        """
+        start scan
+        """
+        super().start()
         self.rate_counter.start()
 
     def close(self) -> None:
+        """
+        close connection to daq
+        """
         self.rate_counter.close()
 
-    def set_num_data_samples_per_batch(self, N) -> None:
+    def set_num_data_samples_per_batch(self, N: int) -> None:
+        """
+        Set the number of data samples per batch
+        """
         self.rate_counter.num_data_samples_per_batch = N
 
     def sample_counts(self) -> np.ndarray:
-        return self.rate_counter.sample_counts(self.num_daq_batches)
+        """
+        Get the counts for a batch by sampling the counts from the rate_counter class
+        """
+        return self.rate_counter.sample_counts(self.rate_counter.num_data_samples_per_batch)
 
     def sample_count_rate(self, data_counts=None) -> np.floating:
+        """
+        Sum the counts in a batch
+        """
         if data_counts is None:
             data_counts = self.sample_counts()
         return self.rate_counter.sample_count_rate(data_counts)
 
-    def scan_v(self) -> None:
+    def scan_voltage(self) -> None:
         """
-        Scans the wavelengths from vmin to vmax in steps of step_size.
+        Scans the wavelengths from v_start to v_end in steps of step_size.
 
         Stores results in self.scanned_raw_counts and self.scanned_count_rate.
         """
-        raw_counts_for_axis = self.scan_axis('v', self.vmin, self.vmax, self._step_size)
+        raw_counts_for_axis = self.scan_axis('voltage', self.v_start, self.v_end, self._step_size)
         self.scanned_raw_counts.append(raw_counts_for_axis)
         self.scanned_count_rate.append([self.sample_count_rate(raw_counts) for raw_counts in raw_counts_for_axis])
-        self.current_t = self.current_t + 1
+        self.current_frame = self.current_frame + 1
 
     def scan_axis(self, axis, min, max, step_size) -> list:
         """
         Moves the voltage from min to max in steps of step_size.
-        Returns a list of raw counts from the scan in the shape
+        Returns a list of raw counts from the scan
         """
         raw_counts = []
         self.wavelength_controller.go_to_voltage(**{axis: min})
-        time.sleep(self.raster_line_pause)
         for val in np.arange(min, max, step_size):
             if self.wavelength_controller:
                 logger.info(f'go to voltage {axis}: {val:.2f}')
@@ -180,21 +252,27 @@ class WavemeterAndScanner(PleScanner):
     Inherits from PleScanner base class
     Adds a wavemeter and daq readings to the correlated voltage sweeps
     """
-    def __init__(self, wm_reader, v_readers, wavelength_controller):
+    def __init__(self, wm_reader: Type[WavemeterController], v_readers: Type[VControl], wavelength_controller: Type[VControl]):
+        """
+        self.wm_reader: Wavemeter Controller instance
+        self.v_readers: instances of voltage readers from the daq
+        self.scanned_count_rate: data from voltage readers per pause per scan
+        self.scanned_wm: data from wavemeter per pause per scan
+        """
         super(WavemeterAndScanner, self).__init__(wavelength_controller)
         self.wm_reader = wm_reader
         self.v_readers = v_readers
         self.scanned_count_rate = []
         self.scanned_wm = []
 
-    def scan_v(self) -> None:
+    def scan_voltage(self) -> None:
         """
-        Scans the wavelengths from vmin to vmax in steps of step_size.
+        Scans the wavelengths from v_start to v_end in steps of step_size.
         """
-        _wm_scan, _vs_scan = self.scan_axis('v', self.vmin, self.vmax, self._step_size)
+        _wm_scan, _vs_scan = self.scan_axis('v', self.v_start, self.v_end, self._step_size)
         self.scanned_wm.append(_wm_scan)
         self.scanned_count_rate.append(_vs_scan)
-        self.current_t = self.current_t + 1
+        self.current_frame = self.current_frame + 1
 
     def read_wavemeter(self) -> float:
         """
@@ -202,7 +280,7 @@ def read_wavemeter(self) -> float:
         """
         return self.wm_reader.read_wavemeter()
 
-    def scan_axis(self, axis, min, max, step_size) -> list:
+    def scan_axis(self, axis: str, min: float, max: float, step_size: float) -> tuple[list[float], list[float]]:
         """
         Moves the voltage from min to max in steps of step_size.
         Returns a list of readings from the wave meter and DAQ for each scan
@@ -212,10 +290,10 @@ def scan_axis(self, axis, min, max, step_size) -> list:
         for v_reader in self.v_readers:
             vs_scans[v_reader.read_channel] = []
         self.wavelength_controller.go_to_voltage(**{axis: min})
-        time.sleep(self.raster_line_pause)
         for val in np.arange(min, max, step_size):
             if self.wavelength_controller:
-                logger.info(f'go to voltage {axis}: {val:.2f}')
+                log_sigfig = str(step_size)[::-1].find('.')
+                logger.info(f'go to voltage {axis}: {val:.{log_sigfig}f}')
                 self.wavelength_controller.go_to_voltage(**{axis: val})
             _wm_reading = self.read_wavemeter()
             wm_scan.append(_wm_reading)
@@ -237,7 +315,7 @@ def GetApplicationControllerInstance(classtype, readers: dict, controllers: dict
     controllers : dict
         - dict of controllers this class uses. This will always be a VControl class
     """
-    if classtype == WavemeterAndScanner:
+    if issubclass(classtype, WavemeterAndScanner):
         return classtype(list(readers.values())[-1], list(readers.values())[0:-1], list(controllers.values())[0])
     elif classtype == CounterAndScanner:
         return classtype(list(readers.values())[0], list(controllers.values())[0])
diff --git a/src/qt3utils/nidaq/customcontrollers.py b/src/qt3utils/nidaq/customcontrollers.py
index fadd82b6..da7695d4 100644
--- a/src/qt3utils/nidaq/customcontrollers.py
+++ b/src/qt3utils/nidaq/customcontrollers.py
@@ -3,27 +3,31 @@
 import time
 
 logger = logging.getLogger(__name__)
+
 class VControl():
     """
     Class for interfacing with DAQ hardware with the express purpose of
     controlling and/or reading the voltage at the DAQ that sets the wavelength of a laser
     """
 
-    def __init__(self, device_name: str = "",
+    def __init__(self,
+                 logger_level,
+                 device_name: str = "",
                  write_channel: str = 'ao0',
                  read_channel: str = None,
                  scale_nm_per_volt: float = 8,
                  move_settle_time: float = 0.001,
-                 min_position: float = 0.0,
-                 max_position: float = 80.0) -> None:
-        super().__init__()
+                 min_voltage: float = 0.0,
+                 max_voltage: float = 80.0) -> None:
+        self.logger = logging.getLogger(__name__)
+        self.logger.setLevel(logger_level)
 
         self.device_name = device_name
         self.write_channel = write_channel
         self.read_channel = read_channel
         self.scale_nm_per_volt = scale_nm_per_volt
-        self.minimum_allowed_position = min_position
-        self.maximum_allowed_position = max_position
+        self.minimum_allowed_voltage = min_voltage
+        self.maximum_allowed_voltage = max_voltage
         self._settling_time_in_seconds = move_settle_time  # 10 millisecond settle time
         self.last_write_value = None
 
@@ -32,7 +36,7 @@ def __init__(self, device_name: str = "",
     def go_to_voltage(self, voltage: float = None) -> None:
         '''
         Sets the voltage
-        raises ValueError if try to set position out of bounds.
+        raises ValueError if try to set voltage out of bounds.
         '''
         debug_string = []
         if voltage is not None:
@@ -43,24 +47,20 @@ def go_to_voltage(self, voltage: float = None) -> None:
                 self.last_write_value = voltage
             debug_string.append(f'voltage: {voltage:.2f}')
         logger.info(f'go to voltage {" ".join(debug_string)}')
-        time.sleep(self.settling_time_in_seconds)  # wait to ensure piezo actuator has settled into position.
+        time.sleep(self.settling_time_in_seconds)  # wait to ensure piezo actuator has settled into voltage.
         logger.debug(f'last write: {self.last_write_value}')
 
     def get_current_voltage(self) -> float:
         '''
         Returns the voltage supplied to the three input analog channels.
-
         If no input analog channels were provided when objected was created,
-        returns [-1,-1,-1]
+        returns none
         '''
-        output = -1
+        output = None
         if self.read_channel is not None:
             with nidaqmx.Task() as vread, nidaqmx.Task():
-
-                vread.ai_channels.add_ai_voltage_chan(self.device_name + '/' + self.read_channel, min_val=0, max_val=10.0)
-
+                vread.ai_channels.add_ai_voltage_chan(f"{self.device_name}/{self.read_channel}")
                 output = vread.read()
-
         return output
 
     def configure(self, config_dict: dict) -> None:
@@ -71,28 +71,29 @@ def configure(self, config_dict: dict) -> None:
         self.write_channel = config_dict.get('write_channels', self.write_channel)
         self.read_channel = config_dict.get('read_channels', self.read_channel)
         self.scale_nm_per_volt = config_dict.get('scale_nm_per_volt', self.scale_nm_per_volt)
-        self.minimum_allowed_position = config_dict.get('min_position', self.minimum_allowed_position)
-        self.maximum_allowed_position = config_dict.get('max_position', self.maximum_allowed_position)
+        self.minimum_allowed_voltage = config_dict.get('min_voltage', self.minimum_allowed_voltage)
+        self.maximum_allowed_voltage = config_dict.get('max_voltage', self.maximum_allowed_voltage)
 
-    def check_allowed_position(self, v: float = None) -> None:
-        if v is not None: self._validate_value(v)
+    def check_allowed_voltage(self, voltage: float = None) -> None:
+        if voltage is not None: self._validate_value(voltage)
 
     def _validate_value(self, voltage: float) -> None:
         voltage = float(voltage)
-        if type(voltage) not in [type(1.0), type(1)]:
+        if not isinstance(voltage, (float, int)):
             raise TypeError(f'value {voltage} is not a valid type.')
-        if voltage < self.minimum_allowed_position:
-            raise ValueError(f'value {voltage} is less than {self.minimum_allowed_position: .3f}.')
-        if voltage > self.maximum_allowed_position:
-            raise ValueError(f'value {voltage} is greater than {self.maximum_allowed_position: .3f}.')
+        if voltage < self.minimum_allowed_voltage:
+            raise ValueError(f'value {voltage} is less than {self.minimum_allowed_voltage: .3f}.')
+        if voltage > self.maximum_allowed_voltage:
+            raise ValueError(f'value {voltage} is greater than {self.maximum_allowed_voltage: .3f}.')
     def _nm_to_volts(self, nm: float) -> float:
         return nm / self.scale_nm_per_volt
 
     def _volts_to_nm(self, volts: float) -> float:
         return self.scale_nm_per_volt * volts
+
     @property
     def settling_time_in_seconds (self):
         return self._settling_time_in_seconds
     @settling_time_in_seconds.setter
-    def settling_time_in_seconds (self, val):
-        self._settling_time_in_seconds = val
+    def settling_time_in_seconds (self, value):
+        self._settling_time_in_seconds = value

From 7f2158677602fe78677323ab82dfcb0b6ffb33dd Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Thu, 22 Feb 2024 16:50:00 -0800
Subject: [PATCH 26/32] Generalized plescanner to run any number of readers
 based on YAML file

---
 .../controllers/nidaq_wm_ple.yaml             |   4 +-
 .../controllers/nidaqedgecounter.py           |   1 +
 src/qt3utils/applications/qt3ple/main.py      | 101 ++++---
 src/qt3utils/datagenerators/plescanner.py     | 278 ++++++------------
 src/qt3utils/nidaq/customcontrollers.py       |   7 +-
 5 files changed, 150 insertions(+), 241 deletions(-)

diff --git a/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml b/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
index fb2b51cb..d03b9477 100644
--- a/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
+++ b/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
@@ -3,9 +3,7 @@ QT3PLE:
     import_path : qt3utils.datagenerators.plescanner
     class_name : WavemeterAndScanner
     configure :
-      controllers:
-        daq_writers:
-          daq_writer : VoltageController
+      controller: VoltageController
       readers :
         daq_readers:
           daq_reader : DAQReader
diff --git a/src/qt3utils/applications/controllers/nidaqedgecounter.py b/src/qt3utils/applications/controllers/nidaqedgecounter.py
index 7703d42c..11589339 100644
--- a/src/qt3utils/applications/controllers/nidaqedgecounter.py
+++ b/src/qt3utils/applications/controllers/nidaqedgecounter.py
@@ -158,3 +158,4 @@ def num_data_samples_per_batch(self) -> int:
     @num_data_samples_per_batch.setter
     def num_data_samples_per_batch(self, value: int):
         self.data_generator.num_data_samples_per_batch = value
+
diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index 6b5b4a5c..38decc2a 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -6,6 +6,7 @@
 from threading import Thread
 
 import matplotlib
+from matplotlib import gridspec
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
 import matplotlib.pyplot as plt
 import nidaqmx
@@ -36,43 +37,64 @@
 
 DEFAULT_DAQ_DEVICE_NAME = NIDAQ_DEVICE_NAMES[0]
 
-CONTROLLER_PATH = 'qt3utils.applications.controllers'
+CONTROLLER_PATH = 'qt3utils.applications.controller'
 STANDARD_CONTROLLERS = {NIDAQ_DEVICE_NAMES[0] : 'nidaq_rate_counter.yaml',
                         NIDAQ_DEVICE_NAMES[1] : 'nidaq_wm_ple.yaml'}
 
 class ScanImage:
     def __init__(self, mplcolormap='gray') -> None:
-        self.fig, self.ax = plt.subplots()
+        self.fig = plt.figure()
+        self.ax = plt.gca()
         self.cbar = None
         self.cmap = mplcolormap
         self.cid = self.fig.canvas.mpl_connect('button_press_event', self.onclick)
-        self.ax.set_xlabel('Voltage')
         self.log_data = False
 
-    def update(self, model) -> None:
+    def fill_subplot(self, x, y):
+        if self.ax is None:
+            self.ax = plt.gca()
+        sub_plt = self.ax.plot(x, y)
+        return sub_plt
 
-        if self.log_data:
-            data = np.log10(model.scanned_count_rate)
-            data[np.isinf(data)] = 0  # protect against +-inf
-        else:
-            data = model.scanned_count_rate
-        data = np.array(data).T.tolist()
-
-        self.artist = self.ax.imshow(data, cmap=self.cmap, extent=[model.current_frame + model.raster_line_pause,
-                                                                   0,
-                                                                   model.vstart,
-                                                                   model.vend + model.step_size
-                                                                   ])
-        if self.cbar is None:
-            self.cbar = self.fig.colorbar(self.artist, ax=self.ax)
-        else:
-            self.cbar.update_normal(self.artist)
+    def update_image_and_plot(self, model) -> None:
+        num_readers = len(model.readers)
+        grid = plt.GridSpec(2, num_readers)
+        self.update_image(model, grid)
+        self.update_plot(model, grid)
+
+
+    def update_image(self, model, grid) -> None:
+        for ii, reader in enumerate(model.readers):
+
+            if self.log_data:
+                data = np.log10(model.scanned_count_rate)
+                data[np.isinf(data)] = 0  # protect against +-inf
+            else:
+                data = model.scanned_count_rate
+            data = np.array(data).T.tolist()
 
-        if self.log_data is False:
-            self.cbar.formatter.set_powerlimits((0, 3))
+            artist = self.ax.imshow(data, plt.subplot(grid[0, ii]), cmap=self.cmap)
+                                   # , extent=[model.current_frame + model.raster_line_pause,
+                                   #                                    0,
+                                   #                                    model.vstart,
+                                   #                                    model.vend + model.step_size]
+            if self.cbar is None:
+                self.cbar = self.fig.colorbar(artist, ax=self.ax)
+            else:
+                self.cbar.update_normal(artist)
 
-        self.ax.set_xlabel('Pixels')
-        self.ax.set_ylabel('Voltage (V)')
+            if self.log_data is False:
+                self.cbar.formatter.set_powerlimits((0, 3))
+
+            self.ax.set_xlabel('Pixels')
+            self.ax.set_ylabel('Voltage (V)')
+
+    def update_plot(self, model, grid) -> None:
+
+        for ii, reader in enumerate(model.readers):
+            y_data = model.readers[reader]
+            x_control = model.scanned_control
+            self.ax.plot(x_control, y_data, plt.subplot(grid[1, ii]), color='k', linewidth=1.5)
 
     def reset(self) -> None:
         self.ax.cla()
@@ -249,17 +271,14 @@ def scan_thread_function(self, vstart: float, vend: float, step_size: float, n_s
         self.application_controller.set_scan_range(vstart, vend)
         self.application_controller.step_size = step_size
         self.application_controller.tmax = n_scans
-        if isinstance(self.application_controller, plescanner.CounterAndScanner):
-            self.application_controller.set_num_data_samples_per_batch(n_sample_size)
-
         try:
             self.application_controller.reset()  # clears the data
             self.application_controller.start()  # starts the DAQ
             self.application_controller.set_to_starting_voltage()  # moves the stage to starting voltage
 
             while self.application_controller.still_scanning():
-                self.application_controller.scan_voltage()
-                self.view.scan_view.update(self.application_controller)
+                self.application_controller.scan_wavelengths()
+                self.view.scan_view.update_image_and_plot(self.application_controller)
                 self.view.canvas.draw()
 
             self.application_controller.stop()
@@ -343,20 +362,16 @@ def configure_from_yaml(self, afile=None) -> None:
                 cls = getattr(module, wm_reader_config['class_name'])
                 self.data_acquisition_models[wm_reader] = cls(logger.level)
                 self.data_acquisition_models[wm_reader].configure(wm_reader_config['configure'])
-        daq_controllers = self.app_config["controllers"]["daq_writers"]
-        if daq_controllers is not None:
-            for daq_controller in daq_controllers:
-                daq_controller_name = daq_controllers[daq_controller]
-                daq_controller_config = config[CONFIG_FILE_APPLICATION_NAME][daq_controller_name]
-                module = importlib.import_module(daq_controller_config['import_path'])
-                logger.debug(f"loading {daq_controller_config['import_path']}")
-                cls = getattr(module, daq_controller_config['class_name'])
-                self.controller_models[daq_controller] = cls(logger.level)
-                self.controller_models[daq_controller].configure(daq_controller_config['configure'])
-        app_module = importlib.import_module(self.app_controller_config['import_path'])
-        logger.debug(f"loading {self.app_controller_config['import_path']}")
-        app_cls = getattr(app_module, self.app_controller_config["class_name"])
-        self.application_controller = plescanner.GetApplicationControllerInstance(app_cls, self.data_acquisition_models, self.controller_models)
+        daq_controller_config = config[CONFIG_FILE_APPLICATION_NAME]
+        if daq_controller_config is not None:
+            module = importlib.import_module(daq_controller_config['import_path'])
+            logger.debug(f"loading {daq_controller_config['import_path']}")
+            cls = getattr(module, daq_controller_config['class_name'])
+            controller_model = cls(logger.level)
+            controller_model.configure(daq_controller_config['configure'])
+        else:
+           raise Exception("Yaml configuration file must have a controller for PLE scan.")
+        self.application_controller = plescanner.PleScanner(self.data_acquisition_models, controller_model)
 
     def load_controller_from_name(self, application_controller_name: str) -> None:
         """
diff --git a/src/qt3utils/datagenerators/plescanner.py b/src/qt3utils/datagenerators/plescanner.py
index 518333e0..110c6cfa 100644
--- a/src/qt3utils/datagenerators/plescanner.py
+++ b/src/qt3utils/datagenerators/plescanner.py
@@ -5,7 +5,7 @@
 
 import numpy as np
 
-from qt3utils.applications.controllers.nidaqedgecounter import QT3ScopeNIDAQEdgeCounterController
+from qt3utils.applications.controllers.nidaqedgecounter import QT3ScanNIDAQEdgeCounterController
 from qt3utils.applications.controllers.wavemeter_controller import WavemeterController
 from qt3utils.nidaq.customcontrollers import VControl
 
@@ -17,44 +17,56 @@ class PleScanner:
     Override this class for specific types of PLE experiments
     """
 
-    def __init__(self, wavelength_controller: Type[VControl]):
+    def __init__(self, readers, wavelength_controller):
         """
         self.running: boolean true when scan thread is running
         self.current_frame: current pixel (or time) number in sweep
-        self.v_start: minimum allowed voltage for voltage controlling the laser wavelength
-        self.v_end: maximum allowe voltage for voltage controlling the laser wavelength
+        self._start: minimum allowed point for hardware controlling the laser wavelength
+        self._end: maximum allowed point for hardware controlling the laser wavelength
         self.tmax: maximum number of pixels (or time) for sweep
-        self._step_size: size between voltage steps as it is swept
-        self.wavelength_controller: the voltage controller class instance
+        self._step_size: size between steps controlling wavelength as it is swept
+        self.wavelength_controller: the wavelength controller class instance
         """
         self.running = False
         self.current_frame = 0
-        self.v_start = float(wavelength_controller.minimum_allowed_position)
-        self.v_end= float(wavelength_controller.maximum_allowed_position)
+        self._start = float(wavelength_controller.minimum_allowed_position)
+        self._end= float(wavelength_controller.maximum_allowed_position)
         self.tmax = None
         self._step_size = None
         self.wavelength_controller = wavelength_controller
+        self.readers = readers
+        self.outputs = []
+        self.rate_counters = []
+        self.scanned_control = []
+        if isinstance(self.wavelength_controller, VControl):
+            self.axis_name = "Voltage"
+        else:
+            self.axis_name = "Wavelength"
 
     def stop(self) -> None:
         """
         stop running scan
         """
         self.running = False
+        for rate_counter in self.rate_counters:
+            rate_counter.stop()
 
     def start(self) -> None:
         """
         start running scan
         """
         self.running = True
+        for rate_counter in self.rate_counters:
+            rate_counter.start()
 
-    def set_to_starting_voltage(self) -> None:
+    def set_to_start(self) -> None:
         """
-        Set the voltage to the original voltage start value
+        Set the wavelength control to the original start value
         Does nothing if the wavelength controller is not initialized.
         """
-        self.current_v = self.v_start
+        self.current_wl_point = self._start
         if self.wavelength_controller:
-            self.wavelength_controller.go_to_voltage(v=self.v_start)
+            self.wavelength_controller.go_to(v=self._start)
 
     def close(self) -> None:
         """
@@ -62,31 +74,31 @@ def close(self) -> None:
         """
         pass
 
-    def set_scan_range(self, v_start: float, v_end: float) -> None:
+    def set_scan_range(self, _start: float, _end: float) -> None:
         """
-        Set the voltage minimum and maximum for the PLE scan
+        Set the wavelength controller's minimum and maximum for the PLE scan
         """
         if self.wavelength_controller:
-            self.wavelength_controller.check_allowed_voltage(v_start)
-            self.wavelength_controller.check_allowed_voltage(v_end)
-        self.v_start = v_start
-        self.v_end = v_end
+            self.wavelength_controller.check_allowed_limits(_start)
+            self.wavelength_controller.check_allowed_limits(_end)
+        self._start = _start
+        self._end = _end
 
     def get_scan_range(self) -> tuple[float, float]:
         """
         Returns a tuple of the full scan range
-        :return: v_start, v_end
+        :return: _start, _end
         """
-        return self.v_start, self.v_end,
+        return self._start, self._end,
 
     def get_completed_scan_range(self) -> tuple[float, float, float]:
         """
         Returns a tuple of the scan range that has been completed
-        :return: starting voltage, ending voltage, voltage set at daq
+        :return: starting and ending points of wavelength contrl, as well as current point in run
         """
-        return self.v_start, self.v_end, self.current_v
+        return self._start, self._end, self.current_wl_point
 
-    def still_scanning(self) -> None:
+    def still_scanning(self) -> bool:
         """
         Return boolean to determine of the scan should continue
         returning True means the scan should continue
@@ -101,39 +113,72 @@ def still_scanning(self) -> None:
             self.running = False
             return False
 
-    def move_v(self) -> None:
+    def increment_wl(self) -> None:
         """
-        Move the voltage one _step_size from current voltage towards maximum voltage
+        Move the wavelength control one _step_size towards maximum
         """
-        self.current_v += self._step_size
-        if self.wavelength_controller and self.current_v <= self.v_end:
+        self.current_wl_point += self._step_size
+        if self.wavelength_controller and self.current_wl_point <= self._end:
             try:
-                self.wavelength_controller.go_to_position(v=self.current_v)
+                self.wavelength_controller.go_to(v=self.current_wl_point)
             except ValueError as e:
                 logger.info(f'out of range\n\n{e}')
 
-    def go_to_voltage(self, desired_voltage: float) -> None:
+    def go_to(self, wl_point: float) -> None:
         """
-        Set the wavelength controller to set the daq to a desired voltage
+        Set the wavelength controller to desired point
         """
-        if self.wavelength_controller and desired_voltage <= self.v_end and desired_voltage >= self.v_start:
+        if self.wavelength_controller and wl_point <= self._end and wl_point >= self._start:
             try:
-                self.wavelength_controller.go_to_voltage(voltage=desired_voltage)
+                self.wavelength_controller.go_to(wl_point=wl_point)
             except ValueError as e:
                 logger.info(f'out of range\n\n{e}')
 
-    def scan_voltage(self) -> None:
+    def scan_wavelengths(self) -> None:
         """
         Scans the wavelengths from v_start to v_end in steps of step_size.
+        Records the output from the readers into a list of dictionaries
         """
-        pass
+        self.outputs.append(self.scan_axis(self.axis_name, self._start, self._end, self._step_size))
+        self.current_frame = self.current_frame + 1
 
     def scan_axis(self, axis: str, min: float, max: float, step_size: float) -> list:
         """
-        Moves the voltage from min to max in steps of step_size.
-        Returns data
+        Moves the wavelength controller from min to max in steps of step_size.
+        Returns data in the form of a dictionary with
+            keys = name of reader defined in YAML file
+            values = output of scan
+        As well as an array of the points associated with the scan
+        """
+        output = {key: [] for key in self.readers.keys}
+        self.wavelength_controller.go_to_wl_point(**{axis: min})
+        self.scanned_control.append(self.wavelength_controller.geta_current_wl_point())
+        for reader in self.readers:
+            if isinstance(reader, QT3ScanNIDAQEdgeCounterController ):
+                self.rate_counters.append(self.readers[reader])
+                raw_counts = []
+                _raw_counts = self.sample_counts(self.readers[reader])
+                raw_counts.append(_raw_counts)
+                logger.info(f'raw counts, total clock samples: {_raw_counts}')
+                if self.wavelength_controller:
+                    logger.info(f'current {self.axis_name}: {self.wavelength_controller.get_current_wl_point()}')
+                raw_counts.append(_raw_counts)
+                output[reader].append(self.sample_count_rate(raw_counts))
+            if isinstance(reader, WavemeterController):
+                _wm_reading = self.read_wavemeter(self.readers[reader])
+                output[reader].append(_wm_reading)
+                if self.wavelength_controller:
+                    logger.info(f'current {self.axis_name}: {self.wavelength_controller.get_current_wl_point()}')
+            if isinstance(reader, VControl):
+                v_reading = self.readers[reader].get_current_wl_point()
+                output[reader].append(v_reading)
+        return output
+
+    def sample_counts(self, reader) -> np.ndarray:
         """
-        pass
+        Get the counts for a batch by sampling the counts from the rate_counter class
+        """
+        return reader.sample_counts(reader.num_data_samples_per_batch)
 
     def reset(self) -> None:
         """
@@ -155,167 +200,16 @@ def step_size(self):
     def step_size(self, value: float):
         self._step_size = value
 
-
-class CounterAndScanner(PleScanner):
-    """
-    Inherits from PleScanner base class
-    Adds a rate counter for the SPCM and correlates counts with scans
-    """
-    def __init__(self, rate_counter: Type[QT3ScopeNIDAQEdgeCounterController], wavelength_controller: Type[VControl]) -> None:
-        """
-        self.scanned_raw_counts: raw counts in scan
-        selfscanned_count_rate: counts summed according to number of counts per batch
-        self.rate_counter: class instance for counting from the SPCM
-        """
-        super(CounterAndScanner, self).__init__(wavelength_controller)
-        self.scanned_raw_counts = []
-        self.scanned_count_rate = []
-        self.rate_counter = rate_counter
-
-    def stop(self) -> None:
-        """
-        stop scan
-        """
-        super().stop()
-        self.rate_counter.stop()
-
-    def start(self) -> None:
-        """
-        start scan
-        """
-        super().start()
-        self.rate_counter.start()
-
-    def close(self) -> None:
-        """
-        close connection to daq
-        """
-        self.rate_counter.close()
-
-    def set_num_data_samples_per_batch(self, N: int) -> None:
-        """
-        Set the number of data samples per batch
-        """
-        self.rate_counter.num_data_samples_per_batch = N
-
-    def sample_counts(self) -> np.ndarray:
-        """
-        Get the counts for a batch by sampling the counts from the rate_counter class
-        """
-        return self.rate_counter.sample_counts(self.rate_counter.num_data_samples_per_batch)
-
-    def sample_count_rate(self, data_counts=None) -> np.floating:
+    def sample_count_rate(self, rate_counter, data_counts=None) -> np.floating:
         """
         Sum the counts in a batch
         """
         if data_counts is None:
             data_counts = self.sample_counts()
-        return self.rate_counter.sample_count_rate(data_counts)
+        return rate_counter.sample_count_rate(data_counts)
 
-    def scan_voltage(self) -> None:
-        """
-        Scans the wavelengths from v_start to v_end in steps of step_size.
-
-        Stores results in self.scanned_raw_counts and self.scanned_count_rate.
-        """
-        raw_counts_for_axis = self.scan_axis('voltage', self.v_start, self.v_end, self._step_size)
-        self.scanned_raw_counts.append(raw_counts_for_axis)
-        self.scanned_count_rate.append([self.sample_count_rate(raw_counts) for raw_counts in raw_counts_for_axis])
-        self.current_frame = self.current_frame + 1
-
-    def scan_axis(self, axis, min, max, step_size) -> list:
-        """
-        Moves the voltage from min to max in steps of step_size.
-        Returns a list of raw counts from the scan
-        """
-        raw_counts = []
-        self.wavelength_controller.go_to_voltage(**{axis: min})
-        for val in np.arange(min, max, step_size):
-            if self.wavelength_controller:
-                logger.info(f'go to voltage {axis}: {val:.2f}')
-                self.wavelength_controller.go_to_voltage(**{axis: val})
-            _raw_counts = self.sample_counts()
-            raw_counts.append(_raw_counts)
-            logger.info(f'raw counts, total clock samples: {_raw_counts}')
-            if self.wavelength_controller:
-                logger.info(f'current voltage: {self.wavelength_controller.get_current_voltage()}')
-
-        return raw_counts
-
-    def reset(self) -> None:
-        self.scanned_raw_counts = []
-        self.scanned_count_rate = []
-
-
-class WavemeterAndScanner(PleScanner):
-    """
-    Inherits from PleScanner base class
-    Adds a wavemeter and daq readings to the correlated voltage sweeps
-    """
-    def __init__(self, wm_reader: Type[WavemeterController], v_readers: Type[VControl], wavelength_controller: Type[VControl]):
-        """
-        self.wm_reader: Wavemeter Controller instance
-        self.v_readers: instances of voltage readers from the daq
-        self.scanned_count_rate: data from voltage readers per pause per scan
-        self.scanned_wm: data from wavemeter per pause per scan
-        """
-        super(WavemeterAndScanner, self).__init__(wavelength_controller)
-        self.wm_reader = wm_reader
-        self.v_readers = v_readers
-        self.scanned_count_rate = []
-        self.scanned_wm = []
-
-    def scan_voltage(self) -> None:
-        """
-        Scans the wavelengths from v_start to v_end in steps of step_size.
-        """
-        _wm_scan, _vs_scan = self.scan_axis('v', self.v_start, self.v_end, self._step_size)
-        self.scanned_wm.append(_wm_scan)
-        self.scanned_count_rate.append(_vs_scan)
-        self.current_frame = self.current_frame + 1
-
-    def read_wavemeter(self) -> float:
+    def read_wavemeter(self, wm_reader) -> float:
         """
         Returns the reading from the wavemeter
         """
-        return self.wm_reader.read_wavemeter()
-
-    def scan_axis(self, axis: str, min: float, max: float, step_size: float) -> tuple[list[float], list[float]]:
-        """
-        Moves the voltage from min to max in steps of step_size.
-        Returns a list of readings from the wave meter and DAQ for each scan
-        """
-        wm_scan = []
-        vs_scans = {}
-        for v_reader in self.v_readers:
-            vs_scans[v_reader.read_channel] = []
-        self.wavelength_controller.go_to_voltage(**{axis: min})
-        for val in np.arange(min, max, step_size):
-            if self.wavelength_controller:
-                log_sigfig = str(step_size)[::-1].find('.')
-                logger.info(f'go to voltage {axis}: {val:.{log_sigfig}f}')
-                self.wavelength_controller.go_to_voltage(**{axis: val})
-            _wm_reading = self.read_wavemeter()
-            wm_scan.append(_wm_reading)
-            if self.wavelength_controller:
-                logger.info(f'current voltage: {self.wavelength_controller.get_current_voltage()}')
-            for v_reader in self.v_readers:
-                v_reading = v_reader.get_current_voltage()
-                vs_scans[v_reader.read_channel].append(v_reading)
-        return wm_scan, vs_scans
-
-
-def GetApplicationControllerInstance(classtype, readers: dict, controllers: dict):
-    """
-    Create an instance of the application controller depending on the type
-    classtype : class
-        - either WavemeterAndScanner or CounterAndScanner
-    readers : dict
-        - dict of readers this class uses. For WaveMeterAndScanner, wavemeter is first, then DAQs
-    controllers : dict
-        - dict of controllers this class uses. This will always be a VControl class
-    """
-    if issubclass(classtype, WavemeterAndScanner):
-        return classtype(list(readers.values())[-1], list(readers.values())[0:-1], list(controllers.values())[0])
-    elif classtype == CounterAndScanner:
-        return classtype(list(readers.values())[0], list(controllers.values())[0])
+        return wm_reader.read_wavemeter()
diff --git a/src/qt3utils/nidaq/customcontrollers.py b/src/qt3utils/nidaq/customcontrollers.py
index da7695d4..532b74fd 100644
--- a/src/qt3utils/nidaq/customcontrollers.py
+++ b/src/qt3utils/nidaq/customcontrollers.py
@@ -33,11 +33,12 @@ def __init__(self,
 
 
 
-    def go_to_voltage(self, voltage: float = None) -> None:
+    def go_to(self, wl_point: float = None) -> None:
         '''
         Sets the voltage
         raises ValueError if try to set voltage out of bounds.
         '''
+        voltage = wl_point
         debug_string = []
         if voltage is not None:
             self._validate_value(voltage)
@@ -50,7 +51,7 @@ def go_to_voltage(self, voltage: float = None) -> None:
         time.sleep(self.settling_time_in_seconds)  # wait to ensure piezo actuator has settled into voltage.
         logger.debug(f'last write: {self.last_write_value}')
 
-    def get_current_voltage(self) -> float:
+    def get_current_wl_point(self) -> float:
         '''
         Returns the voltage supplied to the three input analog channels.
         If no input analog channels were provided when objected was created,
@@ -74,7 +75,7 @@ def configure(self, config_dict: dict) -> None:
         self.minimum_allowed_voltage = config_dict.get('min_voltage', self.minimum_allowed_voltage)
         self.maximum_allowed_voltage = config_dict.get('max_voltage', self.maximum_allowed_voltage)
 
-    def check_allowed_voltage(self, voltage: float = None) -> None:
+    def check_allowed_limits(self, voltage: float = None) -> None:
         if voltage is not None: self._validate_value(voltage)
 
     def _validate_value(self, voltage: float) -> None:

From 0d4ef2f07beea0a719bb7b8b3b984387cf5f1f30 Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Fri, 23 Feb 2024 16:56:52 -0800
Subject: [PATCH 27/32] Added lockin controller

---
 .../controllers/lockin_controller.py          |  28 ++++
 .../controllers/nidaq_wm_ple.yaml             |  28 +---
 src/qt3utils/applications/qt3ple/main.py      |  50 +++++-
 src/qt3utils/datagenerators/plescanner.py     |   6 +
 src/qt3utils/nidaq/customcontrollers.py       | 158 ++++++++++++++++++
 5 files changed, 246 insertions(+), 24 deletions(-)
 create mode 100644 src/qt3utils/applications/controllers/lockin_controller.py

diff --git a/src/qt3utils/applications/controllers/lockin_controller.py b/src/qt3utils/applications/controllers/lockin_controller.py
new file mode 100644
index 00000000..55446f9d
--- /dev/null
+++ b/src/qt3utils/applications/controllers/lockin_controller.py
@@ -0,0 +1,28 @@
+import numpy as np
+
+import nidaqmx
+
+class Lockin:
+    def __init__(self, device_name: str, signal_channel: str, timeout: float) -> None:
+        self.device_name = device_name
+        self.signal_channel = signal_channel
+        self.sample_number = 20
+        self.rate = 20.0
+        self.timeout = timeout
+
+    def read(self) -> np.ndarray:
+        with nidaqmx.Task() as task:
+            task.ai_channels.add_ai_voltage_chan(self.device_name + '/' + self.signal_channel, max_val=10)
+            task.timing.cfg_samp_clk_timing(rate=self.rate, samps_per_chan=self.sample_number)
+            c = task.read(number_of_samples_per_channel=self.sample_number, timeout=self.timeout)
+        return np.array(c)
+
+def configure(self, config_dict: dict) -> None:
+    """
+    This method is used to configure the data controller.
+    """
+    self.device_name = config_dict.get('daq_name', self.device_name)
+    self.signal_channel = config_dict.get('signal_channels', self.signal_channel)
+    self.sample_number = config_dict.get('sample_number', self.sample_number)
+    self.rate = config_dict.get('rate', self.rate)
+    self.timeout = config_dict.get('timeout', self.timeout)
diff --git a/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml b/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
index d03b9477..0481bafd 100644
--- a/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
+++ b/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
@@ -12,34 +12,22 @@ QT3PLE:
           wm_reader : WavemeterDllController
 
   DAQReader:
-    import_path : qt3utils.nidaq.customcontrollers
-    class_name  : VControl
-    configure :
-      daq_name : Silicon_DAQ  # NI DAQ Device Name
-      write_channels : ao3 # NI DAQ analog output channels to use for writing position
-      read_channels : ai3  # NI DAQ analog input channels to use for reading position
-      min_position: -10  # conversion factor from volts to microns, can also supply a list [8,8,8] or [6,4.2,5]
-      max_position: 10  # the voltage value that defines the position 0,0,0, can also supply a list [0,0,0] or [5,5,5]
-      scale_nm_per_volt: 1  # microns
-
-  DAQReader2:
-    import_path : qt3utils.nidaq.customcontrollers
-    class_name  : VControl
+    import_path : qt3utils.applications.controllers.lockin_controller
+    class_name  : Lockin
     configure :
       daq_name : Silicon_DAQ # NI DAQ Device Name
-      write_channels : ao2 # NI DAQ analog output channels to use for writing position
-      read_channels : ai2  # NI DAQ analog input channels to use for reading position
-      min_position: -10  # conversion factor from volts to microns, can also supply a list [8,8,8] or [6,4.2,5]
-      max_position: 10  # the voltage value that defines the position 0,0,0, can also supply a list [0,0,0] or [5,5,5]
-      scale_nm_per_volt: 1  # microns
+      signal_channels : ai21  # NI DAQ analog input channels to use for reading position
+      sample_number: 20  # Specifies the sampling rate in samples per channel per second
+      rate: 20.0  #Specifies the number of samples to acquire or generate for each channel in the task
+      timeout: 20  # Specifies the amount of time in seconds to wait for samples to become available
 
   VoltageController:
     import_path : qt3utils.nidaq.customcontrollers
     class_name  : VControl
     configure :
       daq_name : Silicon_DAQ # NI DAQ Device Name
-      write_channels : ao0 # NI DAQ analog output channels to use for writing position
-      read_channels : ai0  # NI DAQ analog input channels to use for reading position
+      write_channels : ao3 # NI DAQ analog output channels to use for writing position
+      read_channels : ai3  # NI DAQ analog input channels to use for reading position
       min_position: -10  # conversion factor from volts to microns, can also supply a list [8,8,8] or [6,4.2,5]
       max_position: 10  # the voltage value that defines the position 0,0,0, can also supply a list [0,0,0] or [5,5,5]
       scale_nm_per_volt: 1  # microns
diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index 38decc2a..471c8b18 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -41,6 +41,8 @@
 STANDARD_CONTROLLERS = {NIDAQ_DEVICE_NAMES[0] : 'nidaq_rate_counter.yaml',
                         NIDAQ_DEVICE_NAMES[1] : 'nidaq_wm_ple.yaml'}
 
+SCAN_OPTIONS = ["Discrete", "Batches"]
+
 class ScanImage:
     def __init__(self, mplcolormap='gray') -> None:
         self.fig = plt.figure()
@@ -147,18 +149,39 @@ def __init__(self, root, scan_range) -> None:
         self.sweep_time_entry.insert(10, 3)
         self.sweep_time_entry.grid(row=row, column=1)
 
+        row += 1
+        tk.Label(frame, text="Downsweep Time").grid(row=row, column=0)
+        self.downsweep_time_entry = tk.Entry(frame, width=10)
+        self.downsweep_time_entry.insert(10, 1)
+        self.downsweep_time_entry.grid(row=row, column=1)
+
+        row += 1
+        tk.Label(frame, text="Mode").grid(row=row, column=0)
+        clicked = tk.StringVar()
+        clicked.set("Discrete")
+        self.scan_mode= tk.OptionMenu(frame, clicked, *SCAN_OPTIONS)
+        self.scan_mode.pack()
+
         row += 1
         tk.Label(frame, text="DAQ Settings", font='Helvetica 16').grid(row=row, column=0, pady=10)
 
         row += 1
         self.goto_button = tk.Button(frame, text="Go To Voltage")
         self.goto_button.grid(row=row, column=0)
+        self.goto_slow_button = tk.Button(frame, text="Slowly go to Voltage")
+        self.goto_slow_button.grid(row=row, column=1)
         row += 1
         tk.Label(frame, text="Voltage (V)").grid(row=row, column=0)
         self.voltage_entry = tk.Entry(frame, width=10)
         self.voltage_entry.insert(10, 0)
         self.voltage_entry.grid(row=row, column=1)
 
+        row += 1
+        self.get_button = tk.Button(frame, text="Get current Voltage")
+        self.get_button.grid(row=row, column=0)
+        self.voltage_show=tk.Label(frame, text='None')
+        self.voltage_show.grid(row=row, column=2)
+
         row += 1
         tk.Label(frame, text="Voltage Limits (V)").grid(row=row, column=0)
         self.voltage_lmin_entry = tk.Entry(frame, width=10)
@@ -215,21 +238,40 @@ def __init__(self, controller_name) -> None:
         self.view.sidepanel.start_button.bind("<Button>", self.start_scan)
         self.view.sidepanel.save_scan_button.bind("<Button>", self.save_scan)
         self.view.sidepanel.stop_button.bind("<Button>", self.stop_scan)
-        self.view.sidepanel.goto_button.bind("<Button>", self.go_to_voltage)
+        self.view.sidepanel.goto_button.bind("<Button>", self.go_to)
+        self.view.sidepanel.goto_slow_button.bind("<Button>", self.go_to_slowly)
+        self.view.sidepanel.get_button.bind("<Button>", self.update_voltage_show)
         self.view.sidepanel.hardware_config_from_yaml_button.bind("<Button>", lambda e: self.configure_from_yaml())
         self.root.protocol("WM_DELETE_WINDOWwait_visibility()", self.on_closing)
 
-    def go_to_voltage(self, event=None) -> None:
+    def go_to(self, event=None) -> None:
         self.disable_buttons()
-        self.application_controller.go_to_voltage(float(self.view.sidepanel.voltage_entry.get()))
+        controller_speed = self.application_controller.wavelength_controller.speed
+        self.application_controller.wavelength_controller.speed = "fast"
+        self.application_controller.go_to(float(self.view.sidepanel.voltage_entry.get()))
+        self.application_controller.wavelength_controller.speed = controller_speed
         self.enable_buttons()
 
+    def go_to_slowly(self, event=None) -> None:
+        self.disable_buttons()
+        controller_speed = self.application_controller.wavelength_controller.speed
+        self.application_controller.wavelength_controller.speed = "slow"
+        self.application_controller.go_to(float(self.view.sidepanel.voltage_entry.get()))
+        self.application_controller.wavelength_controller.speed = controller_speed
+        self.enable_buttons()
+
+    def update_voltage_show(self, event=None) -> None:
+        read = self.application_controller.wavelength_controller.last_write_value
+        l = self.view.sidepanel.voltage_show
+        l.config(text=read)
+
     def start_scan(self, event=None) -> None:
         self.disable_buttons()
 
         n_sample_size = int(self.view.sidepanel.num_pixels.get())
         n_scans = int(self.view.sidepanel.scan_num_entry.get())
         sweep_time_entry = float(self.view.sidepanel.sweep_time_entry.get())
+        downsweep_time_entry = float(self.view.sidepanel.sweep_time_entry.get())
         vstart= float(self.view.sidepanel.voltage_start_entry.get())
         vend = float(self.view.sidepanel.voltage_end_entry.get())
         step_size = (vend - vstart) / float(n_sample_size)
@@ -274,7 +316,7 @@ def scan_thread_function(self, vstart: float, vend: float, step_size: float, n_s
         try:
             self.application_controller.reset()  # clears the data
             self.application_controller.start()  # starts the DAQ
-            self.application_controller.set_to_starting_voltage()  # moves the stage to starting voltage
+            self.application_controller.set_to_start()  # moves the stage to starting voltage
 
             while self.application_controller.still_scanning():
                 self.application_controller.scan_wavelengths()
diff --git a/src/qt3utils/datagenerators/plescanner.py b/src/qt3utils/datagenerators/plescanner.py
index 110c6cfa..e6f8f4a2 100644
--- a/src/qt3utils/datagenerators/plescanner.py
+++ b/src/qt3utils/datagenerators/plescanner.py
@@ -7,6 +7,7 @@
 
 from qt3utils.applications.controllers.nidaqedgecounter import QT3ScanNIDAQEdgeCounterController
 from qt3utils.applications.controllers.wavemeter_controller import WavemeterController
+from qt3utils.applications.controllers.lockin_controller import Lockin
 from qt3utils.nidaq.customcontrollers import VControl
 
 logger = logging.getLogger(__name__)
@@ -172,6 +173,9 @@ def scan_axis(self, axis: str, min: float, max: float, step_size: float) -> list
             if isinstance(reader, VControl):
                 v_reading = self.readers[reader].get_current_wl_point()
                 output[reader].append(v_reading)
+            if isinstance(reader, Lockin):
+                signal_reading = self.readers[reader].read()
+
         return output
 
     def sample_counts(self, reader) -> np.ndarray:
@@ -213,3 +217,5 @@ def read_wavemeter(self, wm_reader) -> float:
         Returns the reading from the wavemeter
         """
         return wm_reader.read_wavemeter()
+
+
diff --git a/src/qt3utils/nidaq/customcontrollers.py b/src/qt3utils/nidaq/customcontrollers.py
index 532b74fd..ac55cf05 100644
--- a/src/qt3utils/nidaq/customcontrollers.py
+++ b/src/qt3utils/nidaq/customcontrollers.py
@@ -1,9 +1,167 @@
+import abc
 import logging
 import nidaqmx
+import numpy as np
 import time
 
 logger = logging.getLogger(__name__)
 
+
+class VControlBase(abc.ABC):
+
+    def __init__(self, device_name: str,
+                 write_channel: str = 'ao0',
+                 read_channel: str = None,
+                 scale_nm_per_volt: float = 8,
+                 move_settle_time: float = 0.001,
+                 min_position: float = 0.0,
+                 max_position: float = 80.0) -> None:
+        super().__init__()
+
+        self.device_name = device_name
+        self.write_channel = write_channel
+        self.read_channel = read_channel
+        self.scale_nm_per_volt = scale_nm_per_volt
+        self.minimum_allowed_position = min_position
+        self.maximum_allowed_position = max_position
+        self._settling_time_in_seconds = move_settle_time #10 millisecond settle time
+        self.last_write_value = None
+        self.speed = "fast"
+
+    def configure(self, config_dict: dict) -> None:
+        """
+        This method is used to configure the data controller.
+        """
+        self.device_name = config_dict.get('daq_name', self.device_name)
+        self.write_channel = config_dict.get('write_channels', self.write_channel)
+        self.read_channel = config_dict.get('read_channels', self.read_channel)
+        self.scale_nm_per_volt = config_dict.get('scale_nm_per_volt', self.scale_nm_per_volt)
+        self.minimum_allowed_position = config_dict.get('min_position', self.minimum_allowed_position)
+        self.maximum_allowed_position = config_dict.get('max_position', self.maximum_allowed_position)
+
+    def get_current_wl_point(self) -> float:
+        '''
+        Returns the voltage supplied to the three input analog channels.
+        If no input analog channels were provided when objected was created,
+        returns [-1,-1,-1]
+        '''
+        output = -1
+        if self.read_channel is not None:
+            with nidaqmx.Task() as vread, nidaqmx.Task():
+
+                vread.ai_channels.add_ai_voltage_chan(self.device_name + '/' + self.read_channel, min_val=0, max_val=10.0)
+
+                output = vread.read()
+
+        return output
+
+    def check_allowed_position(self, v: float = None) -> None:
+        if v is not None: self._validate_value(v)
+
+    def _validate_value(self, voltage: float) -> None:
+        voltage = float(voltage)
+        if type(voltage) not in [type(1.0), type(1)]:
+            raise TypeError(f'value {voltage} is not a valid type.')
+        if voltage < self.minimum_allowed_position:
+            raise ValueError(f'value {voltage} is less than {self.minimum_allowed_position: .3f}.')
+        if voltage > self.maximum_allowed_position:
+            raise ValueError(f'value {voltage} is greater than {self.maximum_allowed_position: .3f}.')
+
+    def go_to(self, wl_point: float = None) -> None:
+        '''
+        Sets the voltage
+        raises ValueError if try to set voltage out of bounds.
+        '''
+        pass
+
+    @property
+    def settling_time_in_seconds (self):
+        return self._settling_time_in_seconds
+    @settling_time_in_seconds.setter
+    def settling_time_in_seconds (self, val):
+        self._settling_time_in_seconds = val
+
+
+class VControl(VControlBase):
+
+    def go_to(self, wl_point: float = None) -> None:
+        '''
+        Sets the voltage
+        raises ValueError if try to set voltage out of bounds.
+        '''
+        self.go_to_voltage(wl_point)
+
+    def go_to_voltage(self, v: float = None) -> None:
+        '''
+        !//Sets the voltage
+        raises ValueError if try to set position out of bounds.
+        '''
+        debug_string = []
+        if v is not None:
+            self._validate_value(v)
+            with nidaqmx.Task() as task:
+                task.ao_channels.add_ao_voltage_chan(self.device_name + '/' + self.write_channel)
+                task.write(self._nm_to_volts(nm=v))
+                self.last_write_value = v
+            debug_string.append(f'v: {v:.2f}')
+        logger.info(f'go to voltage {" ".join(debug_string)}')
+        time.sleep(self.settling_time_in_seconds) #wait to ensure piezo actuator has settled into position.
+        logger.debug(f'last write: {self.last_write_value}')
+
+    def _nm_to_volts(self, nm: float) -> float:
+        return nm / self.scale_nm_per_volt
+
+    def _volts_to_nm(self, volts: float) -> float:
+        return self.scale_nm_per_volt * volts
+
+
+class VControlV(VControlBase):
+
+    def go_to(self, wl_point: float = None) -> None:
+        '''
+        Sets the voltage
+        raises ValueError if try to set voltage out of bounds.
+        '''
+        if self.speed == "fast":
+            self.go_to_voltage(wl_point)
+        else:
+            self.go_to_voltage_slowly(wl_point)
+
+    def go_to_voltage(self, v: float = None) -> None:
+        '''
+        !//Sets the voltage
+        raises ValueError if try to set position out of bounds.
+        '''
+        debug_string = []
+        if v is not None:
+            self._validate_value(v)
+            with nidaqmx.Task() as task:
+                task.ao_channels.add_ao_voltage_chan(self.device_name + '/' + self.write_channel)
+                task.write(v)
+                self.last_write_value = v
+            debug_string.append(f'v: {v:.2f}')
+        logger.info(f'go to voltage {" ".join(debug_string)}')
+        time.sleep(self.settling_time_in_seconds) #wait to ensure piezo actuator has settled into position.
+        logger.debug(f'last write: {self.last_write_value}')
+
+    def go_to_voltage_slowly(self, v: float = None) -> None:
+        debug_string = []
+        step_size_slow = 0.2
+        if v is not None:
+            self._validate_value(v)
+            with nidaqmx.Task() as task:
+                task.ao_channels.add_ao_voltage_chan(self.device_name + '/' + self.write_channel)
+                while abs(v-self.last_write_value) > step_size_slow:
+                    current_v=self.last_write_value + step_size_slow * np.sign(v-self.last_write_value)
+                    task.write(current_v)
+                    self.last_write_value = current_v
+                    time.sleep(self.settling_time_in_seconds)
+                task.write(v)
+                self.last_write_value = v
+            debug_string.append(f'v: {v:.2f}')
+        logger.info(f'go to voltage {" ".join(debug_string)}')
+        time.sleep(self.settling_time_in_seconds)  # wait to ensure piezo actuator has settled into position.
+        logger.debug(f'last write: {self.last_write_value}')
 class VControl():
     """
     Class for interfacing with DAQ hardware with the express purpose of

From 7ac51aea4af91df418f95fa3cc91b57aaaf1fa55 Mon Sep 17 00:00:00 2001
From: LimeBasil&Mandarin <yunzhao.wang1996@gmail.com>
Date: Fri, 23 Feb 2024 20:22:57 -0800
Subject: [PATCH 28/32] Addressed issues from hardware test

---
 .../controllers/lockin_controller.py          | 29 +++---
 .../controllers/nidaq_rate_counter.yaml       |  2 +-
 .../controllers/nidaq_wm_ple.yaml             | 10 +-
 src/qt3utils/applications/qt3ple/main.py      | 57 ++++++-----
 src/qt3utils/datagenerators/plescanner.py     | 85 ++++++++++-------
 src/qt3utils/nidaq/customcontrollers.py       | 94 +------------------
 6 files changed, 108 insertions(+), 169 deletions(-)

diff --git a/src/qt3utils/applications/controllers/lockin_controller.py b/src/qt3utils/applications/controllers/lockin_controller.py
index 55446f9d..8524b4bd 100644
--- a/src/qt3utils/applications/controllers/lockin_controller.py
+++ b/src/qt3utils/applications/controllers/lockin_controller.py
@@ -1,14 +1,17 @@
+import logging
 import numpy as np
 
 import nidaqmx
 
 class Lockin:
-    def __init__(self, device_name: str, signal_channel: str, timeout: float) -> None:
-        self.device_name = device_name
-        self.signal_channel = signal_channel
+    def __init__(self, logger_level) -> None:
+        self.logger = logging.getLogger(__name__)
+        self.logger.setLevel(logger_level)
+        self.device_name = ""
+        self.signal_channel = ""
         self.sample_number = 20
         self.rate = 20.0
-        self.timeout = timeout
+        self.timeout = 10
 
     def read(self) -> np.ndarray:
         with nidaqmx.Task() as task:
@@ -17,12 +20,12 @@ def read(self) -> np.ndarray:
             c = task.read(number_of_samples_per_channel=self.sample_number, timeout=self.timeout)
         return np.array(c)
 
-def configure(self, config_dict: dict) -> None:
-    """
-    This method is used to configure the data controller.
-    """
-    self.device_name = config_dict.get('daq_name', self.device_name)
-    self.signal_channel = config_dict.get('signal_channels', self.signal_channel)
-    self.sample_number = config_dict.get('sample_number', self.sample_number)
-    self.rate = config_dict.get('rate', self.rate)
-    self.timeout = config_dict.get('timeout', self.timeout)
+    def configure(self, config_dict: dict) -> None:
+        """
+        This method is used to configure the data controller.
+        """
+        self.device_name = config_dict.get('daq_name', self.device_name)
+        self.signal_channel = config_dict.get('signal_channels', self.signal_channel)
+        self.sample_number = config_dict.get('sample_number', self.sample_number)
+        self.rate = config_dict.get('rate', self.rate)
+        self.timeout = config_dict.get('timeout', self.timeout)
diff --git a/src/qt3utils/applications/controllers/nidaq_rate_counter.yaml b/src/qt3utils/applications/controllers/nidaq_rate_counter.yaml
index 2e151ffe..0579e11b 100644
--- a/src/qt3utils/applications/controllers/nidaq_rate_counter.yaml
+++ b/src/qt3utils/applications/controllers/nidaq_rate_counter.yaml
@@ -1,7 +1,7 @@
 QT3PLE:
   ApplicationController:
     import_path : qt3utils.datagenerators.plescanner
-    class_name : CounterAndScanner
+    class_name : PleScanner
     configure :
       controllers:
         daq_writers:
diff --git a/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml b/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
index 0481bafd..642a78ed 100644
--- a/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
+++ b/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
@@ -1,13 +1,12 @@
 QT3PLE:
   ApplicationController:
     import_path : qt3utils.datagenerators.plescanner
-    class_name : WavemeterAndScanner
+    class_name : PleScanner
     configure :
       controller: VoltageController
       readers :
         daq_readers:
           daq_reader : DAQReader
-          daq_reader2 : DAQReader2
         wm_readers:
           wm_reader : WavemeterDllController
 
@@ -26,13 +25,14 @@ QT3PLE:
     class_name  : VControl
     configure :
       daq_name : Silicon_DAQ # NI DAQ Device Name
-      write_channels : ao3 # NI DAQ analog output channels to use for writing position
-      read_channels : ai3  # NI DAQ analog input channels to use for reading position
+      write_channels : ao0 # NI DAQ analog output channels to use for writing position
+      read_channels : ai0  # NI DAQ analog input channels to use for reading position
       min_position: -10  # conversion factor from volts to microns, can also supply a list [8,8,8] or [6,4.2,5]
       max_position: 10  # the voltage value that defines the position 0,0,0, can also supply a list [0,0,0] or [5,5,5]
       scale_nm_per_volt: 1  # microns
+      num_measurements_per_batch: 10
 
-  WavemeterController:
+  WavemeterDllController:
     import_path : qt3utils.applications.controllers.wavemeter_controller
     class_name  : WavemeterDllController
     configure :
diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index 471c8b18..5119d0cf 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -37,7 +37,7 @@
 
 DEFAULT_DAQ_DEVICE_NAME = NIDAQ_DEVICE_NAMES[0]
 
-CONTROLLER_PATH = 'qt3utils.applications.controller'
+CONTROLLER_PATH = 'qt3utils.applications.controllers'
 STANDARD_CONTROLLERS = {NIDAQ_DEVICE_NAMES[0] : 'nidaq_rate_counter.yaml',
                         NIDAQ_DEVICE_NAMES[1] : 'nidaq_wm_ple.yaml'}
 
@@ -59,27 +59,36 @@ def fill_subplot(self, x, y):
         return sub_plt
 
     def update_image_and_plot(self, model) -> None:
+        for ax in self.fig.axes:
+            self.fig.delaxes(ax)
         num_readers = len(model.readers)
         grid = plt.GridSpec(2, num_readers)
         self.update_image(model, grid)
         self.update_plot(model, grid)
 
-
     def update_image(self, model, grid) -> None:
         for ii, reader in enumerate(model.readers):
 
-            if self.log_data:
-                data = np.log10(model.scanned_count_rate)
-                data[np.isinf(data)] = 0  # protect against +-inf
-            else:
-                data = model.scanned_count_rate
-            data = np.array(data).T.tolist()
-
-            artist = self.ax.imshow(data, plt.subplot(grid[0, ii]), cmap=self.cmap)
-                                   # , extent=[model.current_frame + model.raster_line_pause,
-                                   #                                    0,
-                                   #                                    model.vstart,
-                                   #                                    model.vend + model.step_size]
+            #if self.log_data:
+            #    data = np.log10(model.scanned_count_rate)
+            #    data[np.isinf(data)] = 0  # protect against +-inf
+            #else:
+            #    data = model.scanned_count_rate
+            #data = np.array(data).T.tolist()
+            y_data = []
+            for output in model.outputs:
+                y_scan = output[reader]
+                if isinstance(y_scan[0], list) or isinstance(y_scan[0], np.ndarray):
+                    for jj, ydatum in enumerate(y_scan):
+                        y_scan[jj] = np.mean(np.array(ydatum))
+                y_data.append(y_scan)
+
+            ax = self.fig.add_subplot(grid[0, ii])
+            artist = ax.imshow(y_data, cmap=self.cmap
+                                    , extent=[model.current_frame + model.wavelength_controller.settling_time_in_seconds,
+                                                                       0.0,
+                                                                       model.get_start,
+                                                                       model.get_end + model.step_size])
             if self.cbar is None:
                 self.cbar = self.fig.colorbar(artist, ax=self.ax)
             else:
@@ -94,9 +103,10 @@ def update_image(self, model, grid) -> None:
     def update_plot(self, model, grid) -> None:
 
         for ii, reader in enumerate(model.readers):
-            y_data = model.readers[reader]
-            x_control = model.scanned_control
-            self.ax.plot(x_control, y_data, plt.subplot(grid[1, ii]), color='k', linewidth=1.5)
+            y_data = model.outputs[model.current_frame-1][reader]
+            x_control = model.scanned_control[model.current_frame-1]
+            ax = self.fig.add_subplot(grid[1, ii])
+            ax.plot(x_control, y_data, color='k', linewidth=1.5)
 
     def reset(self) -> None:
         self.ax.cla()
@@ -159,8 +169,8 @@ def __init__(self, root, scan_range) -> None:
         tk.Label(frame, text="Mode").grid(row=row, column=0)
         clicked = tk.StringVar()
         clicked.set("Discrete")
-        self.scan_mode= tk.OptionMenu(frame, clicked, *SCAN_OPTIONS)
-        self.scan_mode.pack()
+        #self.scan_mode= tk.OptionMenu(frame, clicked, *SCAN_OPTIONS)
+        #self.scan_mode.pack()
 
         row += 1
         tk.Label(frame, text="DAQ Settings", font='Helvetica 16').grid(row=row, column=0, pady=10)
@@ -208,7 +218,7 @@ def __init__(self, root, scan_range) -> None:
 
 
 class MainApplicationView():
-    def __init__(self, main_frame, scan_range=[-3, 5]) -> None:
+    def __init__(self, main_frame, scan_range=[0, 2]) -> None:
         frame = tk.Frame(main_frame.root)
         frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
 
@@ -281,7 +291,7 @@ def start_scan(self, event=None) -> None:
         args.append(n_scans)
 
         settling_time = sweep_time_entry / n_sample_size
-        self.application_controller.wavelength_controller.settling_time_in_seconds = settling_time
+        #self.application_controller.wavelength_controller.settling_time_in_seconds = settling_time
 
         self.scan_thread = Thread(target=self.scan_thread_function, args=args)
         self.scan_thread.start()
@@ -404,7 +414,8 @@ def configure_from_yaml(self, afile=None) -> None:
                 cls = getattr(module, wm_reader_config['class_name'])
                 self.data_acquisition_models[wm_reader] = cls(logger.level)
                 self.data_acquisition_models[wm_reader].configure(wm_reader_config['configure'])
-        daq_controller_config = config[CONFIG_FILE_APPLICATION_NAME]
+        daq_controller_name = config[CONFIG_FILE_APPLICATION_NAME]['ApplicationController']['configure']['controller']
+        daq_controller_config = config[CONFIG_FILE_APPLICATION_NAME][daq_controller_name]
         if daq_controller_config is not None:
             module = importlib.import_module(daq_controller_config['import_path'])
             logger.debug(f"loading {daq_controller_config['import_path']}")
@@ -428,12 +439,14 @@ def load_controller_from_name(self, application_controller_name: str) -> None:
     def disable_buttons(self):
         self.view.sidepanel.start_button['state'] = 'disabled'
         self.view.sidepanel.goto_button['state'] = 'disabled'
+        self.view.sidepanel.goto_slow_button['state'] = 'disabled'
         self.view.sidepanel.controller_menu.config(state=tk.DISABLED)
         self.view.sidepanel.save_scan_button.config(state=tk.DISABLED)
 
     def enable_buttons(self):
         self.view.sidepanel.start_button['state'] = 'normal'
         self.view.sidepanel.goto_button['state'] = 'normal'
+        self.view.sidepanel.goto_slow_button['state'] = 'normal'
         self.view.sidepanel.controller_menu.config(state=tk.NORMAL)
         self.view.sidepanel.save_scan_button.config(state=tk.NORMAL)
 
diff --git a/src/qt3utils/datagenerators/plescanner.py b/src/qt3utils/datagenerators/plescanner.py
index e6f8f4a2..a2100348 100644
--- a/src/qt3utils/datagenerators/plescanner.py
+++ b/src/qt3utils/datagenerators/plescanner.py
@@ -67,7 +67,7 @@ def set_to_start(self) -> None:
         """
         self.current_wl_point = self._start
         if self.wavelength_controller:
-            self.wavelength_controller.go_to(v=self._start)
+            self.go_to(wl_point=self._start)
 
     def close(self) -> None:
         """
@@ -121,7 +121,7 @@ def increment_wl(self) -> None:
         self.current_wl_point += self._step_size
         if self.wavelength_controller and self.current_wl_point <= self._end:
             try:
-                self.wavelength_controller.go_to(v=self.current_wl_point)
+                self.wavelength_controller.go_to(wl_point=self.current_wl_point)
             except ValueError as e:
                 logger.info(f'out of range\n\n{e}')
 
@@ -151,31 +151,37 @@ def scan_axis(self, axis: str, min: float, max: float, step_size: float) -> list
             values = output of scan
         As well as an array of the points associated with the scan
         """
-        output = {key: [] for key in self.readers.keys}
-        self.wavelength_controller.go_to_wl_point(**{axis: min})
-        self.scanned_control.append(self.wavelength_controller.geta_current_wl_point())
-        for reader in self.readers:
-            if isinstance(reader, QT3ScanNIDAQEdgeCounterController ):
-                self.rate_counters.append(self.readers[reader])
-                raw_counts = []
-                _raw_counts = self.sample_counts(self.readers[reader])
-                raw_counts.append(_raw_counts)
-                logger.info(f'raw counts, total clock samples: {_raw_counts}')
-                if self.wavelength_controller:
-                    logger.info(f'current {self.axis_name}: {self.wavelength_controller.get_current_wl_point()}')
-                raw_counts.append(_raw_counts)
-                output[reader].append(self.sample_count_rate(raw_counts))
-            if isinstance(reader, WavemeterController):
-                _wm_reading = self.read_wavemeter(self.readers[reader])
-                output[reader].append(_wm_reading)
-                if self.wavelength_controller:
-                    logger.info(f'current {self.axis_name}: {self.wavelength_controller.get_current_wl_point()}')
-            if isinstance(reader, VControl):
-                v_reading = self.readers[reader].get_current_wl_point()
-                output[reader].append(v_reading)
-            if isinstance(reader, Lockin):
-                signal_reading = self.readers[reader].read()
-
+        output = {key: [] for key in self.readers.keys()}
+        scanned_control = []
+        self.set_to_start()
+        for val in np.arange(min, max, step_size):
+            if self.wavelength_controller:
+                logger.info(f'go to {axis}: {val:.2f}')
+                self.go_to(wl_point=val)
+            scanned_control.append(self.wavelength_controller.get_current_wl_point())
+            for reader in self.readers:
+                if isinstance(self.readers[reader], QT3ScanNIDAQEdgeCounterController ):
+                    self.rate_counters.append(self.readers[reader])
+                    raw_counts = []
+                    _raw_counts = self.sample_counts(self.readers[reader])
+                    raw_counts.append(_raw_counts)
+                    logger.info(f'raw counts, total clock samples: {_raw_counts}')
+                    if self.wavelength_controller:
+                        logger.info(f'current {self.axis_name}: {self.wavelength_controller.get_current_wl_point()}')
+                    raw_counts.append(_raw_counts)
+                    output[reader].append(self.sample_count_rate(raw_counts))
+                if isinstance(self.readers[reader], WavemeterController):
+                    _wm_reading = self.read_wavemeter(self.readers[reader])
+                    output[reader].append(_wm_reading)
+                    if self.wavelength_controller:
+                        logger.info(f'current {self.axis_name}: {self.wavelength_controller.get_current_wl_point()}')
+                if isinstance(self.readers[reader], VControl):
+                    v_reading = self.readers[reader].get_current_wl_point()
+                    output[reader].append(v_reading)
+                if isinstance(self.readers[reader], Lockin):
+                    signal_reading = self.readers[reader].read()
+                    output[reader].append(signal_reading)
+        self.scanned_control.append(scanned_control)
         return output
 
     def sample_counts(self, reader) -> np.ndarray:
@@ -196,14 +202,6 @@ def configure_view(self, gui_root: tk.Toplevel) -> None:
         """
         pass
 
-    @property
-    def step_size(self):
-        return self._step_size
-
-    @step_size.setter
-    def step_size(self, value: float):
-        self._step_size = value
-
     def sample_count_rate(self, rate_counter, data_counts=None) -> np.floating:
         """
         Sum the counts in a batch
@@ -218,4 +216,21 @@ def read_wavemeter(self, wm_reader) -> float:
         """
         return wm_reader.read_wavemeter()
 
+    @property
+    def step_size(self):
+        return self._step_size
+
+    @step_size.setter
+    def step_size(self, value: float):
+        self._step_size = value
+
+    @property
+    def get_start(self):
+        return self._start
+
+    @property
+    def get_end(self):
+        return self._end
+
+
 
diff --git a/src/qt3utils/nidaq/customcontrollers.py b/src/qt3utils/nidaq/customcontrollers.py
index ac55cf05..85855603 100644
--- a/src/qt3utils/nidaq/customcontrollers.py
+++ b/src/qt3utils/nidaq/customcontrollers.py
@@ -55,7 +55,7 @@ def get_current_wl_point(self) -> float:
 
         return output
 
-    def check_allowed_position(self, v: float = None) -> None:
+    def check_allowed_limits(self, v: float = None) -> None:
         if v is not None: self._validate_value(v)
 
     def _validate_value(self, voltage: float) -> None:
@@ -162,97 +162,5 @@ def go_to_voltage_slowly(self, v: float = None) -> None:
         logger.info(f'go to voltage {" ".join(debug_string)}')
         time.sleep(self.settling_time_in_seconds)  # wait to ensure piezo actuator has settled into position.
         logger.debug(f'last write: {self.last_write_value}')
-class VControl():
-    """
-    Class for interfacing with DAQ hardware with the express purpose of
-    controlling and/or reading the voltage at the DAQ that sets the wavelength of a laser
-    """
 
-    def __init__(self,
-                 logger_level,
-                 device_name: str = "",
-                 write_channel: str = 'ao0',
-                 read_channel: str = None,
-                 scale_nm_per_volt: float = 8,
-                 move_settle_time: float = 0.001,
-                 min_voltage: float = 0.0,
-                 max_voltage: float = 80.0) -> None:
-        self.logger = logging.getLogger(__name__)
-        self.logger.setLevel(logger_level)
-
-        self.device_name = device_name
-        self.write_channel = write_channel
-        self.read_channel = read_channel
-        self.scale_nm_per_volt = scale_nm_per_volt
-        self.minimum_allowed_voltage = min_voltage
-        self.maximum_allowed_voltage = max_voltage
-        self._settling_time_in_seconds = move_settle_time  # 10 millisecond settle time
-        self.last_write_value = None
-
-
-
-    def go_to(self, wl_point: float = None) -> None:
-        '''
-        Sets the voltage
-        raises ValueError if try to set voltage out of bounds.
-        '''
-        voltage = wl_point
-        debug_string = []
-        if voltage is not None:
-            self._validate_value(voltage)
-            with nidaqmx.Task() as task:
-                task.ao_channels.add_ao_voltage_chan(f"{self.device_name}/{self.write_channel}")
-                task.write(self._nm_to_volts(nm=voltage))
-                self.last_write_value = voltage
-            debug_string.append(f'voltage: {voltage:.2f}')
-        logger.info(f'go to voltage {" ".join(debug_string)}')
-        time.sleep(self.settling_time_in_seconds)  # wait to ensure piezo actuator has settled into voltage.
-        logger.debug(f'last write: {self.last_write_value}')
 
-    def get_current_wl_point(self) -> float:
-        '''
-        Returns the voltage supplied to the three input analog channels.
-        If no input analog channels were provided when objected was created,
-        returns none
-        '''
-        output = None
-        if self.read_channel is not None:
-            with nidaqmx.Task() as vread, nidaqmx.Task():
-                vread.ai_channels.add_ai_voltage_chan(f"{self.device_name}/{self.read_channel}")
-                output = vread.read()
-        return output
-
-    def configure(self, config_dict: dict) -> None:
-        """
-        This method is used to configure the data controller.
-        """
-        self.device_name = config_dict.get('daq_name', self.device_name)
-        self.write_channel = config_dict.get('write_channels', self.write_channel)
-        self.read_channel = config_dict.get('read_channels', self.read_channel)
-        self.scale_nm_per_volt = config_dict.get('scale_nm_per_volt', self.scale_nm_per_volt)
-        self.minimum_allowed_voltage = config_dict.get('min_voltage', self.minimum_allowed_voltage)
-        self.maximum_allowed_voltage = config_dict.get('max_voltage', self.maximum_allowed_voltage)
-
-    def check_allowed_limits(self, voltage: float = None) -> None:
-        if voltage is not None: self._validate_value(voltage)
-
-    def _validate_value(self, voltage: float) -> None:
-        voltage = float(voltage)
-        if not isinstance(voltage, (float, int)):
-            raise TypeError(f'value {voltage} is not a valid type.')
-        if voltage < self.minimum_allowed_voltage:
-            raise ValueError(f'value {voltage} is less than {self.minimum_allowed_voltage: .3f}.')
-        if voltage > self.maximum_allowed_voltage:
-            raise ValueError(f'value {voltage} is greater than {self.maximum_allowed_voltage: .3f}.')
-    def _nm_to_volts(self, nm: float) -> float:
-        return nm / self.scale_nm_per_volt
-
-    def _volts_to_nm(self, volts: float) -> float:
-        return self.scale_nm_per_volt * volts
-
-    @property
-    def settling_time_in_seconds (self):
-        return self._settling_time_in_seconds
-    @settling_time_in_seconds.setter
-    def settling_time_in_seconds (self, value):
-        self._settling_time_in_seconds = value

From 1780f22b23549cfe33fe5d3e5daaa9235163841b Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Tue, 27 Feb 2024 08:01:40 -0800
Subject: [PATCH 29/32] Added batch scan mode

---
 src/qt3utils/applications/qt3ple/main.py  | 64 ++++++++++++++++----
 src/qt3utils/datagenerators/plescanner.py | 74 +++++++++++++++--------
 src/qt3utils/nidaq/customcontrollers.py   |  5 +-
 3 files changed, 105 insertions(+), 38 deletions(-)

diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index 5119d0cf..38d6f4ad 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -160,17 +160,26 @@ def __init__(self, root, scan_range) -> None:
         self.sweep_time_entry.grid(row=row, column=1)
 
         row += 1
+        self.do_downsweep = tk.IntVar(value=0)
         tk.Label(frame, text="Downsweep Time").grid(row=row, column=0)
         self.downsweep_time_entry = tk.Entry(frame, width=10)
         self.downsweep_time_entry.insert(10, 1)
         self.downsweep_time_entry.grid(row=row, column=1)
+        self.downsweep_time_entry.config(state=tk.DISABLED)
+        self.downsweep_button = tk.Checkbutton(frame, text="Downsweep", onvalue=1, offvalue=0,
+                                               variable=self.do_downsweep, command=self.display_downsweep_time)
+        self.downsweep_button.grid(row=row, column=2)
 
         row += 1
         tk.Label(frame, text="Mode").grid(row=row, column=0)
-        clicked = tk.StringVar()
-        clicked.set("Discrete")
-        #self.scan_mode= tk.OptionMenu(frame, clicked, *SCAN_OPTIONS)
-        #self.scan_mode.pack()
+        self.scan_mode = tk.StringVar()
+        self.scan_mode.set("Discrete")
+        self.scan_options = tk.OptionMenu(frame, self.scan_mode, *SCAN_OPTIONS, command=self.display_batch_entry)
+        self.scan_options.grid(row=row, column=1)
+        self.batch_entry = tk.Entry(frame, width=10)
+        self.batch_entry.insert(10, 1)
+        self.batch_entry.grid(row=row, column=2)
+        self.batch_entry.config(state=tk.DISABLED)
 
         row += 1
         tk.Label(frame, text="DAQ Settings", font='Helvetica 16').grid(row=row, column=0, pady=10)
@@ -190,7 +199,7 @@ def __init__(self, root, scan_range) -> None:
         self.get_button = tk.Button(frame, text="Get current Voltage")
         self.get_button.grid(row=row, column=0)
         self.voltage_show=tk.Label(frame, text='None')
-        self.voltage_show.grid(row=row, column=2)
+        self.voltage_show.grid(row=row, column=1)
 
         row += 1
         tk.Label(frame, text="Voltage Limits (V)").grid(row=row, column=0)
@@ -216,6 +225,19 @@ def __init__(self, root, scan_range) -> None:
         self.hardware_config_from_yaml_button = tk.Button(frame, text="Load YAML Config")
         self.hardware_config_from_yaml_button.grid(row=row, column=0, columnspan=3)
 
+    def display_batch_entry(self, scan_mode):
+        if scan_mode == "Batches":
+            self.batch_entry.config(state=tk.NORMAL)
+        else:
+            self.batch_entry.config(state=tk.DISABLED)
+
+    def display_downsweep_time(self):
+        if self.do_downsweep.get() == 1:
+            self.downsweep_time_entry.config(state=tk.NORMAL)
+        else:
+            self.downsweep_time_entry.config(state=tk.DISABLED)
+
+
 
 class MainApplicationView():
     def __init__(self, main_frame, scan_range=[0, 2]) -> None:
@@ -277,11 +299,15 @@ def update_voltage_show(self, event=None) -> None:
 
     def start_scan(self, event=None) -> None:
         self.disable_buttons()
-
+        scan_mode = str(self.view.sidepanel.scan_mode.get())
+        batch_size = int(self.view.sidepanel.batch_entry.get())
         n_sample_size = int(self.view.sidepanel.num_pixels.get())
         n_scans = int(self.view.sidepanel.scan_num_entry.get())
         sweep_time_entry = float(self.view.sidepanel.sweep_time_entry.get())
-        downsweep_time_entry = float(self.view.sidepanel.sweep_time_entry.get())
+        do_downsweep = bool(self.view.sidepanel.do_downsweep.get())
+        downsweep_time = float(self.view.sidepanel.sweep_time_entry.get())
+        if not do_downsweep:
+            downsweep_time_entry = None
         vstart= float(self.view.sidepanel.voltage_start_entry.get())
         vend = float(self.view.sidepanel.voltage_end_entry.get())
         step_size = (vend - vstart) / float(n_sample_size)
@@ -289,9 +315,13 @@ def start_scan(self, event=None) -> None:
         args.append(step_size)
         args.append(n_sample_size)
         args.append(n_scans)
+        args.append(scan_mode)
+        args.append(batch_size)
 
         settling_time = sweep_time_entry / n_sample_size
-        #self.application_controller.wavelength_controller.settling_time_in_seconds = settling_time
+        downsweep_settling_time = downsweep_time / n_sample_size
+        self.application_controller.settling_time_in_seconds = settling_time
+        self.application_controller.downsweep_settling_time_in_seconds = downsweep_settling_time
 
         self.scan_thread = Thread(target=self.scan_thread_function, args=args)
         self.scan_thread.start()
@@ -313,13 +343,25 @@ def on_closing(self) -> None:
             logger.debug(e)
             pass
 
-    def scan_thread_function(self, vstart: float, vend: float, step_size: float, n_sample_size: int, n_scans: int) -> None:
+    def scan_thread_function(self,
+                             vstart: float,
+                             vend: float,
+                             step_size: float,
+                             n_sample_size: int,
+                             n_scans: int,
+                             scan_mode: str,
+                             batch_size: int,
+                             downsweep_time: float) -> None:
         """
         Function to be called in background thread
         Scans the voltage from vstart to vend in increments of step_size
-        for a total of n_sample_size data points n_scans number of times
+        for a total of n_sample_size data points n_scans number of times.
+        If the scan_mode is "Batches", it will aggregate (average) some
+        batch_size number of points in between data points instead.
         """
-
+        self.application_controller.set_scan_mode(scan_mode)
+        self.application_controller.discrete_batch_size = batch_size
+        self.application_controller.downsweep_time
         self.application_controller.set_scan_range(vstart, vend)
         self.application_controller.step_size = step_size
         self.application_controller.tmax = n_scans
diff --git a/src/qt3utils/datagenerators/plescanner.py b/src/qt3utils/datagenerators/plescanner.py
index a2100348..2678a7b3 100644
--- a/src/qt3utils/datagenerators/plescanner.py
+++ b/src/qt3utils/datagenerators/plescanner.py
@@ -39,6 +39,8 @@ def __init__(self, readers, wavelength_controller):
         self.outputs = []
         self.rate_counters = []
         self.scanned_control = []
+        self.scan_mode = ""
+        self.discrete_batch_size = 1
         if isinstance(self.wavelength_controller, VControl):
             self.axis_name = "Voltage"
         else:
@@ -150,37 +152,52 @@ def scan_axis(self, axis: str, min: float, max: float, step_size: float) -> list
             keys = name of reader defined in YAML file
             values = output of scan
         As well as an array of the points associated with the scan
+        If scan_mode is Discrete, each point will represent average values of batch between points instead
         """
         output = {key: [] for key in self.readers.keys()}
         scanned_control = []
         self.set_to_start()
-        for val in np.arange(min, max, step_size):
-            if self.wavelength_controller:
+        val_array = np.arange(min, max, step_size)
+        for ii, val in enumerate(val_array):
+            if self.scan_mode == "Discrete":
+                batch_vals = [val]
+            elif self.scan_mode == "Batches":
+                self.wavelength_controller.speed = "fast"
+                time.sleep(self.wavelength_controller.settling_time_in_seconds)
+                batch_vals = np.arange(val, val_array[ii+1])
+            for batch_val in batch_vals:
                 logger.info(f'go to {axis}: {val:.2f}')
-                self.go_to(wl_point=val)
-            scanned_control.append(self.wavelength_controller.get_current_wl_point())
+                self.go_to(wl_point=batch_val)
+                scanned_control.append(self.wavelength_controller.get_current_wl_point())
+                batch_output = {key: [] for key in self.readers.keys()}
+                for reader in self.readers:
+                    if isinstance(self.readers[reader], QT3ScanNIDAQEdgeCounterController ):
+                        self.rate_counters.append(self.readers[reader])
+                        raw_counts = []
+                        _raw_counts = self.sample_counts(self.readers[reader])
+                        raw_counts.append(_raw_counts)
+                        logger.info(f'raw counts, total clock samples: {_raw_counts}')
+                        if self.wavelength_controller:
+                            logger.info(f'current {self.axis_name}: {self.wavelength_controller.get_current_wl_point()}')
+                        raw_counts.append(_raw_counts)
+                        batch_output[reader].append(self.sample_count_rate(raw_counts))
+                    if isinstance(self.readers[reader], WavemeterController):
+                        _wm_reading = self.read_wavemeter(self.readers[reader])
+                        batch_output[reader].append(_wm_reading)
+                        if self.wavelength_controller:
+                            logger.info(f'current {self.axis_name}: {self.wavelength_controller.get_current_wl_point()}')
+                    if isinstance(self.readers[reader], VControl):
+                        v_reading = self.readers[reader].get_current_wl_point()
+                        batch_output[reader].append(v_reading)
+                    if isinstance(self.readers[reader], Lockin):
+                        signal_reading = self.readers[reader].read()
+                        batch_output[reader].append(signal_reading)
             for reader in self.readers:
-                if isinstance(self.readers[reader], QT3ScanNIDAQEdgeCounterController ):
-                    self.rate_counters.append(self.readers[reader])
-                    raw_counts = []
-                    _raw_counts = self.sample_counts(self.readers[reader])
-                    raw_counts.append(_raw_counts)
-                    logger.info(f'raw counts, total clock samples: {_raw_counts}')
-                    if self.wavelength_controller:
-                        logger.info(f'current {self.axis_name}: {self.wavelength_controller.get_current_wl_point()}')
-                    raw_counts.append(_raw_counts)
-                    output[reader].append(self.sample_count_rate(raw_counts))
-                if isinstance(self.readers[reader], WavemeterController):
-                    _wm_reading = self.read_wavemeter(self.readers[reader])
-                    output[reader].append(_wm_reading)
-                    if self.wavelength_controller:
-                        logger.info(f'current {self.axis_name}: {self.wavelength_controller.get_current_wl_point()}')
-                if isinstance(self.readers[reader], VControl):
-                    v_reading = self.readers[reader].get_current_wl_point()
-                    output[reader].append(v_reading)
-                if isinstance(self.readers[reader], Lockin):
-                    signal_reading = self.readers[reader].read()
-                    output[reader].append(signal_reading)
+                reader_batch = np.array(batch_output[reader])
+                if len(reader_batch.shape) == 1:
+                    output[reader].append(np.mean(batch_output[reader]))
+                else:
+                    output[reader].append(batch_output[reader][-1])
         self.scanned_control.append(scanned_control)
         return output
 
@@ -216,6 +233,13 @@ def read_wavemeter(self, wm_reader) -> float:
         """
         return wm_reader.read_wavemeter()
 
+    def set_scan_mode(self, scan_mode: str) ->None:
+        self.scan_mode = scan_mode
+
+    @property
+    def discrete_batch_size(self, batch_size: int) -> None:
+        self.discrete_batch_size = batch_size
+
     @property
     def step_size(self):
         return self._step_size
diff --git a/src/qt3utils/nidaq/customcontrollers.py b/src/qt3utils/nidaq/customcontrollers.py
index 85855603..ae42462a 100644
--- a/src/qt3utils/nidaq/customcontrollers.py
+++ b/src/qt3utils/nidaq/customcontrollers.py
@@ -122,7 +122,7 @@ def go_to(self, wl_point: float = None) -> None:
         Sets the voltage
         raises ValueError if try to set voltage out of bounds.
         '''
-        if self.speed == "fast":
+        if self.speed == "normal" or self.speed == "fast":
             self.go_to_voltage(wl_point)
         else:
             self.go_to_voltage_slowly(wl_point)
@@ -141,7 +141,8 @@ def go_to_voltage(self, v: float = None) -> None:
                 self.last_write_value = v
             debug_string.append(f'v: {v:.2f}')
         logger.info(f'go to voltage {" ".join(debug_string)}')
-        time.sleep(self.settling_time_in_seconds) #wait to ensure piezo actuator has settled into position.
+        if not self.speed == "fast":
+            time.sleep(self.settling_time_in_seconds) #wait to ensure voltage has settled into position.
         logger.debug(f'last write: {self.last_write_value}')
 
     def go_to_voltage_slowly(self, v: float = None) -> None:

From 8edb03d0d81c5f73044429a0bf5c089ff9d79787 Mon Sep 17 00:00:00 2001
From: LimeBasil&Mandarin <yunzhao.wang1996@gmail.com>
Date: Thu, 29 Feb 2024 20:42:32 -0800
Subject: [PATCH 30/32] Saves as pickle. Fixed issues with batch mode.

---
 .../controllers/nidaq_wm_ple.yaml             |  4 +-
 .../controllers/wavemeter_controller.py       |  9 +-
 src/qt3utils/applications/qt3ple/main.py      | 84 ++++++++++---------
 src/qt3utils/datagenerators/plescanner.py     | 16 ++--
 src/qt3utils/nidaq/customcontrollers.py       |  7 +-
 5 files changed, 68 insertions(+), 52 deletions(-)

diff --git a/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml b/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
index 642a78ed..9cac3a6c 100644
--- a/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
+++ b/src/qt3utils/applications/controllers/nidaq_wm_ple.yaml
@@ -25,8 +25,8 @@ QT3PLE:
     class_name  : VControl
     configure :
       daq_name : Silicon_DAQ # NI DAQ Device Name
-      write_channels : ao0 # NI DAQ analog output channels to use for writing position
-      read_channels : ai0  # NI DAQ analog input channels to use for reading position
+      write_channels : ao3 # NI DAQ analog output channels to use for writing voltage
+      read_channels : ai0  # NI DAQ analog input channels to use for reading voltage
       min_position: -10  # conversion factor from volts to microns, can also supply a list [8,8,8] or [6,4.2,5]
       max_position: 10  # the voltage value that defines the position 0,0,0, can also supply a list [0,0,0] or [5,5,5]
       scale_nm_per_volt: 1  # microns
diff --git a/src/qt3utils/applications/controllers/wavemeter_controller.py b/src/qt3utils/applications/controllers/wavemeter_controller.py
index 6cee2ceb..c46adee5 100644
--- a/src/qt3utils/applications/controllers/wavemeter_controller.py
+++ b/src/qt3utils/applications/controllers/wavemeter_controller.py
@@ -1,7 +1,9 @@
+import abc
 import ctypes
 import logging
 
-class WavemeterController:
+
+class WavemeterController(abc.ABC):
     """
     Base class for other types of wavemeter controllers to inherit from
     """
@@ -9,30 +11,35 @@ def __init__(self, logger_level):
         self.logger = logging.getLogger(__name__)
         self.logger.setLevel(logger_level)
 
+    @abc.abstractmethod
     def open(self):
         """
         Override this method to open and initialize wavemeter
         """
         pass
 
+    @abc.abstractmethod
     def read_wavemeter(self):
         """
         Override this method to read the value from the wavemeter
         """
         pass
 
+    @abc.abstractmethod
     def close_wavemeter(self):
         """
         Override this method to close the connection to the wavemeter
         """
         pass
 
+    @abc.abstractmethod
     def configure(self):
         """
         Override this method to configure the wavemeter from a dict set via yaml file
         """
         pass
 
+
 class WavemeterDllController(WavemeterController):
     """
     Class for interfacing with wavemeter hardware
diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index 38d6f4ad..66ec63fd 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -1,12 +1,11 @@
 import argparse
-import h5py
 import importlib
 import importlib.resources
 import logging
+import pickle
 from threading import Thread
 
 import matplotlib
-from matplotlib import gridspec
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
 import matplotlib.pyplot as plt
 import nidaqmx
@@ -84,18 +83,16 @@ def update_image(self, model, grid) -> None:
                 y_data.append(y_scan)
 
             ax = self.fig.add_subplot(grid[0, ii])
+            y_data = np.array(y_data).T
             artist = ax.imshow(y_data, cmap=self.cmap
                                     , extent=[model.current_frame + model.wavelength_controller.settling_time_in_seconds,
                                                                        0.0,
                                                                        model.get_start,
                                                                        model.get_end + model.step_size])
-            if self.cbar is None:
-                self.cbar = self.fig.colorbar(artist, ax=self.ax)
-            else:
-                self.cbar.update_normal(artist)
+            cbar = self.fig.colorbar(artist, ax=ax)
 
-            if self.log_data is False:
-                self.cbar.formatter.set_powerlimits((0, 3))
+            #if self.log_data is False:
+            #    cbar.formatter.set_powerlimits((0, 3))
 
             self.ax.set_xlabel('Pixels')
             self.ax.set_ylabel('Voltage (V)')
@@ -210,6 +207,9 @@ def __init__(self, root, scan_range) -> None:
         self.voltage_lmin_entry.grid(row=row, column=1)
         self.voltage_lmax_entry.grid(row=row, column=2)
 
+        row += 1
+        tk.Label(frame, text="Hardware Configuration", font='Helvetica 16').grid(row=row, column=0, pady=10)
+
         row+=1
         self.controller_option = tk.StringVar(frame)
         self.controller_option.set(DEFAULT_DAQ_DEVICE_NAME)  # setting the default value
@@ -265,7 +265,9 @@ def __init__(self, controller_name) -> None:
         self.view.controller_option = controller_name
         # data acquisition model that is used to acquire data
         self.data_acquisition_models = {}
-        self.controller_models = {}
+        self.controller_model = None
+        self.meta_configs = None
+        self.app_meta_data = None
         # load the data acquisition model
         self.view.sidepanel.start_button.bind("<Button>", self.start_scan)
         self.view.sidepanel.save_scan_button.bind("<Button>", self.save_scan)
@@ -323,6 +325,7 @@ def start_scan(self, event=None) -> None:
         self.application_controller.settling_time_in_seconds = settling_time
         self.application_controller.downsweep_settling_time_in_seconds = downsweep_settling_time
 
+        self.app_meta_data = args
         self.scan_thread = Thread(target=self.scan_thread_function, args=args)
         self.scan_thread.start()
 
@@ -350,8 +353,7 @@ def scan_thread_function(self,
                              n_sample_size: int,
                              n_scans: int,
                              scan_mode: str,
-                             batch_size: int,
-                             downsweep_time: float) -> None:
+                             batch_size: int) -> None:
         """
         Function to be called in background thread
         Scans the voltage from vstart to vend in increments of step_size
@@ -361,7 +363,6 @@ def scan_thread_function(self,
         """
         self.application_controller.set_scan_mode(scan_mode)
         self.application_controller.discrete_batch_size = batch_size
-        self.application_controller.downsweep_time
         self.application_controller.set_scan_range(vstart, vend)
         self.application_controller.step_size = step_size
         self.application_controller.tmax = n_scans
@@ -385,32 +386,29 @@ def scan_thread_function(self,
         self.enable_buttons()
 
     def save_scan(self, event = None):
-        myformats = [('Compressed Numpy MultiArray', '*.npz'), ('Numpy Array (count rate only)', '*.npy'), ('HDF5', '*.h5')]
-        afile = tk.filedialog.asksaveasfilename(filetypes=myformats, defaultextension='.npz')
+        myformats = [('Pickle', '*.pkl')]
+        afile = tk.filedialog.asksaveasfilename(filetypes=myformats, defaultextension='.pkl')
         logger.info(afile)
         file_type = afile.split('.')[-1]
         if afile is None or afile == '':
             return # selection was canceled.
-
-        data = dict(
-            raw_counts=self.application_controller.scanned_raw_counts,
-            count_rate=self.application_controller.scanned_count_rate,
-            scan_range=self.application_controller.get_completed_scan_range(),
-            step_size=self.application_controller.step_size,
-            daq_clock_rate=self.application_controller.rate_counter.clock_rate,
-        )
-
-        if file_type == 'npy':
-            np.save(afile, data['count_rate'])
-
-        if file_type == 'npz':
-            np.savez_compressed(afile, **data)
-
-        elif file_type == 'h5':
-            h5file = h5py.File(afile, 'w')
-            for key, value in data.items():
-                h5file.create_dataset(key, data=value)
-            h5file.close()
+        data = {}
+        data["Data"] = {}
+        if self.application_controller is not None:
+            for ii, scan_data in enumerate(self.application_controller.outputs):
+                data["Data"][f"Scan{ii}"] = {}
+                for reader in self.application_controller.readers:
+                    data["Data"][f"Scan{ii}"][reader] = scan_data[reader]
+        data["Metadata"] = []
+        if self.meta_configs is not None:
+            for meta_config in self.meta_configs:
+                data["Metadata"].append(meta_config)
+        if self.app_meta_data is not None:
+            data["ApplicationController"] = self.app_meta_data
+
+        if file_type == 'pkl':
+            with open(afile, 'wb') as f:
+                pickle.dump(data, f)
 
     def configure_from_yaml(self, afile=None) -> None:
         """
@@ -437,36 +435,40 @@ def configure_from_yaml(self, afile=None) -> None:
         self.app_config = self.app_controller_config["configure"]
         logger.info("load settings from yaml")
         daq_readers = self.app_config["readers"]["daq_readers"]
+        self.meta_configs = []
         if daq_readers is not None:
             for daq_reader in daq_readers:
                 daq_reader_name = daq_readers[daq_reader]
                 daq_reader_config = config[CONFIG_FILE_APPLICATION_NAME][daq_reader_name]
+                self.meta_configs.append(daq_reader_config)
                 module = importlib.import_module(daq_reader_config['import_path'])
                 logger.debug(f"loading {daq_reader_config['import_path']}")
                 cls = getattr(module, daq_reader_config['class_name'])
-                self.data_acquisition_models[daq_reader] = cls(logger.level)
-                self.data_acquisition_models[daq_reader].configure(daq_reader_config['configure'])
+                self.data_acquisition_models[daq_reader_name] = cls(logger.level)
+                self.data_acquisition_models[daq_reader_name].configure(daq_reader_config['configure'])
         wm_readers = self.app_config["readers"]["wm_readers"]
         if wm_readers is not None:
             for wm_reader in wm_readers:
                 wm_reader_name = wm_readers[wm_reader]
                 wm_reader_config = config[CONFIG_FILE_APPLICATION_NAME][wm_reader_name]
+                self.meta_configs.append(wm_reader_config)
                 module = importlib.import_module(wm_reader_config['import_path'])
                 logger.debug(f"loading {wm_reader_config['import_path']}")
                 cls = getattr(module, wm_reader_config['class_name'])
-                self.data_acquisition_models[wm_reader] = cls(logger.level)
-                self.data_acquisition_models[wm_reader].configure(wm_reader_config['configure'])
+                self.data_acquisition_models[wm_reader_name] = cls(logger.level)
+                self.data_acquisition_models[wm_reader_name].configure(wm_reader_config['configure'])
         daq_controller_name = config[CONFIG_FILE_APPLICATION_NAME]['ApplicationController']['configure']['controller']
         daq_controller_config = config[CONFIG_FILE_APPLICATION_NAME][daq_controller_name]
+        self.meta_configs.append(daq_controller_config)
         if daq_controller_config is not None:
             module = importlib.import_module(daq_controller_config['import_path'])
             logger.debug(f"loading {daq_controller_config['import_path']}")
             cls = getattr(module, daq_controller_config['class_name'])
-            controller_model = cls(logger.level)
-            controller_model.configure(daq_controller_config['configure'])
+            self.controller_model = cls(logger.level)
+            self.controller_model.configure(daq_controller_config['configure'])
         else:
            raise Exception("Yaml configuration file must have a controller for PLE scan.")
-        self.application_controller = plescanner.PleScanner(self.data_acquisition_models, controller_model)
+        self.application_controller = plescanner.PleScanner(self.data_acquisition_models, self.controller_model)
 
     def load_controller_from_name(self, application_controller_name: str) -> None:
         """
diff --git a/src/qt3utils/datagenerators/plescanner.py b/src/qt3utils/datagenerators/plescanner.py
index 2678a7b3..9355afc2 100644
--- a/src/qt3utils/datagenerators/plescanner.py
+++ b/src/qt3utils/datagenerators/plescanner.py
@@ -40,7 +40,7 @@ def __init__(self, readers, wavelength_controller):
         self.rate_counters = []
         self.scanned_control = []
         self.scan_mode = ""
-        self.discrete_batch_size = 1
+        self._discrete_batch_size = 1
         if isinstance(self.wavelength_controller, VControl):
             self.axis_name = "Voltage"
         else:
@@ -110,7 +110,7 @@ def still_scanning(self) -> bool:
         if self.running == False:  # this allows external process to stop scan
             return False
 
-        if self.current_frame <= self.tmax:  # stops scan when reaches final position
+        if self.current_frame < self.tmax:  # stops scan when reaches final position
             return True
         else:
             self.running = False
@@ -157,14 +157,17 @@ def scan_axis(self, axis: str, min: float, max: float, step_size: float) -> list
         output = {key: [] for key in self.readers.keys()}
         scanned_control = []
         self.set_to_start()
-        val_array = np.arange(min, max, step_size)
+        val_array = np.arange(min, max + step_size, step_size)
         for ii, val in enumerate(val_array):
             if self.scan_mode == "Discrete":
                 batch_vals = [val]
             elif self.scan_mode == "Batches":
                 self.wavelength_controller.speed = "fast"
                 time.sleep(self.wavelength_controller.settling_time_in_seconds)
-                batch_vals = np.arange(val, val_array[ii+1])
+                if ii < len(val_array)-1:
+                    batch_vals = np.arange(val, val_array[ii+1])
+                else:
+                    continue
             for batch_val in batch_vals:
                 logger.info(f'go to {axis}: {val:.2f}')
                 self.go_to(wl_point=batch_val)
@@ -237,8 +240,11 @@ def set_scan_mode(self, scan_mode: str) ->None:
         self.scan_mode = scan_mode
 
     @property
+    def discrete_batch_size(self):
+        return self._discrete_batch_size
+    @discrete_batch_size.setter
     def discrete_batch_size(self, batch_size: int) -> None:
-        self.discrete_batch_size = batch_size
+        self._discrete_batch_size = batch_size
 
     @property
     def step_size(self):
diff --git a/src/qt3utils/nidaq/customcontrollers.py b/src/qt3utils/nidaq/customcontrollers.py
index ae42462a..e67ceebe 100644
--- a/src/qt3utils/nidaq/customcontrollers.py
+++ b/src/qt3utils/nidaq/customcontrollers.py
@@ -7,7 +7,7 @@
 logger = logging.getLogger(__name__)
 
 
-class VControlBase(abc.ABC):
+class WavelengthControlBase(abc.ABC):
 
     def __init__(self, device_name: str,
                  write_channel: str = 'ao0',
@@ -67,6 +67,7 @@ def _validate_value(self, voltage: float) -> None:
         if voltage > self.maximum_allowed_position:
             raise ValueError(f'value {voltage} is greater than {self.maximum_allowed_position: .3f}.')
 
+    @abc.abstractmethod
     def go_to(self, wl_point: float = None) -> None:
         '''
         Sets the voltage
@@ -82,7 +83,7 @@ def settling_time_in_seconds (self, val):
         self._settling_time_in_seconds = val
 
 
-class VControl(VControlBase):
+class VControl(WavelengthControlBase):
 
     def go_to(self, wl_point: float = None) -> None:
         '''
@@ -115,7 +116,7 @@ def _volts_to_nm(self, volts: float) -> float:
         return self.scale_nm_per_volt * volts
 
 
-class VControlV(VControlBase):
+class VControlWavelength(WavelengthControlBase):
 
     def go_to(self, wl_point: float = None) -> None:
         '''

From 8eda17d107b353c1e8921d54a90ace5d320df75a Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Wed, 27 Mar 2024 17:41:37 -0700
Subject: [PATCH 31/32] Adjusted comments and display names

---
 .../controllers/wavemeter_controller.py       | 10 ++++-----
 src/qt3utils/applications/qt3ple/main.py      | 22 +++++++------------
 src/qt3utils/datagenerators/plescanner.py     |  6 ++---
 src/qt3utils/nidaq/customcontrollers.py       | 20 +++++++++--------
 4 files changed, 27 insertions(+), 31 deletions(-)

diff --git a/src/qt3utils/applications/controllers/wavemeter_controller.py b/src/qt3utils/applications/controllers/wavemeter_controller.py
index c46adee5..6dfdd0c3 100644
--- a/src/qt3utils/applications/controllers/wavemeter_controller.py
+++ b/src/qt3utils/applications/controllers/wavemeter_controller.py
@@ -33,7 +33,7 @@ def close_wavemeter(self):
         pass
 
     @abc.abstractmethod
-    def configure(self):
+    def configure(self, config_dict: dict):
         """
         Override this method to configure the wavemeter from a dict set via yaml file
         """
@@ -46,9 +46,9 @@ class WavemeterDllController(WavemeterController):
     """
     def __init__(self, logger_level, dll_path=""):
         super(WavemeterDllController, self).__init__(logger_level)
-        if not dll_path == "":
-            self.open(dll_path)
         self.dll_path = dll_path
+        if not dll_path == "":
+            self.open(self.dll_path)
         self.last_config_dict = {}
 
     def open(self, dll_path) -> None:
@@ -61,13 +61,13 @@ def open(self, dll_path) -> None:
         if self._dh == -1:
             raise Exception("Failed to connect to wave meter.")
 
-    def read_wavemeter(self) -> float:
+    def read(self) -> float:
         """
         Return the value from the wavemeter via the dll
         """
         return self._mydll.CLGetLambdaReading(self._dh)
 
-    def close_wavemeter(self) -> None:
+    def close(self) -> None:
         """
         Close the connection to the wavemeter via the dll
         """
diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index 66ec63fd..e8452ab9 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -67,13 +67,6 @@ def update_image_and_plot(self, model) -> None:
 
     def update_image(self, model, grid) -> None:
         for ii, reader in enumerate(model.readers):
-
-            #if self.log_data:
-            #    data = np.log10(model.scanned_count_rate)
-            #    data[np.isinf(data)] = 0  # protect against +-inf
-            #else:
-            #    data = model.scanned_count_rate
-            #data = np.array(data).T.tolist()
             y_data = []
             for output in model.outputs:
                 y_scan = output[reader]
@@ -130,7 +123,7 @@ def __init__(self, root, scan_range) -> None:
         self.save_scan_button = tk.Button(frame, text="Save Scan")
         self.save_scan_button.grid(row=row, column=2)
         row += 1
-        tk.Label(frame, text="Voltage Range (V)").grid(row=row, column=0)
+        tk.Label(frame, text="Scan Range").grid(row=row, column=0)
         self.voltage_start_entry = tk.Entry(frame, width=10)
         self.voltage_end_entry = tk.Entry(frame, width=10)
         self.voltage_start_entry.insert(10, scan_range[0])
@@ -158,7 +151,7 @@ def __init__(self, root, scan_range) -> None:
 
         row += 1
         self.do_downsweep = tk.IntVar(value=0)
-        tk.Label(frame, text="Downsweep Time").grid(row=row, column=0)
+        tk.Label(frame, text="Backward Sweep Time").grid(row=row, column=0)
         self.downsweep_time_entry = tk.Entry(frame, width=10)
         self.downsweep_time_entry.insert(10, 1)
         self.downsweep_time_entry.grid(row=row, column=1)
@@ -182,24 +175,24 @@ def __init__(self, root, scan_range) -> None:
         tk.Label(frame, text="DAQ Settings", font='Helvetica 16').grid(row=row, column=0, pady=10)
 
         row += 1
-        self.goto_button = tk.Button(frame, text="Go To Voltage")
+        self.goto_button = tk.Button(frame, text="Go To scanning parameter")
         self.goto_button.grid(row=row, column=0)
-        self.goto_slow_button = tk.Button(frame, text="Slowly go to Voltage")
+        self.goto_slow_button = tk.Button(frame, text="Slowly go to scanning parameter")
         self.goto_slow_button.grid(row=row, column=1)
         row += 1
-        tk.Label(frame, text="Voltage (V)").grid(row=row, column=0)
+        tk.Label(frame, text="Wavelength Parameter").grid(row=row, column=0)
         self.voltage_entry = tk.Entry(frame, width=10)
         self.voltage_entry.insert(10, 0)
         self.voltage_entry.grid(row=row, column=1)
 
         row += 1
-        self.get_button = tk.Button(frame, text="Get current Voltage")
+        self.get_button = tk.Button(frame, text="Get current scanning parameter")
         self.get_button.grid(row=row, column=0)
         self.voltage_show=tk.Label(frame, text='None')
         self.voltage_show.grid(row=row, column=1)
 
         row += 1
-        tk.Label(frame, text="Voltage Limits (V)").grid(row=row, column=0)
+        tk.Label(frame, text="Scan Limits").grid(row=row, column=0)
         self.voltage_lmin_entry = tk.Entry(frame, width=10)
         self.voltage_lmax_entry = tk.Entry(frame, width=10)
         self.voltage_lmin_entry.insert(10, float(scan_range[0]))
@@ -436,6 +429,7 @@ def configure_from_yaml(self, afile=None) -> None:
         logger.info("load settings from yaml")
         daq_readers = self.app_config["readers"]["daq_readers"]
         self.meta_configs = []
+        self.data_acquisition_models = {}
         if daq_readers is not None:
             for daq_reader in daq_readers:
                 daq_reader_name = daq_readers[daq_reader]
diff --git a/src/qt3utils/datagenerators/plescanner.py b/src/qt3utils/datagenerators/plescanner.py
index 9355afc2..b7c4a1e5 100644
--- a/src/qt3utils/datagenerators/plescanner.py
+++ b/src/qt3utils/datagenerators/plescanner.py
@@ -8,7 +8,7 @@
 from qt3utils.applications.controllers.nidaqedgecounter import QT3ScanNIDAQEdgeCounterController
 from qt3utils.applications.controllers.wavemeter_controller import WavemeterController
 from qt3utils.applications.controllers.lockin_controller import Lockin
-from qt3utils.nidaq.customcontrollers import VControl
+from qt3utils.nidaq.customcontrollers import WavelengthControlBase, VControl
 
 logger = logging.getLogger(__name__)
 
@@ -18,7 +18,7 @@ class PleScanner:
     Override this class for specific types of PLE experiments
     """
 
-    def __init__(self, readers, wavelength_controller):
+    def __init__(self, readers: dict, wavelength_controller: WavelengthControlBase) -> None:
         """
         self.running: boolean true when scan thread is running
         self.current_frame: current pixel (or time) number in sweep
@@ -234,7 +234,7 @@ def read_wavemeter(self, wm_reader) -> float:
         """
         Returns the reading from the wavemeter
         """
-        return wm_reader.read_wavemeter()
+        return wm_reader.read()
 
     def set_scan_mode(self, scan_mode: str) ->None:
         self.scan_mode = scan_mode
diff --git a/src/qt3utils/nidaq/customcontrollers.py b/src/qt3utils/nidaq/customcontrollers.py
index e67ceebe..fae7c72f 100644
--- a/src/qt3utils/nidaq/customcontrollers.py
+++ b/src/qt3utils/nidaq/customcontrollers.py
@@ -4,10 +4,11 @@
 import numpy as np
 import time
 
-logger = logging.getLogger(__name__)
-
-
 class WavelengthControlBase(abc.ABC):
+    """
+    All methods of controlling wavelength should share some common characteristics: min, max, get current value, etc.
+    This is such a base class from which all wavelength controller can inherit from.
+    """
 
     def __init__(self, device_name: str,
                  write_channel: str = 'ao0',
@@ -18,6 +19,7 @@ def __init__(self, device_name: str,
                  max_position: float = 80.0) -> None:
         super().__init__()
 
+        self.logger = logging.getLogger(__name__)
         self.device_name = device_name
         self.write_channel = write_channel
         self.read_channel = read_channel
@@ -105,9 +107,9 @@ def go_to_voltage(self, v: float = None) -> None:
                 task.write(self._nm_to_volts(nm=v))
                 self.last_write_value = v
             debug_string.append(f'v: {v:.2f}')
-        logger.info(f'go to voltage {" ".join(debug_string)}')
+        self.logger.info(f'go to voltage {" ".join(debug_string)}')
         time.sleep(self.settling_time_in_seconds) #wait to ensure piezo actuator has settled into position.
-        logger.debug(f'last write: {self.last_write_value}')
+        self.logger.debug(f'last write: {self.last_write_value}')
 
     def _nm_to_volts(self, nm: float) -> float:
         return nm / self.scale_nm_per_volt
@@ -141,10 +143,10 @@ def go_to_voltage(self, v: float = None) -> None:
                 task.write(v)
                 self.last_write_value = v
             debug_string.append(f'v: {v:.2f}')
-        logger.info(f'go to voltage {" ".join(debug_string)}')
+        self.logger.info(f'go to voltage {" ".join(debug_string)}')
         if not self.speed == "fast":
             time.sleep(self.settling_time_in_seconds) #wait to ensure voltage has settled into position.
-        logger.debug(f'last write: {self.last_write_value}')
+        self.logger.debug(f'last write: {self.last_write_value}')
 
     def go_to_voltage_slowly(self, v: float = None) -> None:
         debug_string = []
@@ -161,8 +163,8 @@ def go_to_voltage_slowly(self, v: float = None) -> None:
                 task.write(v)
                 self.last_write_value = v
             debug_string.append(f'v: {v:.2f}')
-        logger.info(f'go to voltage {" ".join(debug_string)}')
+        self.logger.info(f'go to voltage {" ".join(debug_string)}')
         time.sleep(self.settling_time_in_seconds)  # wait to ensure piezo actuator has settled into position.
-        logger.debug(f'last write: {self.last_write_value}')
+        self.logger.debug(f'last write: {self.last_write_value}')
 
 

From 6ff982a80d8c5f44272ac715f214222c46372d13 Mon Sep 17 00:00:00 2001
From: lane <laneb88@uw.edu>
Date: Wed, 27 Mar 2024 17:54:38 -0700
Subject: [PATCH 32/32] Changed PLE main verbose logger functionality

---
 src/qt3utils/applications/qt3ple/main.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/qt3utils/applications/qt3ple/main.py b/src/qt3utils/applications/qt3ple/main.py
index e8452ab9..d0f7964f 100644
--- a/src/qt3utils/applications/qt3ple/main.py
+++ b/src/qt3utils/applications/qt3ple/main.py
@@ -19,8 +19,7 @@
 
 parser = argparse.ArgumentParser(description='NI DAQ (PCIx 6363) / PLE Scanner',
                                  formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-parser.add_argument('-q', '--quiet', action='store_true',
-                    help='When true,logger level will be set to warning. Otherwise, set to "info".')
+parser.add_argument('-v', '--verbose', type=int, default=2, help='0 = quiet, 1 = info, 2 = debug.')
 parser.add_argument('-cmap', metavar='<MPL color>', default='gray',
                     help='Set the MatplotLib colormap scale')
 args = parser.parse_args()
@@ -28,8 +27,12 @@
 logger = logging.getLogger(__name__)
 logging.basicConfig()
 
-if args.quiet is False:
+if args.verbose == 0:
+    logger.setLevel(logging.WARNING)
+if args.verbose == 1:
     logger.setLevel(logging.INFO)
+if args.verbose == 2:
+    logger.setLevel(logging.DEBUG)
 
 NIDAQ_DEVICE_NAMES = ['NIDAQ Rate Counter', "Lockin & Wavemeter"]
 RANDOM_DAQ_DEVICE_NAME = 'Random Data Generator'