wasatch 2.3.2__tar.gz → 2.3.6__tar.gz

{wasatch-2.3.2 → wasatch-2.3.6}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+- 2025-11-06 2.3.6
+    - resolve hotplug race condition when laser power set in percent
+    - cache certain device getters to avoid I2C overruns
+    - stop trying to read laser temperature on FX2, it's never worked right
+- 2025-10-22 2.3.5
+    - don't loop on spectral read errors on XS
+- 2025-10-22 2.3.4
+    - ignore heartbeat on Andor
+- 2025-06-30 2.3.3
+    - Hamamatsu 2048px area scan
 - 2025-06-18 2.3.2
     - XS area scan
         - fixed off-by-one stop line

{wasatch-2.3.2 → wasatch-2.3.6}/Makefile

@@ -28,7 +28,11 @@ pip-install-local:
 	pip install $$PWD
 
 publish-test:
+	@echo REMINDER to keep .toml in sync with __init__.py!
+	@echo 
 	flit publish --repository testpypi
 
 publish:
+	@echo REMINDER to keep .toml in sync with __init__.py!
+	@echo 
 	flit publish

{wasatch-2.3.2 → wasatch-2.3.6}/PKG-INFO

@@ -1,9 +1,10 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: wasatch
-Version: 2.3.2
+Version: 2.3.6
 Summary: Application-level driver for Wasatch Photonics spectrometers
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: six
 Requires-Dist: psutil

{wasatch-2.3.2 → wasatch-2.3.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wasatch"
-version = "2.3.2"
+version = "2.3.6"
 description= "Application-level driver for Wasatch Photonics spectrometers"
 requires-python = ">=3.9"
 readme = "README.md"

{wasatch-2.3.2 → wasatch-2.3.6}/wasatch/AndorDevice.py

@@ -188,7 +188,7 @@ class AndorDevice(InterfaceDevice):
         process_f["take_one_request"]           = self.set_take_one_request
 
         process_f["reset_scan_averaging"]       = self.not_implemented
-        process_f["heartbeat"]                  = self.not_implemented
+        process_f["heartbeat"]                  = lambda x: None
 
         ##################################################################
         # What follows is the old init-lambdas that are squashed into process_f

{wasatch-2.3.2 → wasatch-2.3.6}/wasatch/EEPROM.py

@@ -1446,5 +1446,8 @@ class EEPROMField:
         self.offset     = pos[1]
         self.length     = pos[2]
 
+    def __repr__(self): 
+        return str(self.__dict__)
+    
     def toJSON(self): 
         return str(self.__dict__)

{wasatch-2.3.2 → wasatch-2.3.6}/wasatch/FeatureIdentificationDevice.py

@@ -308,11 +308,23 @@ class FeatureIdentificationDevice(InterfaceDevice):
             return result
 
         # ######################################################################
-        # Automatically disable laser at connection
+        # Laser defaults
         # ######################################################################
 
-        # if self.settings.eeprom.has_laser:
-        #     self.set_laser_enable(False)
+        if self.settings.eeprom.has_laser:
+            log.debug("post_connect: setting laser defaults")
+            # MZ: why did we stop doing this?
+            # self.set_laser_enable(False)
+
+            self.settings.state.laser_power_mW = self.settings.eeprom.max_laser_power_mW
+            self.settings.state.laser_power_perc = 100
+            self.settings.state.use_mW = self.settings.eeprom.has_laser_power_calibration() and self.settings.is_mml()
+
+            log.debug(f"  laser_power_mW   {self.settings.state.laser_power_mW}")
+            log.debug(f"  laser_power_perc {self.settings.state.laser_power_perc}")
+            log.debug(f"  use_mW           {self.settings.state.use_mW}")
+
+            log.debug("post_connect: done setting laser defaults")
 
         # ######################################################################
         # TEC Setpoint
@@ -816,20 +828,21 @@ class FeatureIdentificationDevice(InterfaceDevice):
 
         try:
             self._wait_for_usb_available()
+            log.debug("%s_get_code: request 0x%02x value 0x%04x index 0x%04x length %d", prefix, bRequest, wValue, wIndex, wLength)
             result = self.device_type.ctrl_transfer(self.device,
                                                0xc0,        # DEVICE_TO_HOST
                                                bRequest,
                                                wValue,
                                                wIndex,
-                                               wLength)
+                                               wLength)     # add TIMEOUT_MS?
         except Exception as exc:
             log.critical(f"Hardware Failure FID Get Code Problem with ctrl transfer (bRequest 0x{bRequest:02x}, wValue 0x{wValue:04x}, wIndex 0x{wIndex:04x}, label {label})", exc_info=1)
             self._schedule_disconnect(exc)
             return SpectrometerResponse(poison_pill=True)
 
         result_hex = " ".join([f"{v:02x}" for v in result])
