wasatch 2.3.6__tar.gz → 2.3.8__tar.gz

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

@@ -1,5 +1,17 @@
 # Changelog
 
+- 2026-01-12 2.3.8
+    - added settings.has_detector
+    - improved support for Andor .json "virtual EEPROMs"
+    - bump internal WrapperWorker poll rate from 20Hz to 200Hz
+    - retain debug logging for 20sec after connection (vs previous 10sec)
+    - only update Andor detector temperature at 1Hz
+    - improved support for using 220250 boards as standalone laser drivers w/o 
+      detectors (added Reading.keep_alive to indicate metadata but no spectra)
+- 2025-12-10 2.3.7
+    - added EEPROM.is_oem
+    - fixed TCPDevice.set_detector_gain and set_vertical_roi
+    - disable use of eeprom.actual_pixels_horizontal during acquisition
 - 2025-11-06 2.3.6
     - resolve hotplug race condition when laser power set in percent
     - cache certain device getters to avoid I2C overruns

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wasatch
-Version: 2.3.6
+Version: 2.3.8
 Summary: Application-level driver for Wasatch Photonics spectrometers
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown

wasatch-2.3.8/demo-ids-raman.py

@@ -0,0 +1,281 @@
+#!/usr/bin/env python
+################################################################################
+#                              demo-ids-raman.py                               #
+################################################################################
+#                                                                              #
+#  DESCRIPTION:  Simple cmd-line demo to control an XS spectrometer using IDS  #
+#                detector and 220250 Rev4 laser driver.                        #
+#                                                                              #
+#  NOTES: This is for the fairly unusual case of having an XS bench built with #
+#         an IDS camera (providing its own USB3 port for comms and control),   #
+#         plus a 220250 Rev4 PCB for use as a standalone laser driver (but w/o #
+#         an IMX385 detector connected).                                       #
+#                                                                              #
+################################################################################
+
+# DEPENDENCIES: pywin32, psutil, seabreeze, pyftdi, crcmod, bleak
+
+import os
+import re
+import sys
+import time
+import numpy as np
+import signal
+import logging
+import argparse
+
+from datetime import datetime
+from time import sleep
+
+import wasatch
+from wasatch                      import applog
+from wasatch.DeviceID             import DeviceID
+from wasatch.IDSDevice            import IDSDevice
+from wasatch.WasatchBus           import WasatchBus
+from wasatch.WasatchDevice        import WasatchDevice
+
+log = logging.getLogger(__name__)
+demo = None
+
+class WasatchDemo:
+
+    def __init__(self):
+        self.camera_device = None   # a wasatch.IDSDevice wrapping a wasatch.IDSCamera (as 'camera')
+        self.laser_device = None    # a wasatch.WasatchDevice wrapping a wasatch.FeatureIdentificationDevice (as 'hardware')
+        self.reading_count = 0
+        self.exiting = False
+
+        self.args = self.parse_args()
+
+        print(f"Wasatch.PY {wasatch.__version__} IDS Raman Demo")
+
+    def parse_args(self):
+        parser = argparse.ArgumentParser(description="Simple demo to acquire spectra from command-line interface")
+        parser.add_argument("--log-level",           type=str, default="INFO", help="logging level", choices=["DEBUG","INFO","WARNING","ERROR","CRITICAL","NEVER"])
+        parser.add_argument("--integration-time-ms", type=int, default=1000,   help="integration time (ms, default 10)")
+        parser.add_argument("--take-dark",           action="store_true",      help="first measurement is used for dark subtraction")
+        parser.add_argument("--enable-laser",        action="store_true",      help="fire laser (after optional dark)")
+        parser.add_argument("--max",                 type=int, default=0,      help="max spectra to acquire (default 0, unlimited)")
+        parser.add_argument("--save-spectra",        action="store_true",      help="save vertically-binned spectra to row-ordered CSV")
+        parser.add_argument("--save-png",            action="store_true",      help="save PNG of each image frame")
+        parser.add_argument("--save-data",           action="store_true",      help="save 2D array of each image frame")
+        parser.add_argument("--save-dir",            type=str, default=".",    help="directory to save files")
+        parser.add_argument("--prefix",              type=str, default="ids-raman", help="filename prefix")
+
+        args = parser.parse_args()
+        applog.MainLogger(args.log_level)
+
+        return args
+        
+    def connect(self):
+
+        ########################################################################
+        # Look for laser driver board
+        ########################################################################
+
+        bus = WasatchBus()
+        if not bus.device_ids:
+            print("No Wasatch USB spectrometers found.")
+            return 
+
+        # look for laser driver on WasatchBus -- we won't see the camera here,
+        # because IDSPeak devices are not automatically considered for inclusion
+        # by WasatchBus (although they could be)
+        for device_id in bus.device_ids:
+            log.debug("connect: trying to connect to %s", device_id)
+            device = WasatchDevice(device_id)
+            ok = device.connect()
+            if not ok:
+                log.critical("connect: can't connect to %s", device_id)
+                continue
+
+            log.debug(f"connect: connected to {device_id} ({device})")
+            if device.settings is None:
+                log.error("can't have device without SpectrometerSettings")
+                continue
+
+            print(f"connected to {device.settings.full_model()} {device.settings.eeprom.serial_number} with {device.settings.pixels()} pixels " +
+                  f"from ({device.settings.wavelengths[0]:.2f}, {device.settings.wavelengths[-1]:.2f}nm)" +
+                  (   f" ({device.settings.wavenumbers[0]:.2f}, {device.settings.wavenumbers[-1]:.2f}cm⁻¹)" if device.settings.has_excitation() else "") +
+                  f" (Microcontroller {device.settings.microcontroller_firmware_version}," +
+                  f" FPGA {device.settings.fpga_firmware_version})")
+
+            self.laser_device = device
+            break
+
+        if self.laser_device is None:
+            log.critical("could not find laser driver, exitting")
+            return 
+
+        ########################################################################
+        # now look for an IDS camera
+        ########################################################################
+
+        try:
+            device_id = DeviceID(label="IDSPeak")
+            device = IDSDevice(device_id=device_id, scratch_dir=".", consumer_deletes_area_scan_image=True)
+            if device.connect():
+                self.camera_device = device
+            else:
+                log.error("failed connecting to IDSCamera")
+        except:
+            log.critical("exception connecting to IDS camera", exc_info=1)
+            return
+
+        if self.camera_device is None:
+            log.critical("could not find IDS camera, exitting")
+            return
+
+        device   = self.camera_device
+        camera   = device.camera
+        settings = device.settings
+        eeprom   = settings.eeprom
+
+        device.set_area_scan_enable(True)
+
+        # copy the laser excitation over to the camera "virtual EEPROM" so we can 
+        # compute wavenumbers
+        eeprom.excitation_nm = self.laser_device.settings.eeprom.excitation_nm
+        settings.update_wavecal()
+        print(f"connected to IDSPeak camera {eeprom.model} {eeprom.serial_number} with {camera.width}x{camera.height} pixels " +
+               f"from ({settings.wavelengths[0]:.2f}, {settings.wavelengths[-1]:.2f}nm)" +
+               (   f" ({settings.wavenumbers[0]:.2f}, {settings.wavenumbers[-1]:.2f}cm⁻¹)" if settings.has_excitation() else ""))
+
+        return True
+
+    ############################################################################
+    #                                                                          #
+    #                               Run-Time Loop                              #
+    #                                                                          #
+    ############################################################################
+
+    def run(self):
+        self.camera_device.set_integration_time_ms(self.args.integration_time_ms)
+
+        # initialize outfile if saving spectra
+        outfile = None
+        if self.args.save_spectra:
+            filename = os.path.join(self.args.save_dir, self.args.prefix + "-spectra.csv")
+            outfile = open(filename, "w")
+            outfile.write("pixels,      0, " + ", ".join([f"{x}" for x in range(self.camera_device.settings.pixels())]) + "\n")
+            outfile.write("wavelengths, 0, " + ", ".join([f"{x:.2f}" for x in self.camera_device.settings.wavelengths]) + "\n")
+            outfile.write("wavenumbers, 0, " + ", ".join([f"{x:.2f}" for x in self.camera_device.settings.wavenumbers]) + "\n")
+            outfile.write("time,    count, spectrum\n")
+
+        # read spectra until user presses Control-Break
+        while not self.exiting and (self.args.max == 0 or self.reading_count < self.args.max):
+
+            ####################################################################
+            # check to fire laser
+            ####################################################################
+
+            # on the first reading (or the second, if taking dark), enable the 
+            # laser if requested
+            if (self.args.enable_laser and (self.reading_count == 0 or (self.args.take_dark and self.reading_count == 1))):
+                print("enabling laser")
+                self.laser_device.hardware.set_laser_enable(True)
+
+            ####################################################################
+            # read image
+            ####################################################################
+
+            if self.exiting:
+                break
+
+            response = self.camera_device.acquire_data()
+            if response.keep_alive:
+                log.debug(f"ignoring keepalive from {device}")
+                continue
+
+            if isinstance(response.data, bool):
+                if response.data:
+                    log.debug("received poison-pill, exiting")
+                    break
+                else:
+                    log.debug("no reading available")
+                    continue
+
+            if response.data.failure:
+                log.debug("reading indicated failure")
+                break
+
+            if self.exiting:
+                break
+
+            self.reading_count += 1
+
+            reading = response.data
+            spectrum = reading.spectrum
+            settings = self.camera_device.settings
+            asi = reading.area_scan_image
+            ts = reading.timestamp.strftime("%Y%m%d-%H%M%S-%f")
+
+            # print some stats as we go
+            spectrum_min = np.amin(spectrum)
+            spectrum_max = np.amax(spectrum)
+            spectrum_avg = np.mean(spectrum)
+            spectrum_std = np.std (spectrum)
+            print(f"{ts}: {self.reading_count:4d} : min {spectrum_min:8.2f}, max {spectrum_max:8.2f}, avg {spectrum_avg:8.2f}, stdev {spectrum_std:8.2f}")
+
+            # append to row-ordered file
+            if outfile:
+                values = ",".join(format(x, ".2f") for x in spectrum)
+                outfile.write(f"{reading.timestamp}, {self.reading_count}, {values}\n")
+
+            # save PNG
+            if self.args.save_png and asi.pathname_png:
+                filename = os.path.join(self.args.save_dir, f"{self.args.prefix}-{self.reading_count:04d}.png")
+                log.debug(f"renaming {asi.pathname_png} -> {filename}")
+                os.replace(asi.pathname_png, filename)
+                print(f"\tsaved {filename}")
+
+            # save area scan data
+            if self.args.save_data and asi.data is not None:
+                filename = os.path.join(self.args.save_dir, f"{self.args.prefix}-{self.reading_count:04d}.csv")
+                np.savetxt(filename, asi.data, fmt='%d', delimiter=",")
+                print(f"\tsaved {filename}")
+
+            if self.args.take_dark and self.reading_count == 1:
+                print("\tsaving dark")
+                self.camera_device.camera.set_dark_asi(asi)
+
+################################################################################
+# main()
+################################################################################
+
+def signal_handler(signal, frame):
+    print('\rInterrupted by Ctrl-C...shutting down', end=' ')
+    shutdown()
+
+def shutdown():
+    if demo:
+        demo.exiting = True
+        if demo.laser_device is not None:
+            demo.laser_device.hardware.set_laser_enable(False)
+            demo.laser_device.disconnect()
+
+        if demo.camera_device is not None:
+            demo.camera_device.disconnect()
+            sleep(1)
+
+    log.debug(None)
+    applog.explicit_log_close()
+    sys.exit()
+
+if __name__ == "__main__":
+    # add a signal-handler to catch ctrl-C interrupts, so we can cleanly close 
+    # down all connected devices
+    signal.signal(signal.SIGINT, signal_handler)
+
+    demo = WasatchDemo()
+    if demo.connect():
+        # Note that on Windows, Control-Break (SIGBREAK) differs from 
+        # Control-C (SIGINT); see https://stackoverflow.com/a/1364199
+        log.debug("Press Control-Break to interrupt...")
+        try:
+            demo.run()
+        except:
+            # catch exception so shutdown will run and disable laser
+            log.error("Caught exception during demo", exc_info=1)
+
+    shutdown()

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

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

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

