wasatch 2.1.65__tar.gz → 2.2.0__tar.gz

{wasatch-2.1.65 → wasatch-2.2.0}/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+- 2024-08-22 2.2.0
+    - cutting release for ENLIGHTEN 4.1.0
+- 2024-06-27 2.1.73
+    - update demo.py to support multiple spectrometers
+    - add optional `callback` parameter to WrapperWorker for Inversion of Control (IoC)
+- 2024-06-27 2.1.72
+    - temporarily disable GET_LASER_ENABLED on XS
+- 2024-06-19 2.1.71
+    - disable applog to stdout if stdout missing
+- 2024-06-12 2.1.70
+    - force laser to disable on perc/PWM zero
+- 2024-05-30 2.1.69
+    - added avg_resolution to edittable EEPROM fields
+- 2024-05-24 2.1.68
+    - added horizontal ROI to XL virtual EEPROM
+    - Raspberry Pi testing (no change)
+- 2024-05-22 2.1.67
+    - relax thread logging 10sec after successful connection
+    - display connected spectrometer properties in demo.py
+- 2024-05-07 2.1.66
+    - gave TakeOneRequest a copy-ctor
 - 2024-05-02 2.1.65
     - updated README links to work on pypi servers
 - 2024-05-02 2.1.64

{wasatch-2.1.65 → wasatch-2.2.0}/PKG-INFO

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

{wasatch-2.1.65 → wasatch-2.2.0}/demo.py

@@ -31,7 +31,6 @@ import wasatch
 from wasatch import utils
 from wasatch import applog
 from wasatch.WasatchBus           import WasatchBus
-from wasatch.OceanDevice          import OceanDevice
 from wasatch.WasatchDevice        import WasatchDevice
 from wasatch.WasatchDeviceWrapper import WasatchDeviceWrapper
 from wasatch.RealUSBDevice        import RealUSBDevice
@@ -48,14 +47,16 @@ class WasatchDemo:
 
     def __init__(self, argv=None):
         self.bus     = None
-        self.device  = None
+        self.devices = {}
         self.logger  = None
         self.outfile = None
         self.exiting = False
+        self.reading_count = 0
 
         self.args = self.parse_args(argv)
 
-        self.logger = applog.MainLogger(self.args.log_level)
+        if self.args.log_level != "NEVER":
+            self.logger = applog.MainLogger(self.args.log_level)
         log.info("Wasatch.PY version %s", wasatch.__version__)
 
     ############################################################################
@@ -66,7 +67,7 @@ class WasatchDemo:
 
     def parse_args(self, argv):
         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 [DEBUG,INFO,WARNING,ERROR,CRITICAL]")
+        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=10,     help="integration time (ms, default 10)")
         parser.add_argument("--scans-to-average",    type=int, default=1,      help="scans to average (default 1)")
         parser.add_argument("--boxcar-half-width",   type=int, default=0,      help="boxcar half-width (default 0)")
@@ -83,11 +84,7 @@ class WasatchDemo:
             print("Wasatch.PY %s" % wasatch.__version__)
             sys.exit(0)
 
-        # normalize log level
         args.log_level = args.log_level.upper()
-        if not re.match("^(DEBUG|INFO|ERROR|WARNING|CRITICAL)$", args.log_level):
-            print("Invalid log level: %s (defaulting to INFO)" % args.log_level)
-            args.log_level = "INFO"
 
         return args
         
@@ -98,12 +95,7 @@ class WasatchDemo:
     ############################################################################
 
     def connect(self):
-        """ If the current device is disconnected, and there is a new device, 
-            attempt to connect to it. """
-
-        # if we're already connected, nevermind
-        if self.device is not None:
-            return
+        """ Connect to all discoverable Wasatch spectrometers.  """
 
         # lazy-load a USB bus
         if self.bus is None:
@@ -114,35 +106,43 @@ class WasatchDemo:
             print("No Wasatch USB spectrometers found.")
             return 
 