-        log.debug("%s_get_code: request 0x%02x value 0x%04x index 0x%04x = [%s]",
-            prefix, bRequest, wValue, wIndex, result_hex)
+        log.debug("%s_get_code: request 0x%02x value 0x%04x index 0x%04x length %d = [%s]",
+            prefix, bRequest, wValue, wIndex, wLength, result_hex)
 
         if result is None:
             log.critical("_get_code[%s, %s]: received null", label, self.device_id)
@@ -1135,10 +1148,10 @@ class FeatureIdentificationDevice(InterfaceDevice):
         self.settings.state.area_scan_line_step = n
         return self.i2c_write(0x17, [n], label="SET_AREA_SCAN_LINE_STEP")
 
-    # MZ: I don't remember what boards / firmware supports this?
+    # MZ: I don't remember what boards / firmware supports this? How does this differ from interval?
     def set_area_scan_line_count(self, n):
         self.debug(f"setting line count to {n}")
-        self.dev.ctrl_transfer(H2D, 0xa6, n, 0, Z, TIMEOUT) 
+        self.dev.ctrl_transfer(H2D, 0xa6, n, 0, Z)
         return self._send_code(0xa6, n, label="SET_AREA_SCAN_LINE_COUNT")
 
     # MZ: I don't remember what boards / firmware supports this?
@@ -1401,7 +1414,12 @@ class FeatureIdentificationDevice(InterfaceDevice):
                     else:
                         errors += 1
                         log.error(f"Encountered error on read of {exc}", exc_info=1)
-                        if errors < 3:
+
+                        # Don't loop on errors on XS, so we can experimentally 
+                        # use an XS board as a detector-less laser/TEC driver 
+                        # board. (A better solution would be to add FeatureMask.
+                        # has_detector or similar, this works for now.)
+                        if errors < 3 and not self.settings.is_xs():
                             log.error(f"ignoring error number {errors}")
                         else:
                             response.error_msg = "Encountered error on read"
@@ -1608,12 +1626,17 @@ class FeatureIdentificationDevice(InterfaceDevice):
             self.remaining_throwaways += 1
 
     def set_onboard_scans_to_average(self, n):
+        """ 
+        This is provided to let ENLIGHTEN *turn off* onboard averaging settings 
+        which might have been generated, and (deliberately) left in place after 
+        an Auto-Raman measurement.
+        """
         if not self.settings.is_xs():
             return SpectrometerResponse(False)
 
         retval = self._send_code(0xff, 0x62, n, label="SET_ONBOARD_SCANS_TO_AVERAGE")
         self.settings.state.scans_to_average = n
-        self.settings.state.onboard_averaging = True
+        self.settings.state.onboard_averaging = n > 1
         return retval
 
     def get_scans_to_average(self):
@@ -1673,6 +1696,7 @@ class FeatureIdentificationDevice(InterfaceDevice):
         return result
 
     def i2c_write(self, address, buf, label=""):