@@ -4,7 +4,7 @@ import json
 import numpy as np
 import struct
 import logging
-import datetime
+from datetime import datetime
 
 from ctypes import *
 
@@ -37,11 +37,11 @@ class AndorDevice(InterfaceDevice):
                                        |
                                 handle_requests
                                        |
-                                 ------------
-                                /   /  |  \  \  
+                                  -----------
+                                 |  |  |  |  |  
              { get_laser status, acquire, set_laser_watchdog, etc....}
-                                \   \  |  /  /
-                                 ------------
+                                 |  |  |  |  |  
+                                  -----------
                                        |
                          {self.driver.some_andor_sdk_call}
     @endverbatim
@@ -50,6 +50,7 @@ class AndorDevice(InterfaceDevice):
 
     SUCCESS = 20002             #!< see load_error_codes()
     SHUTTER_SPEED_MS = 50       #!< allow time for mechanical shutter to stabilize
+    TEMPERATURE_CACHE_SEC = 1.0
 
     def __init__(self, device_id, message_queue=None, alert_queue=None):
         # if passed a string representation of a DeviceID, deserialize it
@@ -83,13 +84,16 @@ class AndorDevice(InterfaceDevice):
         self.driver                 = None
 
         self.process_id = os.getpid()
-        self.last_memory_check = datetime.datetime.now()
+        self.last_memory_check = datetime.now()
         self.last_battery_percentage = 0
         self.spec_index = 0 
         self._scan_averaging = 1
         self.dark = None
         self.boxcar_half_width = 0
 