-        device_id = self.bus.device_ids[0]
-        log.debug("connect: trying to connect to %s", device_id)
-        device_id.device_type = RealUSBDevice(device_id)
-
-        if self.args.non_blocking:
-            # this is still buggy on MacOS
-            log.debug("instantiating WasatchDeviceWrapper (non-blocking)")
-            device = WasatchDeviceWrapper(
-                device_id = device_id,
-                log_queue = self.logger.log_queue,
-                log_level = self.args.log_level)
-        else:
-            log.debug("instantiating WasatchDevice (blocking)")
-            if device_id.vid == 0x24aa:
-                device = WasatchDevice(device_id)
+        for device_id in self.bus.device_ids:
+            log.debug("connect: trying to connect to %s", device_id)
+
+            if self.args.non_blocking:
+                # Non-blocking means we instantiate a WasatchDeviceWrapper (WDW)
+                # The WDW incapsulates its own threading.Thread (WrapperWorker)
+                # which continuously acquires spectra free-running mode.
+                log.debug("instantiating WasatchDeviceWrapper (non-blocking)")
+                device = WasatchDeviceWrapper(
+                    device_id = device_id,
+                    log_level = self.args.log_level,
+                    callback = self.WrapperWorker_callback)
             else:
-                device = OceanDevice(device_id)
+                # We're going to place blocking calls to spectrometers, so we can
+                # instantiate a plain WasatchDevice (no need for WDW or WrapperWorker)
+                log.debug("instantiating WasatchDevice (blocking)")
+                device = WasatchDevice(device_id)
 
-        ok = device.connect()
-        if not ok:
-            log.critical("connect: can't connect to %s", device_id)
-            return
+            ok = device.connect()
+            if not ok:
+                log.critical("connect: can't connect to %s", device_id)
+                continue
 
-        log.debug("connect: device connected")
+            log.debug("connect: device connected")
+            if device.settings is None:
+                log.error("can't have device without SpectrometerSettings")
+                continue
 
-        self.device = device
-        self.reading_count = 0
+            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})")
 
-        return device
+            self.devices[str(device.device_id)] = device
+
+        return len(self.devices) > 0
 
     ############################################################################
     #                                                                          #
@@ -154,15 +154,15 @@ class WasatchDemo:
         log.info("Wasatch.PY %s Demo", wasatch.__version__)
 
         # apply initial settings
-        self.device.change_setting("integration_time_ms", self.args.integration_time_ms)
-        self.device.change_setting("scans_to_average", self.args.scans_to_average)
-        self.device.change_setting("detector_tec_enable", True)
+        for device_id, device in self.devices.items():
+            device.change_setting("integration_time_ms", self.args.integration_time_ms)
+            device.change_setting("scans_to_average", self.args.scans_to_average)
 
         # initialize outfile if one was specified
         if self.args.outfile:
             try:
                 self.outfile = open(self.args.outfile, "w")
-                self.outfile.write("time,temp,%s\n" % ",".join(format(x, ".2f") for x in self.device.settings.wavelengths))
+                self.outfile.write("time,temp,serial,spectrum\n")
             except:
                 log.error("Error initializing %s", self.args.outfile)
                 self.outfile = None
@@ -170,7 +170,9 @@ class WasatchDemo:
         # read spectra until user presses Control-Break
         while not self.exiting:
             start_time = datetime.datetime.now()
-            self.attempt_reading()
+            if not self.args.non_blocking:
+                for device_id, device in self.devices.items():
+                    self.attempt_reading(device)
             end_time = datetime.datetime.now()
 
             if self.args.max > 0 and self.reading_count >= self.args.max:
@@ -185,14 +187,13 @@ class WasatchDemo:
                     try:
                         time.sleep(float(sleep_ms) / 1000)
                     except:
-                        # log.critical("WasatchDemo.run sleep() caught an exception", exc_info=1)
                         self.exiting = True
 
         log.debug("WasatchDemo.run exiting")
 
-    def attempt_reading(self):
+    def attempt_reading(self, device):
         try:
-            reading_response = self.acquire_reading()
+            reading_response = self.acquire_reading(device)
         except:
             log.critical("attempt_reading caught exception", exc_info=1)
             self.exiting = True
@@ -213,23 +214,42 @@ class WasatchDemo:
 
         self.process_reading(reading_response.data)
 
-    def acquire_reading(self):
+    def acquire_reading(self, device):
         # We want the demo to effectively block on new scans, so keep
         # polling the subprocess until a reading is ready.  In other apps,
         # we could do other things (like respond to GUI events) if 
         # device.acquire_data() was None (meaning the next spectrum wasn't
         # yet ready).
         while True:
-            reading = self.device.acquire_data()
+            reading = device.acquire_data()
             if reading is None:
                 log.debug("waiting on next reading")
             else:
                 return reading
 
+    def WrapperWorker_callback(self, response):
+        if response is None:
+            log.error("WrapperWorker_callback received null SpectrometerResponse")
+            return
+
+        reading = response.data        
+        if reading is None:
+            log.error("WrapperWorker_callback received null Reading")
+            return
+
+        self.process_reading(reading)
+
     def process_reading(self, reading):
-        if self.args.scans_to_average > 1 and not reading.averaged:
+        if (self.exiting or 
+           (self.args.scans_to_average > 1 and not reading.averaged) or
+           (self.args.max > 0 and self.reading_count >= self.args.max)):
             return
 
+        device_id = reading.device_id
+        log.debug(f"received reading from device_id {device_id}")
+        device = self.devices[str(reading.device_id)]
+        settings = device.settings
+
         self.reading_count += 1
 
         if self.args.boxcar_half_width > 0:
@@ -238,7 +258,7 @@ class WasatchDemo:
             spectrum = reading.spectrum
 
         if self.args.ascii_art:
-            print("\n".join(wasatch.utils.ascii_spectrum(spectrum, rows=20, cols=80, x_axis=self.device.settings.wavelengths, x_unit="nm")))
+            print("\n".join(wasatch.utils.ascii_spectrum(spectrum, rows=20, cols=80, x_axis=settings.wavelengths, x_unit="nm")))
         else:
             spectrum_min = numpy.amin(spectrum)
             spectrum_max = numpy.amax(spectrum)
@@ -246,7 +266,9 @@ class WasatchDemo:
             spectrum_std = numpy.std (spectrum)
             size_in_bytes = psutil.Process(os.getpid()).memory_info().rss
 