+        # return log.debug(f"i2c_write: declining to send cmd 0x90, wValue {address}, wIndex {len(buf)}, data_or_wLength {buf}, label {label}")
         return self._send_code(0x90, wValue=address, wIndex=len(buf), data_or_wLength=buf, label=label)
 
     # ##########################################################################
@@ -1849,8 +1873,16 @@ class FeatureIdentificationDevice(InterfaceDevice):
         marker = 0xffff
         clamp = 0xfffe
         lines = 69
-        line_len = self.settings.pixels() * 2
-        timeout_ms = self.generate_timeout_ms()
+        line_index = -1
+        pixels = self.settings.pixels()
+        line_len = pixels * 2
+        timeout_ms = self.generate_timeout_ms() + 10
+
+        endpoints = [0x82]
+        block_len_bytes = line_len
+        if pixels == 2048 and not self.settings.is_arm():
+            endpoints = [0x82, 0x86]
+            block_len_bytes = 2048 # 1024 pixels apiece from two endpoints
 
         # request a frame
         self._send_code(0xad, label="ACQUIRE_SPECTRUM")
@@ -1866,10 +1898,14 @@ class FeatureIdentificationDevice(InterfaceDevice):
             try:
                 while len(data) < line_len:
                     bytes_remaining = line_len - len(data)
-                    # @todo expand this to 0x86 for S16011-1101
-                    latest_data = self.device_type.read(self.device, 0x82, bytes_remaining, timeout=timeout_ms)
+                    bytes_to_read = min(bytes_remaining, block_len_bytes)
+                    ep_index = 1 if len(endpoints) > 1 and len(data) >= 1024 else 0
+
+                    # log.debug(f"get_area_scan_hamamatsu: attempting to read {bytes_to_read} from 0x{endpoints[ep_index]:02x}")
+                    latest_data = self.device_type.read(self.device, endpoints[ep_index], bytes_to_read, timeout=timeout_ms)
                     data.extend(latest_data) 
             except:
+                # this still happens periodically
                 log.error(f"get_area_scan_hamamatsu {prefix}: error reading line {line}", exc_info=1)
                 break
 
@@ -1903,8 +1939,11 @@ class FeatureIdentificationDevice(InterfaceDevice):
             spectrum[1] = spectrum[2] # stomp
 
             # store line in image
-            self.area_scan_frame[line_index] = spectrum
-            # self.debug(f"{prefix}: stored line {line_index}: {spectrum[:5]}")
+            if 0 <= line_index < len(self.area_scan_frame):
+                log.debug(f"get_area_scan_hamamatsu {prefix}: storing line {line_index}: {spectrum[:5]}")
+                self.area_scan_frame[line_index] = spectrum
+            else:
+                log.warn(f"get_area_scan_hamamatsu {prefix}: dropping line {line_index}: {spectrum[:5]}")
             
             line_count += 1
 
@@ -1915,7 +1954,9 @@ class FeatureIdentificationDevice(InterfaceDevice):
         # store full-frame image data for Area Scan
         data = np.array(self.area_scan_frame, dtype=np.float32, copy=True)
         data -= data.min() # remove baseline
-        asi = AreaScanImage(data=data, width=len(data[0]), height=len(data))
+        if self.settings.eeprom.invert_x_axis:
+            data = np.rot90(data, k=2)
+        asi = AreaScanImage(data=data, width=len(data[0]), height=len(data), line_index=line_index)
 
         # vertically bin within vertical ROI for live graph
         start = self.settings.eeprom.roi_vertical_region_1_start
@@ -1983,7 +2024,7 @@ class FeatureIdentificationDevice(InterfaceDevice):
         if self.settings.state.selected_adc is None or self.settings.state.selected_adc != 1:
             self.select_adc(1)
 