+        self.temperature_cache_value = None
+        self.temperature_cache_timestamp = None
+
         # decide appropriate DLL filename for architecture
         arch = 64 if 64 == struct.calcsize("P") * 8 else 32
         filename = f"atmcd{arch}d.dll"
@@ -344,34 +348,37 @@ class AndorDevice(InterfaceDevice):
 
     def get_detector_temperature_degC(self):
         if self.tec_enabled:
-            log.debug("TEC enabled, so reading temperature")
-
-            use_float = True    # seems to work on 785XL (WP-01635 and WP-01491)
-            if use_float:
-                c_temp = c_float()
-                result = self.driver.GetTemperatureF(byref(c_temp))
-            else:
-                c_temp = c_int()
-                result = self.driver.GetTemperature(byref(c_temp))
-
-                # MZ: why were we trying to use GetTemperatureF(float) here, when above it was GetTemperature(int)?
-                # temperature = c_float()
-                # temp_success = self.driver.GetTemperatureF(byref(temperature))
-                # reading.detector_temperature_degC = temperature.value
-
-            label = self.get_error_code(result)
-            
-            if label in [ "DRV_SUCCESS", 
-                          "DRV_TEMPERATURE_DRIFT",
-                          "DRV_TEMPERATURE_STABILIZED",
-                          "DRV_TEMPERATURE_NOT_REACHED",
-                          "DRV_TEMPERATURE_NOT_STABILIZED" ]:
-                detector_temperature_degC = c_temp.value
-                log.debug(f"Andor temperature {detector_temperature_degC:.2f} ({label})")
-                return detector_temperature_degC
+            log.debug("TEC enabled, so including temperature")
+
+            now = datetime.now()
+            if self.temperature_cache_timestamp is None or self.temperature_cache_value is None or (now - self.temperature_cache_timestamp).total_seconds() >= self.TEMPERATURE_CACHE_SEC:
+                # read new temperature
+                use_float = True    # seems to work on 785XL (WP-01635 and WP-01491)
+                if use_float:
+                    c_temp = c_float()
+                    result = self.driver.GetTemperatureF(byref(c_temp))
+                else:
+                    c_temp = c_int()
+                    result = self.driver.GetTemperature(byref(c_temp))
+
+                label = self.get_error_code(result)
+                if label in [ "DRV_SUCCESS", 
+                              "DRV_TEMPERATURE_DRIFT",
+                              "DRV_TEMPERATURE_STABILIZED",
+                              "DRV_TEMPERATURE_NOT_REACHED",
+                              "DRV_TEMPERATURE_NOT_STABILIZED" ]:
+                    self.temperature_cache_value = c_temp.value
+                    self.temperature_cache_timestamp = now
+                    log.debug(f"Andor temperature {self.temperature_cache_value:.2f} ({label})")
+                else:
+                    log.error(f"unable to read detector temperature, result was {label}")
+                    self.temperature_cache_value = None
+                    self.temperature_cache_timestamp = None
             else:
-                log.error(f"unable to read detector temperature, result was {label}")
+                # use cached value
+                pass
 
+            return self.temperature_cache_value
 
     def _close_ex_shutter(self):
         self.check_result(self.driver.SetShutterEx(1, 1, self.SHUTTER_SPEED_MS, self.SHUTTER_SPEED_MS, 2), "SetShutterEx(2)")

{wasatch-2.3.6 → wasatch-2.3.8}/wasatch/AreaScanImage.py

@@ -16,4 +16,4 @@ class AreaScanImage:
         AreaScanImage.FRAME_COUNT += 1
 
     def __repr__(self):
-        return f"AreaScanImage<frame {self.frame_count}, line_index {line_index}, width {self.width} (orig {self.width_orig}), height {self.height} (orig {self.height_orig}), format_name {self.format_name}, pathname_png {self.pathname_png}>"
+        return f"AreaScanImage<frame {self.frame_count}, line_index {self.line_index}, width {self.width} (orig {self.width_orig}), height {self.height} (orig {self.height_orig}), format_name {self.format_name}, pathname_png {self.pathname_png}>"

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

@@ -123,6 +123,8 @@ class EEPROM:
         self.sig_laser_tec               = False # better: sig_sml_laser_tec
         self.has_interlock_feedback      = False
         self.laser_interlock_excluded    = False # True if the unit has a laser, but the normal safety interlock has been removed or otherwise disabled (OEM-only)
