wasatch 2.2.13__tar.gz → 2.2.15__tar.gz

{wasatch-2.2.13 → wasatch-2.2.15}/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+- 2024-12-06 2.2.15
+    - XL Fixes
+        - fixed scan averaging
+        - fixed detector temperature readout
+        - support vertical ROI (successfully tested (118, 138) ie (center 128, height 20))
+        - flag non-downloaded Andor EEPROMs as 'stubbed'
+    - EEPROM
+        - allow MultiWavelengthCalibration.set to support any EEPROM property
+        - fixed Raman Intensity Calibration (broke in 2.2.14)
+        - raman_intensity_calibration_order (standardized on 5th-order polynomial)
+    - force integral ROI
+- 2024-11-25 2.2.14
+    - EEPROM
+        - added subformat 5 (EEPROM.MultiWavelengthCalibration)
+        - bumped rev to 17
+        - deprecated subformat 4 (regions)
+    - SpectrometerSettings
+        - deprecated integer excitation_nm
+        - moved vertical ROI to wasatch.ROI
+        - added calibrations(), select_calibration(n)
+    - FeatureInterfaceDevice
+        - added set/get_scans_to_average
+    - SpectrometerState
+        - added onboard_averaging
 - 2024-11-01 2.2.13
     - support for InGaAs linear pixel calibration
     - re-enable STM32 serial number