-            print("Reading: %4d  Detector: %5.2f degC  Min: %8.2f  Max: %8.2f  Avg: %8.2f  StdDev: %8.2f  Memory: %11d" % (
+            print("%s: %s %4d  Detector: %5.2f degC  Min: %8.2f  Max: %8.2f  Avg: %8.2f  StdDev: %8.2f  Memory: %11d" % (
+                reading.timestamp,
+                settings.eeprom.serial_number,
                 self.reading_count,
                 reading.detector_temperature_degC,
                 spectrum_min,
@@ -257,8 +279,9 @@ class WasatchDemo:
             log.debug("%s", str(reading))
 
         if self.outfile:
-            self.outfile.write("%s,%.2f,%s\n" % (datetime.datetime.now(),
+            self.outfile.write("%s,%.2f,%s,%s\n" % (datetime.datetime.now(),
                                                  reading.detector_temperature_degC,
+                                                 settings.eeprom.serial_number,
                                                  ",".join(format(x, ".2f") for x in spectrum)))
 
 ################################################################################
@@ -272,9 +295,11 @@ def signal_handler(signal, frame):
 def clean_shutdown():
     log.debug("Exiting")
     if demo:
-        if demo.args and demo.args.non_blocking and demo.device:
-            log.debug("closing background thread")
-            demo.device.disconnect()
+        if demo.args.non_blocking and len(demo.devices):
+            for device_id, device in demo.devices.items():
+                log.debug(f"closing {device_id}")
+                device.disconnect()
+                time.sleep(1)
 
         if demo.logger:
             log.debug("closing logger")

{wasatch-2.1.65 → wasatch-2.2.0}/wasatch/AndorDevice.py

@@ -472,6 +472,8 @@ class AndorDevice(InterfaceDevice):
                    'invert_x_axis',
                    'wavelength_coeffs', 
                    'excitation_nm_float',
+                   'roi_horizontal_end',
+                   'roi_horizontal_start',
                    'raman_intensity_coeffs',
                    'raman_intensity_calibration_order',
                    'startup_temp_degC', 

{wasatch-2.1.65 → wasatch-2.2.0}/wasatch/EEPROM.py

@@ -113,37 +113,40 @@ class EEPROM:
         self.write_buffers = []
         self.digest = None
 
-        self.editable = [ "excitation_nm",
-                          "excitation_nm_float",
-                          "detector_gain",
-                          "detector_offset",
-                          "detector_gain_odd",
-                          "detector_offset_odd",
-                          "calibrated_by",
-                          "calibration_date", 
-                          "user_text",
-                          "wavelength_coeffs",
-                          "linearity_coeffs",
-                          "max_laser_power_mW",
-                          "min_laser_power_mW",
-                          "laser_power_coeffs",
-                          "bad_pixels",
-                          "bin_2x2",
-                          "gen15",
-                          "cutoff_filter_installed",
-                          "has_shutter",
-                          "laser_warmup_sec",
-                          "laser_watchdog_sec",
-                          "roi_horizontal_end",             
-                          "roi_horizontal_start",           
-                          "roi_vertical_region_1_end",      
-                          "roi_vertical_region_1_start",    
-                          "roi_vertical_region_2_end",      
-                          "roi_vertical_region_2_start",    
-                          "roi_vertical_region_3_end",      
-                          "roi_vertical_region_3_start",
-                          "raman_intensity_calibration_order",
-                          "raman_intensity_coeffs" ]
+        self.editable = [
+            "avg_resolution",
+            "bad_pixels",
+            "bin_2x2",
+            "calibrated_by",
+            "calibration_date",
+            "cutoff_filter_installed",
+            "detector_gain",
+            "detector_gain_odd",
+            "detector_offset",
+            "detector_offset_odd",
+            "excitation_nm",
+            "excitation_nm_float",
+            "gen15",
+            "has_shutter",
+            "laser_power_coeffs",
+            "laser_warmup_sec",
+            "laser_watchdog_sec",
+            "linearity_coeffs",
+            "max_laser_power_mW",
+            "min_laser_power_mW",
+            "raman_intensity_calibration_order",
+            "raman_intensity_coeffs",
+            "roi_horizontal_end",
+            "roi_horizontal_start",
+            "roi_vertical_region_1_end",
+            "roi_vertical_region_1_start",
+            "roi_vertical_region_2_end",
+            "roi_vertical_region_2_start",
+            "roi_vertical_region_3_end",
+            "roi_vertical_region_3_start",
+            "user_text",
+            "wavelength_coeffs",
+        ]
 
         self.init_raman_intensity_calibration()
         self.init_spline()
@@ -738,7 +741,7 @@ class EEPROM:
         else:
             struct.pack_into(data_type, buf, start_byte, value)
 
-        if True:
+        if False:
             extra = "" if label is None else (" (%s)" % label)
             log.debug("Packed (%d, %2d, %2d) '%s' value %s -> %s%s", 
                 page, start_byte, length, data_type, value, buf[start_byte:end_byte], extra)

{wasatch-2.1.65 → wasatch-2.2.0}/wasatch/FeatureIdentificationDevice.py

@@ -123,7 +123,6 @@ class FeatureIdentificationDevice(InterfaceDevice):
         self.shutdown_requested = False
 
         self.last_spectrum = None
-        self.spectrum_count = 0
         self.prev_pixels = None
 
         # in case of I2C collisions within the spectrometer, e.g. due to battery-LED status
@@ -201,6 +200,8 @@ class FeatureIdentificationDevice(InterfaceDevice):
             log.debug("on Windows, so NOT setting configuration and claiming interface")
         elif "macOS" in platform.platform():
             log.debug("on MacOS, so NOT setting configuration and claiming interface")
+        # elif "raspberrypi" in str(os.uname()):
+        #     log.debug("on Raspberry Pi, so NOT setting configuration and claiming interface")
         else:
             log.debug("on posix, so setting configuration and claiming interface")
 
@@ -1961,13 +1962,13 @@ class FeatureIdentificationDevice(InterfaceDevice):
         return SpectrometerResponse(data=self.settings.state.selected_laser)
 
     def get_laser_enabled(self):
-        res = self._get_code(0xe2, label="GET_LASER_ENABLED", msb_len=1)
-        flag = 0 != res.data
-
-        if self.device_id.pid == 0x4000:
+        if self.settings.is_xs():
             # 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)
+        flag = 0 != res.data
+
         log.debug(f"get_laser_enabled: {flag} (storing to {self.settings.state})")
         self.settings.state.laser_enabled = flag
         return SpectrometerResponse(data=flag)
@@ -2198,6 +2199,8 @@ class FeatureIdentificationDevice(InterfaceDevice):
 
         # don't want anything weird when passing over USB
         value = float(max(0, min(100, value)))
+        if value <= 0:
+            return set_laser_enable(False)
 
         # If full power (and allowed), disable modulation and exit
         if value >= 100:
@@ -2212,6 +2215,9 @@ class FeatureIdentificationDevice(InterfaceDevice):
         period_us = 1000 if self.settings.state.laser_power_high_resolution else 100
         width_us = int(round(1.0 * value * period_us / 100.0, 0)) # note that value is in range (0, 100) not (0, 1)
 
+        if width_us <= 0:
+            return set_laser_enable(False)
+
         # pulse width can't be longer than period, or shorter than 1us
         width_us = max(1, min(width_us, period_us))
 
@@ -2812,6 +2818,9 @@ class FeatureIdentificationDevice(InterfaceDevice):
             log.debug(msg)
             return
 
+        # MZ: just disable for now
+        # return
+
         if self.settings.microcontroller_firmware_version == "1.0.2.9":
             msg = "ambient temperature ARM requires newer firmware"
             log.debug(msg)

{wasatch-2.1.65 → wasatch-2.2.0}/wasatch/TakeOneRequest.py

@@ -5,12 +5,19 @@ import threading
 
 class TakeOneRequest:
 
-    def __init__(self, take_dark=False, enable_laser_before=False, disable_laser_after=False, laser_warmup_ms=0, scans_to_average=1):
-        self.take_dark = take_dark
-        self.enable_laser_before = enable_laser_before
-        self.disable_laser_after = disable_laser_after
-        self.laser_warmup_ms = laser_warmup_ms
-        self.scans_to_average = scans_to_average
+    def __init__(self, take_dark=False, enable_laser_before=False, disable_laser_after=False, laser_warmup_ms=0, scans_to_average=1, template=None):
+        if template is not None:
+            self.take_dark           = template.take_dark
+            self.enable_laser_before = template.enable_laser_before
+            self.disable_laser_after = template.disable_laser_after
+            self.laser_warmup_ms     = template.laser_warmup_ms
+            self.scans_to_average    = template.scans_to_average
+        else:
+            self.take_dark           = take_dark
+            self.enable_laser_before = enable_laser_before
+            self.disable_laser_after = disable_laser_after
+            self.laser_warmup_ms     = laser_warmup_ms
+            self.scans_to_average    = scans_to_average
 
         self.request_id = f"{os.getpid():05d}-{threading.get_native_id():05d}-{time.time_ns()}-{random.randrange(65536):05d}"
 

{wasatch-2.1.65 → wasatch-2.2.0}/wasatch/WasatchDevice.py

@@ -293,7 +293,7 @@ class WasatchDevice(InterfaceDevice):
         # (given sleep()'s precision) for each acquisition.  For true precision
         # this should all go into the firmware anyway.
 
-        auto_enable_laser = tor and tor.enable_laser_before 
+        auto_enable_laser = tor is not None and tor.enable_laser_before 
         log.debug("acquire_spectrum: auto_enable_laser = %s", auto_enable_laser)
 
         dark_reading = SpectrometerResponse()
@@ -841,7 +841,7 @@ class WasatchDevice(InterfaceDevice):
             self.session_reading_count += 1
             reading.session_count = self.session_reading_count
             reading.sum_count = self.sum_count
-            log.debug(f"take_one_averaged_reading: reading.sum_count now {reading.sum_count}")
+            log.debug(f"take_one_averaged_reading: reading.sum_count now {reading.sum_count}, session_count {reading.session_count}")
 
             # have we completed the averaged reading?
             if sum_locally: 
@@ -878,17 +878,17 @@ class WasatchDevice(InterfaceDevice):
     # to the device.
     #
     # Essentially this iterates through all the (setting, value) pairs we've
-    # received through change_setting() which have not yet been processed, and
+    # received through change_setting() which have not yet been processed, and <-- MZ: incomplete sentence
     #
     #
-    # Note that WasatchDeviceWrapper.continuous_poll "de-dupes" commands on
+    # Note that WrapperWorker.run "de-dupes" commands on
     # receipt from ENLIGHTEN, so the command stream arising from that source
     # should already be optimized and minimal.  Commands injected manually by
     # calling WasatchDevice.change_setting() do not receive this treatment.
     #
-    # In the normal multi-process (ENLIGHTEN) workflow, this function is called
+    # In the normal multithreaded (ENLIGHTEN) workflow, this function is called
     # at the beginning of acquire_data, itself ticked regularly by
-    # WasatchDeviceWrapper.continuous_poll.
+    # WrapperWorker.run.
     def process_commands(self):
         control_object = "throwaway"
         retval = False
@@ -900,6 +900,9 @@ class WasatchDevice(InterfaceDevice):
             # is this a command used by WasatchDevice itself, and not
             # passed down to FeatureIdentificationDevice?
             if control_object.setting.lower() == "acquire":
+                # MZ: does this ever happen? It looks like the current
+                #     request sent down from WrapperWorker is "acquire_data"
+                #     not "acquire"...
                 log.debug("process_commands: acquire found")
                 retval = True
             else:

{wasatch-2.1.65 → wasatch-2.2.0}/wasatch/WasatchDeviceWrapper.py

@@ -17,6 +17,9 @@ log = logging.getLogger(__name__)
 # Readings and StatusMessages) for multiprocessing-safe device communications
 # and acquisition under Windows and Qt.
 #
+# @todo This document is full of references to continuous_poll(). That method 
+#       no longer exists, and has been replaced by WrapperWorker.run()
+#
 # @par Lifecycle
 #
 # From ENLIGHTEN's standpoint (the original Wasatch.PY caller), here's what's going on:
@@ -134,9 +137,10 @@ class WasatchDeviceWrapper:
     # could include "FILE:/path/to/dir", etc.  However, device_id is just
     # a string scalar to this class, and actually parsing / using it should be
     # entirely encapsulated within WasatchDevice and lower using DeviceID.
-    def __init__(self, device_id, log_level):
+    def __init__(self, device_id, log_level, callback=None):
         self.device_id = device_id
         self.log_level = log_level
+        self.callback = callback
 
         self.settings_queue = False
         self.response_queue = False
@@ -223,7 +227,9 @@ class WasatchDeviceWrapper:
             is_ocean       = self.is_ocean,
             is_andor       = self.is_andor,
             is_spi         = self.is_spi,
-            is_ble         = self.is_ble)
+            is_ble         = self.is_ble,
+            log_level      = self.log_level,
+            callback       = self.callback)
         log.debug("device wrapper: Instance created for worker")
 
         self.wrapper_worker.daemon = True
@@ -236,14 +242,25 @@ class WasatchDeviceWrapper:
         self.settings = None
         log.debug("connect: setup connection, returning to controller for settings polling")
 
+        if self.callback:
+            self.wait_for_settings()
+
         return True
 
-    def poll_settings(self): # -> SpectrometerResponse 
+    def wait_for_settings(self):
+        while True:
+            if self.poll_settings():
+                break
+            if (datetime.datetime.now() - self.connect_start_time).total_seconds() > 2:
+                raise Exception("Failed to read SpectrometerSettings")
+            time.sleep(0.1)
+
+    def poll_settings(self): 
         """ @returns SpectrometerResponse(True) on success, (False) otherwise """
         log.debug("polling device settings")
         if not self.settings_queue.empty():
             result = self.settings_queue.get_nowait()
-            if result is None: # shouldn't happen
+            if result is None: 
                 log.critical("poll_settings: failed to retrieve device settings (got None, shouldn't happen)")
                 return SpectrometerResponse(False, error_msg="Failed to retrieve device settings")
 
@@ -280,12 +297,6 @@ class WasatchDeviceWrapper:
 
         self.connected = False
 
-        # MZ: why do we recreate these?
-        self.settings_queue = Queue()
-        self.response_queue = Queue()
-        self.message_queue  = Queue()
-        self.command_queue  = Queue()
-
         return True
 
     ##
@@ -413,10 +424,6 @@ class WasatchDeviceWrapper:
         # none of those.  Yet apparently we did read some normal readings.
         # Return the latest of those.
 
-        # MZ: this would be a possible place to revert logging from DEBUG to
-        # whatever was passed (self.log_level), especially if this is the
-        # first reading returned by this thread.
-
         if WasatchDeviceWrapper.DISABLE_RESPONSE_QUEUE:
             self.previous_reading = last_reading
         return last_reading

{wasatch-2.1.65 → wasatch-2.2.0}/wasatch/WrapperWorker.py

@@ -2,6 +2,7 @@ import threading
 import logging
 import time
 from queue import Queue
+from datetime import datetime
 
 from .SpectrometerResponse import SpectrometerResponse
 from .SpectrometerRequest  import SpectrometerRequest
@@ -34,6 +35,8 @@ class WrapperWorker(threading.Thread):
     # TODO: Create ABC of hardware device that keeps common functions like handle_requests
     POLLER_WAIT_SEC = 0.05    # .05sec = 50ms = update from hardware device at 20Hz
 
+    DEBUG_SEC = 10 # enforce debug logging for the 1st 10sec after connecting a new spectrometer
+
     def __init__(
             self,
             device_id,
@@ -41,11 +44,12 @@ class WrapperWorker(threading.Thread):
             response_queue,
             settings_queue,
             message_queue,
-            is_ocean,
+            is_ocean, # MZ: all these bools should have just been a string "type"
             is_andor,
             is_spi,
             is_ble,
-            parent=None):
+            log_level,
+            callback=None):
 
         threading.Thread.__init__(self)
 
@@ -58,8 +62,18 @@ class WrapperWorker(threading.Thread):
         self.response_queue = response_queue
         self.settings_queue = settings_queue
         self.message_queue  = message_queue
+        self.log_level      = log_level
+        self.callback       = callback
+
         self.connected_device = None
 
+        self.thread_start = datetime.now()
+        self.initial_connection_logging = True
+
+        # enforce debug logging around ENLIGHTEN connections
+        if not self.callback:
+            logging.getLogger().setLevel("DEBUG") 
+
     ##
     # This is essentially the main() loop in a thread.
     # All communications with the parent thread are routed through
@@ -176,7 +190,11 @@ class WrapperWorker(threading.Thread):
                 continue
             log.debug(f"response {reading_response} data is {reading_response.data}")
 
-            if reading_response.keep_alive:
+            if self.callback:
+                log.debug("worker returning response via callback")
+                self.callback(reading_response)
+
+            elif reading_response.keep_alive:
                 log.debug("worker is flowing up keep_alive")
                 self.response_queue.put(reading_response) 
 
@@ -209,6 +227,15 @@ class WrapperWorker(threading.Thread):
                 except:
                     log.error("unable to push Reading %d to GUI", reading_response.data.session_count, exc_info=1)
 
+                # We just successfully sent a reading back to the main thread.
+                # After sending 10sec of such readings, we can disable the default
+                # DEBUG logging and revert to whatever the caller requested.
+                if (self.initial_connection_logging and 
+                        (datetime.now() - self.thread_start).total_seconds() > self.DEBUG_SEC):
+                    log.info(f"relaxing log_level to {self.log_level} after {self.DEBUG_SEC}sec")
+                    logging.getLogger().setLevel(self.log_level)
+                    self.initial_connection_logging = False
+
             else:
                 log.error("received non-failure Reading without spectrum...ignoring?")
 

{wasatch-2.1.65 → wasatch-2.2.0}/wasatch/__init__.py

@@ -1,4 +1,4 @@
 """This package is a driver for Wasatch Photonics spectrometers"""
 
-__version__ = "2.1.65"  # This is used by flit and other pypi things
+__version__ = "2.2.0"   # This is used by flit and other pypi things
 version = __version__   # This is to avoid breaking other files that originally used .version instead of __version__

{wasatch-2.1.65 → wasatch-2.2.0}/wasatch/applog.py

@@ -159,7 +159,7 @@ class MainLogger:
         fh.setFormatter(formatter)
         root_logger.addHandler(fh) 
 
-        if self.enable_stdout:
+        if self.enable_stdout and sys.stdout is not None:
             sys.stdout.reconfigure(encoding='utf-8')
             stream_handler = logging.StreamHandler(sys.stdout)
             stream_handler.setFormatter(formatter)

{wasatch-2.1.65 → wasatch-2.2.0}/wasatch/utils.py

@@ -468,7 +468,7 @@ def coeffs_look_valid(coeffs, count=None):
 
     # check for constants (all coefficients the same value)
     all_const = True
-    log.info(coeffs)
+    # log.debug(coeffs)
     for i in range(1, len(coeffs)):
         if coeffs[0] != coeffs[i]:
             all_const = False