+        self.laser_timeout_after_count   = False
+        self.is_oem                      = False
         self.has_shutter                 = False
         self.disable_ble_power           = False
         self.disable_laser_armed_indicator = False
@@ -506,6 +508,8 @@ class EEPROM:
             self.disable_ble_power             = 0 != self.feature_mask & 0x0100
             self.disable_laser_armed_indicator = 0 != self.feature_mask & 0x0200
             self.laser_interlock_excluded      = 0 != self.feature_mask & 0x0400
+            self.laser_timeout_after_count     = 0 != self.feature_mask & 0x0800
+            self.is_oem                        = 0 != self.feature_mask & 0x1000
         else:
             self.invert_x_axis                 = False 
             self.horiz_binning_enabled         = False
@@ -517,6 +521,9 @@ class EEPROM:
             self.has_shutter                   = False
             self.disable_ble_power             = False 
             self.disable_laser_armed_indicator = False
+            self.laser_interlock_excluded      = False
+            self.laser_timeout_after_count     = False
+            self.is_oem                        = False
 
         # ######################################################################
         # sanity checks
@@ -562,6 +569,8 @@ class EEPROM:
         mask |= 0x0100 if self.disable_ble_power             else 0
         mask |= 0x0200 if self.disable_laser_armed_indicator else 0
         mask |= 0x0400 if self.laser_interlock_excluded      else 0
+        mask |= 0x0800 if self.laser_timeout_after_count     else 0
+        mask |= 0x1000 if self.is_oem                        else 0
         return mask
 
     ##
@@ -860,6 +869,8 @@ class EEPROM:
                 else:
                     buf[start_byte + i] = 0
         else:
+            if data_type == "f":
+                value = float(value)
             struct.pack_into(data_type, buf, start_byte, value)
 
         if False:

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

@@ -66,11 +66,11 @@ class FeatureIdentificationDevice(InterfaceDevice):
                                        |
                                 handle_requests
                                        |
-                                 ------------
-                                /   /  |  \  \ 
+                                  -----------
+                                 |  |  |  |  | 
              { get_laser status, acquire, set_laser_watchdog, etc....}
-                                \   \  |  /  /
-                                 ------------
+                                 |  |  |  |  | 
+                                  -----------
                                        |
                                    _send_code
     @endverbatim
@@ -185,14 +185,14 @@ class FeatureIdentificationDevice(InterfaceDevice):
         # it doesn't know what PIDs it might be looking for.  We know, so just
         # narrow down the search to those devices.
 
-        log.info(f"FID.connect: asked to connect to device_type {self.device_type}")
-        log.info(f"FID.connect: calling device_type.find, looking for VID 0x{self.device_id.vid:04x} and PID 0x{self.device_id.pid:04x}")
+        log.debug(f"FID.connect: asked to connect to device_type {self.device_type}")
+        log.debug(f"FID.connect: calling device_type.find, looking for VID 0x{self.device_id.vid:04x} and PID 0x{self.device_id.pid:04x}")
         devices = self.device_type.find(find_all=True, idVendor=self.device_id.vid, idProduct=self.device_id.pid)
-        log.info(f"FID.connect: found devices {devices}")
+        log.debug(f"FID.connect: found devices {devices}")
         dev_list = list(devices) # convert from array
 
         device = None
-        log.info(f"searching for specified device in dev_list {dev_list}")
+        log.debug(f"searching for specified device in dev_list {dev_list}")
         for dev in dev_list:
             if dev.bus != self.device_id.bus:
                 log.debug("FID.connect: rejecting device (bus %d != requested %d)", dev.bus, self.device_id.bus)