{wasatch-2.2.13 → wasatch-2.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wasatch
-Version: 2.2.13
+Version: 2.2.15
 Summary: This package is a driver for Wasatch Photonics spectrometers
 Author-email: Wasatch Photonics <edort@wasatchphotonics.com>
 Description-Content-Type: text/markdown

{wasatch-2.2.13 → wasatch-2.2.15}/wasatch/AndorDevice.py

@@ -11,6 +11,7 @@ from .SpectrometerResponse        import SpectrometerResponse
 from .InterfaceDevice             import InterfaceDevice
 from .DeviceID                    import DeviceID
 from .Reading                     import Reading
+from .ROI                         import ROI
 
 log = logging.getLogger(__name__)
 
@@ -47,7 +48,7 @@ class AndorDevice(InterfaceDevice):
     SUCCESS = 20002             #!< see load_error_codes()
     SHUTTER_SPEED_MS = 50       #!< allow time for mechanical shutter to stabilize
 
-    def __init__(self, device_id, message_queue=None, alert_queue=None): # -> None 
+    def __init__(self, device_id, message_queue=None, alert_queue=None):
         # if passed a string representation of a DeviceID, deserialize it
         super().__init__()
         if type(device_id) is str:
@@ -67,6 +68,8 @@ class AndorDevice(InterfaceDevice):
 
         self.immediate_mode = False
 
+        # An AndorDevice has-a SpectrometerSettings, which has-a EEPROM, which 
+        # has-a MultiWavelengthCalibration
         self.settings = SpectrometerSettings(self.device_id)
         self.summed_spectra         = None
         self.sum_count              = 0
@@ -125,51 +128,55 @@ class AndorDevice(InterfaceDevice):
         # set Andor defaults for important "EEPROM" settings
         # (all but has_cooling can be overridden via config file)
 
-        # Andor API doesn't have access to detector info
-        # Note that we use non-iDus cameras, including the Newton
+        # Andor API doesn't(?) seem to have access to detector info.
+        # Note that we use non-iDus cameras, including the Newton.
         self.settings.eeprom.detector = "iDus" 
-        self.settings.eeprom.wavelength_coeffs = [0,1,0,0]
+
         self.settings.eeprom.has_cooling = True
         self.settings.eeprom.startup_integration_time_ms = 10
         self.settings.eeprom.startup_temp_degC = -60
         self.settings.eeprom.detector_gain = 1
         self.settings.eeprom.detector_gain_odd = 1
 
+        # MultiWavelengthCalibration attributes
+        self.settings.eeprom.multi_wavelength_calibration.set("wavelength_coeffs", [0,1,0,0,0])
+
         self.process_f = self._init_process_funcs()
 
     ###############################################################
     # Private Methods
     ###############################################################
 
-    def _init_process_funcs(self): # -> dict[str, Callable[..., Any]] 
+    def _init_process_funcs(self):
         process_f = {}
 
-        process_f["connect"] = self.connect
-        process_f["acquire_data"] = self.acquire_data
-        process_f["set_shutter_enable"] = self.set_shutter_enable
-        process_f["set_integration_time_ms"] = self.set_integration_time_ms
-        process_f["get_serial_number"] = self.get_serial_number
-        process_f["init_tec_setpoint"] = self.init_tec_setpoint
-        process_f["set_tec_setpoint"] = self.set_tec_setpoint
-        process_f["init_detector_area"] = self.init_detector_area
-        process_f["scans_to_average"] = self.scans_to_average
-        process_f["high_gain_mode_enable"] = self.high_gain_mode_enable
-        process_f["save_config"] = self.save_config
+        process_f["connect"]                    = self.connect
+        process_f["acquire_data"]               = self.acquire_data
+        process_f["set_shutter_enable"]         = self.set_shutter_enable
+        process_f["set_integration_time_ms"]    = self.set_integration_time_ms
+        process_f["get_serial_number"]          = self.get_serial_number
+        process_f["init_tec_setpoint"]          = self.init_tec_setpoint
+        process_f["set_tec_setpoint"]           = self.set_tec_setpoint
+        process_f["init_detector_area"]         = self.init_detector_area
+        process_f["scans_to_average"]           = self.scans_to_average
+        process_f["high_gain_mode_enable"]      = self.high_gain_mode_enable
+        process_f["save_config"]                = self.save_config
+        process_f["vertical_binning"]           = self.set_vertical_binning
 
         ##################################################################
         # What follows is the old init-lambdas that are squashed into process_f
         # Long term, the upstream requests should be changed to match the new format
         # This is an easy fix for the time being to make things behave
         ##################################################################
-        process_f["integration_time_ms"] = lambda x: self.set_integration_time_ms(x) # conversion from millisec to microsec
-        process_f["fan_enable"] = lambda x: self.set_fan_enable(bool(x))
-        process_f["shutter_enable"] = lambda x: self.set_shutter_enable(bool(x))
-        process_f["detector_tec_enable"]                = lambda x: self.toggle_tec(bool(x))
-        process_f["detector_tec_setpoint_degC"]         = lambda x: self.set_tec_setpoint(int(round(x)))
+        process_f["integration_time_ms"]        = lambda x: self.set_integration_time_ms(x)
+        process_f["fan_enable"]                 = lambda x: self.set_fan_enable(bool(x))
+        process_f["shutter_enable"]             = lambda x: self.set_shutter_enable(bool(x))
+        process_f["detector_tec_enable"]        = lambda x: self.toggle_tec(bool(x))
+        process_f["detector_tec_setpoint_degC"] = lambda x: self.set_tec_setpoint(int(round(x)))
 
         return process_f
 
-    def high_gain_mode_enable(self, enabled: bool): # -> SpectrometerResponse 
+    def high_gain_mode_enable(self, enabled):
         if enabled:
             result = self.driver.SetPreAmpGain(self.gain_idx[-1])
             assert(self.SUCCESS == result), f"unable to set detector gain, got value of {result}"
@@ -181,22 +188,16 @@ class AndorDevice(InterfaceDevice):
             log.debug(f"for {enabled} setting gain to {self.gain_options[0]}")
             return
 
-    # MZ: nothing seems to call this?
-    def _update_wavelength_coeffs(self, coeffs: list[float]): # -> None 
-        self.settings.eeprom.wavelength_coeffs = coeffs
-        self.config_values['wavelength_coeffs'] = coeffs
-        self.save_config()
-
-    def set_fan_enable(self, x: bool): # -> SpectrometerResponse 
+    def set_fan_enable(self, x):
         self.check_result(self.driver.SetFanMode(int(x)), f"Andor Fan On {x}")
         return SpectrometerResponse()
 
-    def _get_default_data_dir(self): # -> str 
+    def _get_default_data_dir(self):
         if os.name == "nt":
             return os.path.join(os.path.expanduser("~"), "Documents", "EnlightenSpectra")
         return os.path.join(os.environ["HOME"], "EnlightenSpectra")
 
-    def _check_config_file(self): # -> bool 
+    def _check_config_file(self):
         self.config_dir = os.path.join(self._get_default_data_dir(), 'config')
         self.config_file = os.path.join(self.config_dir, self.serial + '.json')
         if not os.path.exists(self.config_dir):
@@ -228,10 +229,10 @@ class AndorDevice(InterfaceDevice):
 
         return convertedSpec
 
-    def _take_one_averaged_reading(self): # -> SpectrometerResponse 
+    def _take_one_averaged_reading(self):
         averaging_enabled = (self.settings.state.scans_to_average > 1)
 
-        if averaging_enabled and not self.settings.state.free_running_mode:
+        if averaging_enabled:
             # collect the entire averaged spectrum at once (added for
             # BatchCollection with laser delay)
             #
@@ -258,7 +259,7 @@ class AndorDevice(InterfaceDevice):
             if self.tec_enabled:
                 log.debug("TEC enabled, so reading temperature")
 
-                use_float = True    # seems to work on 785XL (WP-01635)
+                use_float = True    # seems to work on 785XL (WP-01635 and WP-01491)
 
                 if use_float:
                     c_temp = c_float()
@@ -269,7 +270,11 @@ class AndorDevice(InterfaceDevice):
 
                 label = self.get_error_code(result)
                 
-                if label in ["DRV_SUCCESS", "DRV_TEMP_STABILIZED", "DRV_TEMP_NOT_REACHED", "DRV_TEMP_DRIFT", "DRV_TEMP_NOT_STABILIZED"]:
+                if label in [ "DRV_SUCCESS", 
+                              "DRV_TEMPERATURE_DRIFT",
+                              "DRV_TEMPERATURE_STABILIZED",
+                              "DRV_TEMPERATURE_NOT_REACHED",
+                              "DRV_TEMPERATURE_NOT_STABILIZED" ]:
                     reading.detector_temperature_degC = c_temp.value
                     log.debug(f"Andor temperature {reading.detector_temperature_degC:.2f} ({label})")
                 else:
@@ -336,12 +341,12 @@ class AndorDevice(InterfaceDevice):
         # reading.dump_area_scan()
         return SpectrometerResponse(data=reading)
 
-    def _close_ex_shutter(self): # -> SpectrometerResponse 
+    def _close_ex_shutter(self):
         self.check_result(self.driver.SetShutterEx(1, 1, self.SHUTTER_SPEED_MS, self.SHUTTER_SPEED_MS, 2), "SetShutterEx(2)")
         self.settings.state.shutter_enabled = False
         return SpectrometerResponse(True)
 
-    def _open_ex_shutter(self): # -> SpectrometerResponse 
+    def _open_ex_shutter(self):
         self.check_result(self.driver.SetShutterEx(1, 1, self.SHUTTER_SPEED_MS, self.SHUTTER_SPEED_MS, 1), "SetShutterEx(1)")
         self.settings.state.shutter_enabled = True
         return SpectrometerResponse(True)
@@ -358,7 +363,7 @@ class AndorDevice(InterfaceDevice):
             raise RuntimeError(msg)
         log.debug(f"successfully called {func}")
 
-    def connect(self): # -> SpectrometerResponse 
+    def connect(self):
         if self.dll_fail:
             return SpectrometerResponse(False, error_msg="can't find Andor DLL; please confirm Andor Driver Pack 2 installed")
 
@@ -380,13 +385,20 @@ class AndorDevice(InterfaceDevice):
         self.init_detector_area() # step 7
 
         if not self._check_config_file():
+            log.debug("stubbing Andor EEPROM")
+            self.settings.eeprom.stubbed = True
             self.config_values = {
                 'detector_serial_number': self.serial,
-                'wavelength_coeffs': [0,1,0,0],
+                'wavelength_coeffs': [0,1,0,0,0],
                 'excitation_nm_float': 0,
                 'raman_intensity_coeffs': [],
                 'raman_intensity_calibration_order': 0,
-                'invert_x_axis': False 
+                'invert_x_axis': False,
+                'roi_horizontal_start': 0,
+                'roi_horizontal_end': 0,
+                'roi_vertical_region_1_start': 0,
+                'roi_vertical_region_1_end': 0,
+                'stubbed': True
             }
             log.debug(f"connect: config file not found, so defaulting to these: {self.config_values}")
             self.save_config()
@@ -411,6 +423,14 @@ class AndorDevice(InterfaceDevice):
         # step 17 (WasatchNET doesn't do this)
         self._obtain_gain_info()
 
+        # step 18 (WasatchNET doesn't do this)
+        roi = ROI(self.settings.eeprom.roi_vertical_region_1_start, 
+                  self.settings.eeprom.roi_vertical_region_1_end)
+        if roi.start != 0 and roi.end != 0:
+            # although camera can probably support the (0, 0) case, it's 
+            # convenient to treat as unconfigured defaults
+            self.set_vertical_binning(roi)
+
         # success!
         log.info("AndorDevice successfully connected")
 
@@ -419,6 +439,40 @@ class AndorDevice(InterfaceDevice):
         self.settings.eeprom.has_cooling = True
         return SpectrometerResponse(data=True)
 
+    def set_vertical_binning(self, roi):
+        """
+        Note that this follows the same (start, end) vertical ROI API as 
+        FeatureInterfaceDevice.set_vertical_binning, and dynamically translates 
+        that into the (middle, height) Andor API.
+        """
+
+        if isinstance(roi, ROI):
+            start, end = roi.start, roi.end
+        elif len(roi) == 2:
+            start, end = roi[0], roi[1]
+        else:
+            log.error("set_vertical_binning requires an ROI object or tuple of (start, stop) lines")
+            return SpectrometerResponse(data=False, error_msg="invalid start and stop lines")
+
+        if start < 0 or end < 0:
+            log.error("set_vertical_binning requires POSITIVE (start, stop) lines")
+            return SpectrometerResponse(data=False, error_msg="invalid start and stop lines")
+
+        # enforce ascending order
+        if start >= end:
+            log.error("set_vertical_binning requires ascending order (ignoring %d, %d)", start, end)
+            return SpectrometerResponse(data=False, error_msg="invalid start and stop lines")
+
+
+        height = end - start
+        center = int(round(height / 2, 0)) + start
+
+        log.debug(f"setting Single-Track vertical binning of ROI (start {start}, end {end}) (center {center}, height {height})")
+        self.check_result(self.driver.SetReadMode(3), "SetReadMode(single-track)")
+        self.check_result(self.driver.SetSingleTrack(center, height), "SetSingleTrack")
+
+        return SpectrometerResponse(data=True)
+
     def save_config(self, eeprom=None):
         """
         The user has edited the "virtual EEPROM", for instance using ENLIGHTEN's 
@@ -428,7 +482,6 @@ class AndorDevice(InterfaceDevice):
         @param eeprom: if provided, overwrite current settings with those in the 
                passed dict before writing to disk
         """
-        log.debug("save_config: here")
         if eeprom is not None:
             self.update_config_from_eeprom(eeprom)
 
@@ -444,13 +497,13 @@ class AndorDevice(InterfaceDevice):
         # first, copy over any EEPROM fields which have a different name in 
         # wasatch.EEPROM vs the external JSON file 
         for json_name, python_name in self.config_names_to_eeprom.items():
-            self.config_values[json_name] = getattr(eeprom, python_name)
+            self.config_values[json_name] = eeprom.multi_wavelength_calibration.get(python_name)
 
         # now do all the standard attributes of the wasatch.EEPROM, adding 
         # their values into the same dict
-        for python_name, python_value in eeprom.__dict__.items():
+        for python_name in eeprom.__dict__:
             if python_name in self.config_values:
-                self.config_values[python_name] = python_value
+                self.config_values[python_name] = eeprom.multi_wavelength_calibration.get(python_name)
 
     def _load_config_values(self):
         """
@@ -463,10 +516,11 @@ class AndorDevice(InterfaceDevice):
         # handle wp_ prefixes
         for k, v in self.config_names_to_eeprom.items():
             if k in self.config_values:
-                setattr(self.settings.eeprom, v, self.config_values[k])
+                self.settings.eeprom.multi_wavelength_calibration.set(v, self.config_values[k])
 
         # same spelling
         for k in [ 'model', 
+                   'stubbed', 
                    'detector', 
                    'serial_number', 
                    'invert_x_axis',
@@ -474,33 +528,35 @@ class AndorDevice(InterfaceDevice):
                    'excitation_nm_float',
                    'roi_horizontal_end',
                    'roi_horizontal_start',
+                   'roi_vertical_region_1_start',
+                   'roi_vertical_region_1_end',
                    'raman_intensity_coeffs',
                    'raman_intensity_calibration_order',
                    'startup_temp_degC', 
                    'startup_integration_time_ms' ]:
             if k in self.config_values:
-                setattr(self.settings.eeprom, k, self.config_values[k])
+                self.settings.eeprom.multi_wavelength_calibration.set(k, self.config_values[k])
 
         # default missing-but-obvious fields
         if "raman_intensity_coeffs" in self.config_values:
             if "raman_intensity_calibration_order" not in self.config_values:
-                self.settings.eeprom.raman_intensity_calibration_order = len(self.settings.eeprom.raman_intensity_coeffs) - 1
+                self.settings.eeprom.multi_wavelength_calibration.set("raman_intensity_calibration_order", len(self.settings.eeprom.raman_intensity_coeffs) - 1)
 
         # post-load initialization
         if 'startup_temp_degC' in self.config_values:
             self.set_tec_setpoint(self.settings.eeprom.startup_temp_degC)
 
-    def acquire_data(self): # -> SpectrometerResponse 
+    def acquire_data(self):
         reading = self._take_one_averaged_reading()
         return reading
 
-    def set_shutter_enable(self, enable: bool): # -> SpectrometerResponse 
+    def set_shutter_enable(self, enable):
         if enable:
             return self._open_ex_shutter()
         else:
             return self._close_ex_shutter()
 
-    def set_integration_time_ms(self, ms: float): # -> SpectrometerResponse 
+    def set_integration_time_ms(self, ms):
         self.integration_time_ms = ms
         log.debug(f"setting integration time to {self.integration_time_ms}ms")
 
@@ -566,13 +622,13 @@ class AndorDevice(InterfaceDevice):
         self.check_result(self.driver.SetTemperature(self.setpoint_deg_c), f"SetTemperature({self.setpoint_deg_c})")
         return SpectrometerResponse(True)
 
-    def init_detector_area(self): # -> SpectrometerResponse 
+    def init_detector_area(self):
         xPixels = c_int()
         yPixels = c_int()
         self.check_result(self.driver.GetDetector(byref(xPixels), byref(yPixels)), "GetDetector(x, y)")
-        log.debug(f"detector {xPixels.value} width x {yPixels.value} height")
         self.pixels = xPixels.value
         self.height = yPixels.value
+        log.debug(f"detector {self.pixels} width x {self.height} height")
         return SpectrometerResponse(True)
 
     def _obtain_gain_info(self):
@@ -592,7 +648,7 @@ class AndorDevice(InterfaceDevice):
         self.gain_options = self.gain_options[::-1]
         log.debug(f"obtained gain options for spec, values were {self.gain_options}")
 
-    def init_detector_speed(self): # -> SpectrometerResponse 
+    def init_detector_speed(self):
         speed = c_float()
 
         # for CCDs, set vertical to recommended
@@ -623,7 +679,7 @@ class AndorDevice(InterfaceDevice):
         log.debug(f"set AD channel {ADnumber} with horizontal speed {HSnumber} ({STemp})")
         return SpectrometerResponse(True)
 
-    def scans_to_average(self, value: int): # -> SpectrometerResponse 
+    def scans_to_average(self, value):
         self.sum_count = 0
         self.settings.state.scans_to_average = int(value)
         return SpectrometerResponse(True)

{wasatch-2.2.13 → wasatch-2.2.15}/wasatch/AutoRamanRequest.py

@@ -74,3 +74,23 @@ class AutoRamanRequest:
         buf.extend([self.saturation       & 0xff, (self.saturation    >> 8) & 0xff])
         buf.extend([self.max_avg          & 0xff                                  ]) 
         return buf
+
+if __name__ == "__main__":
+    aar = AutoRamanRequest(
+        max_ms         = 10000,
+        start_integ_ms = 100,
+        start_gain_db  = 0,
+        max_integ_ms   = 2000,
+        min_integ_ms   = 10,
+        max_gain_db    = 32,
+        min_gain_db    = 0,
+        target_counts  = 45000,
+        max_counts     = 50000,
+        min_counts     = 40000,
+        max_factor     = 5,
+        drop_factor    = 0.8,
+        saturation     = 65000,
+        max_avg        = 100)
+
+    buf = aar.serialize()
+    print("0x" + " ".join([f"{b:02x}" for b in buf]))

{wasatch-2.2.13 → wasatch-2.2.15}/wasatch/DeviceFinderUSB.py

@@ -161,14 +161,14 @@ class DeviceFinderUSB:
         return [DeviceID(device) for device in pyusb_devices]
 
     def find_usb_devices(self, poll = False):
-        log.debug("DeviceFinderUSB.find_usb_devices: starting")
+        # log.debug("DeviceFinderUSB.find_usb_devices: starting")
         device_ids = []
 
         # MZ/ED: If USE_MONITORING is True, I had to disable the call to remove_all in enlighten.Controller
         if self.startup_scan < self.MIN_POLLING_SCANS or not self.USE_MONITORING or poll:
             # our first few scans should always be a bus poll
             # this is because no events will be registered
-            log.debug(f"DeviceFinderUSB.find_usb_devices: just doing a bus poll for startup_scan {self.startup_scan}")
+            # log.debug(f"DeviceFinderUSB.find_usb_devices: just doing a bus poll for startup_scan {self.startup_scan}")
             device_ids = self.bus_polling()
             self.startup_scan += 1
         elif platform.system() == "Windows":
@@ -177,7 +177,7 @@ class DeviceFinderUSB:
             device_ids = self.linux_monitoring()
         else:
             device_ids = self.bus_polling()
-        log.debug(f"DeviceFinderUSB.find_usb_devices: returning {len(device_ids)} devices")
+        # log.debug(f"DeviceFinderUSB.find_usb_devices: returning {len(device_ids)} devices")
         return device_ids
 
     def mac_monitoring(self):