-        result = self._get_code(0xd5, wLength=2, label="GET_ADC", lsb_len=2)
+        result = self._get_code(0xd5, wLength=2, label="GET_ADC (secondary)", lsb_len=2)
         log.debug("secondary_adc_raw: 0x%04x", result)
         return result
 
@@ -2178,7 +2219,18 @@ class FeatureIdentificationDevice(InterfaceDevice):
 
     ## @note big-endian, reverse of get_laser_temperature_raw
     def get_detector_temperature_raw(self):
-        return self._get_code(0xd7, label="GET_CCD_TEMP", msb_len=2)
+        # - don't poll detector temperature faster than 10Hz...analyzing performance on FX2
+        last = self.settings.state.detector_temperature_raw_last_refreshed 
+        now = datetime.datetime.now()
+        if last is not None and (now - last).total_seconds() < 0.1:
+            raw = self.settings.state.detector_temperature_raw
+            log.debug("get_detector_temperature_raw: using cached {raw}")
+            return raw
+        raw = self._get_code(0xd7, wLength=2, label="GET_CCD_TEMP", msb_len=2)
+        self.settings.state.detector_temperature_raw = raw
+        self.settings.state.detector_temperature_raw_last_refreshed = now
+        log.debug("get_detector_temperature_raw: storing {raw}")
+        return raw
 
     def get_detector_temperature_degC(self, raw: float = None):
         if raw is None:
@@ -2339,12 +2391,16 @@ class FeatureIdentificationDevice(InterfaceDevice):
 
     def get_laser_temperature_raw(self):
         """ @note little-endian, reverse of get_detector_temperature_raw """
+        # this is currently unreliable on most (all?) Hamamatsu units, so why bother
+        if not self.settings.is_xs():
+            return SpectrometerResponse(0)
+
         # flip to primary ADC if needed
         if self.settings.state.selected_adc is None or self.settings.state.selected_adc != 0:
             # MZ: unclear if this is needed on SiG
             self.select_adc(0)
 
-        result = self._get_code(0xd5, wLength=2, label="GET_ADC", lsb_len=2)
+        result = self._get_code(0xd5, wLength=2, label="GET_ADC (laser)", lsb_len=2)
         if not result.data:
             log.debug("Unable to read laser temperature")
             return SpectrometerResponse(0)
@@ -2381,11 +2437,21 @@ class FeatureIdentificationDevice(InterfaceDevice):
             # MZ: get_laser_enabled not currently robust on SiG :-(
             return SpectrometerResponse(data=self.settings.state.laser_enabled)
 
-        res = self._get_code(0xe2, label="GET_LASER_ENABLED", msb_len=1)
+        # - don't poll laser faster than 100Hz...analyzing performance on FX2
+        # - seems to be double-polled due to is_laser_firing()
+        last = self.settings.state.laser_enabled_last_refreshed
+        now = datetime.datetime.now()
+        if last is not None and (now - last).total_seconds() < 0.01:
+            flag = self.settings.state.laser_enabled
+            log.debug(f"get_laser_enabled: using cached {flag}")
+            return SpectrometerResponse(data=flag)
+
+        res = self._get_code(0xe2, wLength=1, label="GET_LASER_ENABLED", msb_len=1)
         flag = 0 != res.data
 
-        log.debug(f"get_laser_enabled: {flag} (storing to {self.settings.state})")
+        log.debug(f"get_laser_enabled: {flag} (storing to self.settings.state)")
         self.settings.state.laser_enabled = flag
+        self.settings.state.laser_enabled_last_refreshed = now
         return SpectrometerResponse(data=flag)
 
     def set_laser_enable(self, flag: bool):
@@ -2912,6 +2978,8 @@ class FeatureIdentificationDevice(InterfaceDevice):
                 self.set_vertical_roi(roi)
 
     def set_vertical_roi(self, roi):