@@ -475,7 +475,7 @@ class FeatureIdentificationDevice(InterfaceDevice):
 
         self.connected = False
 
-        log.critical("fid.disconnect: releasing interface")
+        log.debug("fid.disconnect: releasing interface")
         try:
             #result = self.device_type.release_interface(self.device, 0)
             try:
@@ -520,7 +520,7 @@ class FeatureIdentificationDevice(InterfaceDevice):
         # I had to look at the full configuration string and saw that the way to get the instance id was the following
         # using _try_get_string https://github.com/pyusb/pyusb/blob/master/usb/core.py#L1221
         # so techincally we shouldn't do this by the _ meaning it should be private, but it's the only way I see
-        device_instance_id = f'USB\VID_{self.device_id.vid:04X}&PID_{self.device_id.pid:04X}\{usb.core._try_get_string(pyusb_devices[0], pyusb_devices[0].iSerialNumber)}'
+        device_instance_id = f'USB/VID_{self.device_id.vid:04X}&PID_{self.device_id.pid:04X}/{usb.core._try_get_string(pyusb_devices[0], pyusb_devices[0].iSerialNumber)}'
         log.debug(f"In reset and restart trying to reset instance id {device_instance_id}")
         subprocess.run(["pnputil", r"/reboot", r"/disable-device", device_instance_id])
         subprocess.run(["pnputil", r"/reboot", r"/enable-device", device_instance_id])
@@ -1316,6 +1316,10 @@ class FeatureIdentificationDevice(InterfaceDevice):
                  when NOT in external-triggered mode
         @throws exception on timeout (unless external triggering enabled)
         """
+
+        if not self.settings.has_detector():
+            return SpectrometerResponse(keep_alive=True)
+
         response = SpectrometerResponse()
 
         if not self.is_sensor_stable():
@@ -1361,7 +1365,7 @@ class FeatureIdentificationDevice(InterfaceDevice):
         ########################################################################
 
         # this is the number of pixels we expect to read-out over USB
-        if self.settings.is_imx385():
+        if False and self.settings.is_imx385():
             # Currently, only the IMX385 uses horizontal binning, so for now 
             # limit code changes to that detector (even though they haven't been
             # shown to break other hardware)
@@ -1413,13 +1417,14 @@ class FeatureIdentificationDevice(InterfaceDevice):
                         pass
                     else:
                         errors += 1
-                        log.error(f"Encountered error on read of {exc}", exc_info=1)
+                        log.error(f"Encountered error {errors} on read of {exc}", exc_info=1)
 
                         # 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():
+                        # board. 
+                        if not self.settings.has_detector():
+                            pass
+                        elif errors < 3:
                             log.error(f"ignoring error number {errors}")
                         else:
                             response.error_msg = "Encountered error on read"
@@ -1621,7 +1626,7 @@ class FeatureIdentificationDevice(InterfaceDevice):
         return response
 
     def require_throwaway(self, flag):
-        if flag and self.settings.is_xs() and self.remaining_throwaways < 1:
+        if flag and self.settings.is_xs() and self.remaining_throwaways < 1 and self.settings.has_detector():
             log.debug("queuing throwaways")
             self.remaining_throwaways += 1
 
@@ -1634,6 +1639,10 @@ class FeatureIdentificationDevice(InterfaceDevice):
         if not self.settings.is_xs():
             return SpectrometerResponse(False)
 
+        # MZ: Kludge, disabling while testing
+        log.debug("disabling internal averaging")
+        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 = n > 1
@@ -2999,13 +3008,13 @@ class FeatureIdentificationDevice(InterfaceDevice):
         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")
+            log.debug("set_vertical_roi: requires POSITIVE (start, stop) lines")
             return SpectrometerResponse(data=False, error_msg="invalid start and stop lines")
 
         # enforce ascending order (also, note that stop line is "last line binned + 1", so stop must be > start)
         if start >= end:
             # (start, end) = (end, start)
-            log.error("set_vertical_roi: requires ascending order (ignoring %d, %d)", start, end)
+            log.debug("set_vertical_roi: requires ascending order (ignoring %d, %d)", start, end)
             return SpectrometerResponse(data=False, error_msg="invalid start and stop lines")
 
         if self.settings.is_xs():