+        log.debug(f"set_vertical_roi: {roi}")
+
         # check for legacy SiG-VIS since it didn't like vertical binning
         if self.settings.fpga_firmware_version == "000-008" and self.settings.microcontroller_firmware_version == "0.1.0.7":
             return SpectrometerResponse(data=False)
@@ -2928,6 +2996,7 @@ class FeatureIdentificationDevice(InterfaceDevice):
         else:
             log.error("set_vertical_roi: requires an ROI object or tuple of (start, stop) lines")
             return SpectrometerResponse(data=False, error_msg="invalid start and stop lines")
+        log.debug(f"set_vertical_roi: start {start}, end {end}")
 
         if start < 0 or end < 0:
             log.error("set_vertical_roi: requires POSITIVE (start, stop) lines")
@@ -2947,6 +3016,9 @@ class FeatureIdentificationDevice(InterfaceDevice):
             # FX2 lacks USB opcodes for start/stop line, so use I2C Poke (clamp to 1 byte)
             start = int(max(0, min(255, start)))
             end   = int(max(0, min(255, end  )))
+
+            # start = max(1, start) # kludge
+
             self.i2c_write(0x29, [start], label="I2C_POKE(SET_CCD_START_LINE)")
             self.i2c_write(0x2A, [end],   label="I2C_POKE(SET_CCD_STOP_LINE)")
 

{wasatch-2.3.2 → wasatch-2.3.6}/wasatch/SpectrometerSettings.py

@@ -237,7 +237,7 @@ class SpectrometerSettings:
         # order in the current codebase."
 
         coeffs = self.eeprom.multi_wavelength_calibration.get("raman_intensity_coeffs")
-        log.debug("update_raman_intensity_factors: coeffs {coeffs}")
+        log.debug(f"update_raman_intensity_factors: coeffs {coeffs}")
         if coeffs is None or coeffs == []:
             return
 
@@ -256,7 +256,7 @@ class SpectrometerSettings:
         except:
             log.error(f"exception generating Raman intensity factors (coeffs {coeffs})", exc_info=1)
             self.raman_intensity_factors = None
-        log.debug("generated {len(self.raman_intensity_factors)} Raman intensity factors")
+        log.debug(f"generated {len(self.raman_intensity_factors)} Raman intensity factors")
 
     def set_linear_pixel_calibration(self, data):
         self.linear_pixel_calibration = None

{wasatch-2.3.2 → wasatch-2.3.6}/wasatch/SpectrometerState.py

@@ -29,12 +29,15 @@ class SpectrometerState:
         # TEC       @todo rename detector_tec...
         self.tec_setpoint_degC = 15 # that's a very strange default...
         self.tec_enabled = False
+        self.detector_temperature_raw = None
+        self.detector_temperature_raw_last_refreshed = None
 
         # high gain mode (InGaAs only)
         self.high_gain_mode_enabled = False
 
         # laser
         self.laser_enabled = False
+        self.laser_enabled_last_refreshed = None
         self.laser_power_mW = None  # if last set in mW, will contain setpoint in mW; else will be None
         self.laser_power_perc = 0   # should always contain a number [0, 100]
         self.use_mW = False         # bool

{wasatch-2.3.2 → wasatch-2.3.6}/wasatch/WasatchDeviceWrapper.py

@@ -233,7 +233,7 @@ class WasatchDeviceWrapper:
 
         self.wrapper_worker.daemon = True
 
-        log.debug("deivce wrapper: starting WrapperWorker thread")
+        log.debug("device wrapper: starting WrapperWorker thread")
         self.wrapper_worker.start()
 
         # expect to read a single post-initialization SpectrometerSettings object off the queue

{wasatch-2.3.2 → wasatch-2.3.6}/wasatch/__init__.py

@@ -1,4 +1,4 @@
 """This package provides control of Wasatch Photonics spectrometers"""
 
-__version__ = "2.3.2"   # used by flit and other pypi things
+__version__ = "2.3.6"   # used by flit and other pypi things
 version = __version__   # legacy alias