wasatch 2.3.8__tar.gz → 2.3.12__tar.gz

{wasatch-2.3.8 → wasatch-2.3.12}/.gitignore

@@ -111,3 +111,4 @@ wasatch_applog.txt
 .DS_Store
 .vs/*
 environment.yml
+data/

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

@@ -1,5 +1,16 @@
 # Changelog
 
+- 2026-02-17 2.3.12
+    - added laser_password, startup_scans_to_average, laser_attenuator
+    - added [un]pack_field
+    - un-rotated Hamamatsu area scan 180 deg :-(
+    - allow IDS config files to be located by serial number prefix
+- 2026-02-09 2.3.11
+    - rotate Hamamatsu area scan 180 deg
+- 2026-01-16 2.3.10
+    - support 2min integrations on STARVIS
+- 2026-01-15 2.3.9
+    - added --normalize to demo-ids-raman.py
 - 2026-01-12 2.3.8
     - added settings.has_detector
     - improved support for Andor .json "virtual EEPROMs"

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

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

{wasatch-2.3.8 → wasatch-2.3.12}/README_PYPI.md

@@ -50,6 +50,12 @@ before uploading to the "public, global, default" pypi repository.
 When you are ready to publish run `flit publish` or `flit publish --repository pypi`
 (or just "make publish").
 
+## Common Errors
+
+### requests.exceptions.HTTPError: 400 Client Error: Bad Request for url: https://test.pypi.org/legacy/
+
+Ensure wasatch/__init__.py version matches pyproject.toml.
+
 # Installing 'wasatch' package from source
 
 If you've cloned the Wasatch.PY repo and want to just install the `wasatch` 

{wasatch-2.3.8 → wasatch-2.3.12}/demo-ids-raman.py

@@ -26,6 +26,7 @@ import argparse
 
 from datetime import datetime
 from time import sleep
+from PIL import Image, ImageStat  # for image normalization
 
 import wasatch
 from wasatch                      import applog
@@ -59,6 +60,7 @@ class WasatchDemo:
         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("--normalize",           action="store_true",      help="normalize PNG image")
         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")
 
@@ -150,6 +152,9 @@ class WasatchDemo:
     ############################################################################
 
     def run(self):
+        if self.args.save_dir != ".":
+            os.makedirs(self.args.save_dir, exist_ok=True)
+
         self.camera_device.set_integration_time_ms(self.args.integration_time_ms)
 
         # initialize outfile if saving spectra
@@ -229,6 +234,17 @@ class WasatchDemo:
                 os.replace(asi.pathname_png, filename)
                 print(f"\tsaved {filename}")
 
+                # normalize PNG (just the image file, not the raw 2D data)
+                if self.args.normalize:
+                    img = Image.open(filename).convert('L')
+                    stat = ImageStat.Stat(img)
+                    mean_brightness = stat.mean[0]
+                    img_array = np.array(img)
+                    normalized_img_array = img_array / mean_brightness * 100 
+                    normalized_img = Image.fromarray(np.uint8(normalized_img_array))
+                    normalized_img.save(filename)
+                    print(f"\tnormalized {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")

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

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

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

@@ -25,9 +25,9 @@ log = logging.getLogger(__name__)
 # @see 24LC128 for FX2 (16KB, https://www.microchip.com/en-us/product/24LC128)
 class EEPROM:
 
-    LATEST_REV = 17
+    LATEST_REV = 18
 
-    MAX_PAGES = 8
+    MAX_PAGES = 9
     PAGE_LENGTH = 64
     SUBPAGE_COUNT = 4  # used for BLE
     RAMAN_INTENSITY_CALIBRATION_ORDER = 5
@@ -68,6 +68,7 @@ class EEPROM:
         ((1, 46,  2), "h", "tec_beta"),
         ((1, 48, 12), "s", "calibration_date"),
         ((1, 60,  3), "s", "calibrated_by"),
+
         ((2,  0, 16), "s", "detector"),
         ((2, 16,  2), "H", "active_pixels_horizontal"),
         ((2, 18,  1), "B", "laser_warmup_sec"),
@@ -87,6 +88,7 @@ class EEPROM:
         ((2, 51,  4), "f", "linearity_c2"),
         ((2, 55,  4), "f", "linearity_c3"),
         ((2, 59,  4), "f", "linearity_c4"),
+
         ((3, 12,  4), "f", "laser_power_c0"),
         ((3, 16,  4), "f", "laser_power_c1"),
         ((3, 20,  4), "f", "laser_power_c2"),
@@ -101,9 +103,15 @@ class EEPROM:
         ((3, 55,  2), "H", "power_timeout_sec"),
         ((3, 57,  2), "H", "detector_timeout_sec"),
         ((3, 59,  1), "B", "horiz_binning_mode"),
+        ((3, 60,  1), "B", "startup_scans_to_average"),
+        ((3, 61,  1), "B", "laser_attenuator"),
+
         ((4,  0, 64), "s", "user_data"),
+
         ((5, 30, 16), "s", "product_configuration"),
-        ((5, 63,  1), "B", "subformat")
+        ((5, 63,  1), "B", "subformat"),
+
+        ((8,  0, 15), "s", "laser_password"),
     ]
 
     def __init__(self):
@@ -145,6 +153,8 @@ class EEPROM:
         self.power_timeout_sec           = 0
         self.detector_timeout_sec        = 0
         self.horiz_binning_mode          = 0
+        self.startup_scans_to_average    = 1
+        self.laser_attenuator            = 127
                                          
         self.wavelength_coeffs           = []
         self.degC_to_dac_coeffs          = []
@@ -185,6 +195,8 @@ class EEPROM:
         self.bad_pixels                  = [] # should be set, not list (but this works with EEPROMEditor)
         self.product_configuration       = None
 
+        self.laser_password              = None
+
         self.format                      = EEPROM.LATEST_REV
         self.subformat                   = 0 # determines format of pages 6-7
 
@@ -227,6 +239,7 @@ class EEPROM:
             "roi_vertical_region_3_start",
             "user_text",
             "wavelength_coeffs",
+            "laser_password",
         ]
 
         self.init_raman_intensity_calibration()
@@ -276,7 +289,7 @@ class EEPROM:
     # ##########################################################################
 
     ## 
-    # given a set of the 8 buffers read from a spectrometer via USB,
+    # given a set of the 8+ buffers read from a spectrometer via USB,
     # parse those into the approrpriate fields and datatypes
     def parse(self, buffers):
         if len(buffers) < EEPROM.MAX_PAGES:
@@ -448,6 +461,10 @@ class EEPROM:
             self.detector_timeout_sec        = self.unpack((3, 57,  2), "H", "detector_timeout_sec")
             self.horiz_binning_mode          = self.unpack((3, 59,  1), "B", "horiz_binning_mode")
 
+        if self.format >= 18:
+            self.unpack_field("startup_scans_to_average")
+            self.unpack_field("laser_attenuator")
+
         # ######################################################################
         # Page 4
         # ######################################################################
@@ -525,6 +542,17 @@ class EEPROM:
             self.laser_timeout_after_count     = False
             self.is_oem                        = False
 
+        # ######################################################################
+        # Page 8
+        # ######################################################################
+
+        if "XS" in self.model.upper(): # and self.format >= 18:
+            
+            s = self.unpack_field("laser_password", quiet=True)
+            if len(s) < 4 or any([c in [0x00, 0xff] for c in s]):
+                log.debug("no laser password found")
+                self.laser_password = None
+
         # ######################################################################
         # sanity checks
         # ######################################################################
@@ -695,6 +723,8 @@ class EEPROM:
         self.pack((3, 55,  2), "H", self.power_timeout_sec)
         self.pack((3, 57,  2), "H", self.detector_timeout_sec)
         self.pack((3, 59,  1), "B", self.multi_wavelength_calibration.get("horiz_binning_mode"))
+        self.pack_field("startup_scans_to_average")
+        self.pack_field("laser_attenuator")
 
         # ######################################################################
         # Page 4
@@ -742,6 +772,14 @@ class EEPROM:
         else:
             log.error(f"Unwriteable EEPROM subformat {self.subformat}")
 
+        # ######################################################################
+        # Page 8
+        # ######################################################################
+
+        if "XS" in self.model.upper():
+            # self.pack((8,  0, 16), "s", self.laser_password)
+            self.pack_field("laser_password", quiet=True)
+
     # ##########################################################################
     #                                                                          #
     #                             Utility methods                              #
@@ -789,19 +827,29 @@ class EEPROM:
         log.debug("float_to_uint16: %f -> 0x%04x", gain, raw)
         return raw
 
+    def unpack_field(self, name, quiet=False):
+        if name not in self.fields:
+            log.error(f"unable to unpack unknown field {name}")
+            return
+
+        field = self.fields[name]
+        value = self.unpack(field.pos, field.data_type, label=name, quiet=quiet)
+        setattr(self, name, value)
+        return value
+
     ## 
     # Unpack a single field at a given buffer offset of the given datatype.
     #
     # @param address    a tuple of the form (buf, offset, len)
     # @param data_type  see https://docs.python.org/2/library/struct.html#format-characters
     # @param label      if provided, is included in debug log output
-    def unpack(self, address, data_type, label=None):
+    def unpack(self, address, data_type, label=None, quiet=False):
         page       = address[0]
         start_byte = address[1]
         length     = address[2]
         end_byte   = start_byte + length
 
-        if page > len(self.buffers):
+        if page + 1 > len(self.buffers):
             log.error("error unpacking EEPROM page %d, offset %d, len %d as %s: invalid page (label %s)", 
                 page, start_byte, length, data_type, label, exc_info=1)
             return
@@ -827,19 +875,29 @@ class EEPROM:
             except:
                 log.error("error unpacking EEPROM page %d, offset %d, len %d as %s", page, start_byte, length, data_type, exc_info=1)
 
-        if label is None:
-            log.debug("Unpacked [%s]: %s", data_type, unpack_result)
-        else:
-            log.debug("Unpacked [%s]: %s (%s)", data_type, unpack_result, label)
+        if not quiet:
+            if label is None:
+                log.debug("Unpacked [%s]: %s", data_type, unpack_result)
+            else:
+                log.debug("Unpacked [%s]: %s (%s)", data_type, unpack_result, label)
         return unpack_result
 
+    def pack_field(self, name, quiet=False):
+        if name not in self.fields:
+            log.error(f"unable to pack unknown field {name}")
+            return
+
+        field = self.fields[name]
+        value = getattr(self, name)
+        self.pack(field.pos, field.data_type, value, label=name, quiet=quiet)
+
     ## 
     # Marshall or serialize a single field at a given buffer offset of the given datatype.
     #
     # @param address    a tuple of the form (buf, offset, len)
     # @param data_type  see https://docs.python.org/2/library/struct.html#format-characters
     # @param value      value to serialize
-    def pack(self, address, data_type, value, label=None):
+    def pack(self, address, data_type, value, label=None, quiet=False):
         page       = address[0]
         start_byte = address[1]
         length     = address[2]
@@ -873,7 +931,7 @@ class EEPROM:
                 value = float(value)
             struct.pack_into(data_type, buf, start_byte, value)
 
-        if False:
+        if False and not quiet:
             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)
@@ -960,6 +1018,8 @@ class EEPROM:
         log.debug("  Power Timeout:    %d", self.power_timeout_sec)
         log.debug("  Detector Timeout: %d", self.detector_timeout_sec)
         log.debug("  Horiz Bin Mode:   %d", self.multi_wavelength_calibration.get("horiz_binning_mode", default=0))
+        log.debug("  Startup Scan Avg: %d", self.startup_scans_to_average)
+        log.debug("  Laser Attenuator: %d", self.laser_attenuator)
         log.debug("  Slit size:        %s um", self.slit_size_um)
         log.debug("  Start Integ Time: %d ms", self.startup_integration_time_ms)
         log.debug("  Start Temp:       %.2f degC", self.startup_temp_degC)

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

@@ -942,14 +942,14 @@ class FeatureIdentificationDevice(InterfaceDevice):
     def get_battery_state_raw(self):
         """Retrieves the raw battery reading and then caches it for 1 sec"""
         now = datetime.datetime.now()
-        if self.settings.state.battery_timestamp is not None and (now - self.settings.state.battery_timestamp).total_seconds() < 1:
-            return SpectrometerResponse(data=self.settings.state.battery_raw)
+        if self.settings.state.battery_timestamp is None or \
+                self.settings.state.battery_raw is None or \
+                (now - self.settings.state.battery_timestamp).total_seconds() > 1:
+            self.settings.state.battery_timestamp = now
+            response = self.get_upper_code(0x13, label="GET_BATTERY_STATE", msb_len=3)
+            self.settings.state.battery_raw = response.data
+            log.debug(f"battery_state_raw: 0x{self.settings.state.battery_raw:06x}")
 
-        self.settings.state.battery_timestamp = now
-        response = self.get_upper_code(0x13, label="GET_BATTERY_STATE", msb_len=3)
-        self.settings.state.battery_raw = response.data
-
-        log.debug(f"battery_state_raw: 0x{self.settings.state.battery_raw:04x}")
         return SpectrometerResponse(data=self.settings.state.battery_raw)
 
     def get_battery_percentage(self):
@@ -958,7 +958,7 @@ class FeatureIdentificationDevice(InterfaceDevice):
         lsb = (word >> 16) & 0xff
         msb = (word >>  8) & 0xff
         perc = msb + (1.0 * lsb / 256.0)
-        log.debug("battery_perc: %.2f%%", perc)
+        log.debug(f"battery_perc: msb 0x{msb:02x} + lsb 0x{lsb:02x} = {perc:0.2f}%%")
         return SpectrometerResponse(data=perc)
 
     def get_battery_charging(self):

{wasatch-2.3.8 → wasatch-2.3.12}/wasatch/IDSCamera.py

@@ -259,10 +259,11 @@ class IDSCamera:
         self.node_map = None
         self.long_name = None
         self.datastream = None
+        self.dumped = False
 
         self.area_scan_enabled = False
         self.take_one_request = None
-        self.taking_acquisition = False
+        self.started = False
         self.shutdown_in_progress = False
         self.last_asi_timestamp = None
         self.last_area_scan_image = None
@@ -380,19 +381,50 @@ class IDSCamera:
         self.start_line = 0
         self.stop_line = self.height - 1
 
-        # Load the default settings
-        self.node_map.FindNode("UserSetSelector").SetCurrentEntry("Default")
-        self.node_map.FindNode("UserSetLoad").Execute()
-        self.node_map.FindNode("UserSetLoad").WaitUntilDone()
+        self.set_user_set("Default")
+
+        # default to 15ms
+        self.node_map.FindNode("ExposureTime").SetValue(15_000) # value in µs (note this is valid in Default, but not LongExposure)
+
+        log.debug(f"connect: successfully connected to {self.long_name}")
+        return True
+
+    def doing_default(self):
+        selector = self.node_map.FindNode("UserSetSelector")
+        return "Default" == selector.CurrentEntry().SymbolicValue()
+
+    def doing_long_exposure(self):
+        selector = self.node_map.FindNode("UserSetSelector")
+        return "LongExposure" == selector.CurrentEntry().SymbolicValue()
+
+    def set_user_set(self, entry):
+        if entry not in ["Default", "LongExposure"]:
+            log.error(f"ignoring unsupported UserSetSelector {entry}")
+            return
+
+        selector = self.node_map.FindNode("UserSetSelector")
+        current_entry = selector.CurrentEntry().SymbolicValue()
+        if entry == current_entry:
+            log.debug(f"set_user_set: UserSet already {entry}")
+            return
+        log.debug(f"set_user_set: changing {current_entry} -> {entry}")
+
+        was_started = self.started
+        if was_started:
+            log.debug("set_user_set: was_started, so stopping")
+            self.stop()
+
+        selector.SetCurrentEntry(entry)
+        loader = self.node_map.FindNode("UserSetLoad")
+        loader.Execute()
+        loader.WaitUntilDone()
+
+        node = self.node_map.FindNode("ExposureTime")
+        log.debug(f"set_user_set: applied UserSetSelector {entry}, ExposureTime range now ({node.Minimum()}, {node.Maximum()})µs")
+
+        # assuming we may need to do this after changing UserSet, but haven't verified
+        self.init_software_trigger()
 
-        # initialize software trigger
-        # @see https://www.ids-imaging.us/manuals/ids-peak/ids-peak-user-manual/2.15.0/en/acquisition-control.html
-        log.debug("TriggerSelector set to ExposureStart")
-        self.node_map.FindNode("TriggerSelector").SetCurrentEntry("ReadOutStart") # "ExposureStart" not supported?
-        self.node_map.FindNode("TriggerMode").SetCurrentEntry("On")
-        self.node_map.FindNode("TriggerSource").SetCurrentEntry("Software")
-        self.node_map.FindNode("ExposureTime").SetValue(15_000) # value in µs
-        
         # nodeMapRemoteDevice.FindNode("SequencerMode")   .SetCurrentEntry("Off")
         # nodeMapRemoteDevice.FindNode("AcquisitionMode") .SetCurrentEntry("SingleFrame")
         # nodeMapRemoteDevice.FindNode("ExposureMode")    .SetCurrentEntry("Timed")
@@ -402,10 +434,21 @@ class IDSCamera:
         # nodeMapRemoteDevice.FindNode("AcquisitionStart").Execute()
         # nodeMapRemoteDevice.FindNode("AcquisitionStart").WaitUntilDone()
 
-        self.dump_node(name="Root")
+        # MZ: this can take 247ms, so only do once
+        if not self.dumped:
+            self.dump_node(name="Root")
+            self.dumped = True
 
-        log.debug(f"connect: successfully connected to {self.long_name}")
-        return True
+        if was_started:
+            log.debug("set_user_set: was_started, so re-starting")
+            self.start()
+
+    def init_software_trigger(self):
+        # @see https://www.ids-imaging.us/manuals/ids-peak/ids-peak-user-manual/2.15.0/en/acquisition-control.html
+        log.debug("TriggerSelector set to ExposureStart")
+        self.node_map.FindNode("TriggerSelector").SetCurrentEntry("ReadOutStart") # "ExposureStart" not supported?
+        self.node_map.FindNode("TriggerMode").SetCurrentEntry("On")
+        self.node_map.FindNode("TriggerSource").SetCurrentEntry("Software")
 
     def set_dark_asi(self, asi):
         self.dark = asi
@@ -430,12 +473,20 @@ class IDSCamera:
         self.stop_line = n
 
     def set_integration_time_ms(self, ms):
-        # do we need to .stop and .start around this?
+        # manually clamp to apparent "multi-UserSet" range of (15ms, 120sec)
+        # deliberately round to ms resolution to simplify barrier comparisons
+        ms = int(round(min(120_000, max(ms, 15)), 0))
+
         us = ms * 1000.0
+        log.debug(f"set_integration_time_ms: ms {ms}, us {us}")
 
-        node = self.node_map.FindNode("ExposureTime")
-        us = max(us, node.Minimum())
-        us = min(us, node.Maximum())
+        if us <= 1_001_000:
+            self.set_user_set("Default")
+        elif us >= 2_000_000:
+            self.set_user_set("LongExposure")
+        else:
+            # either mode can apparently support (1001, 1999ms)
+            pass
 
         log.debug(f"set_integration_time_ms: integration time {us} µs")
         self.node_map.FindNode("ExposureTime").SetValue(us)
@@ -457,11 +508,11 @@ class IDSCamera:
             log.debug("start: no device")
             return 
 
-        if self.taking_acquisition:
+        if self.started:
             log.debug("start: already running")
             return
 
-        # self.datastream = None # kludge
+        self.datastream = None # kludge
         if self.datastream is None:
             log.debug("start: initializing datastream")
             self.datastream = self.device.DataStreams()[0].OpenDataStream()
@@ -512,7 +563,7 @@ class IDSCamera:
             self.datastream.StartAcquisition()
             self.node_map.FindNode("AcquisitionStart").Execute()
             self.node_map.FindNode("AcquisitionStart").WaitUntilDone()
-            self.taking_acquisition = True
+            self.started = True
 
             log.debug("start: started")
         except:
@@ -549,11 +600,11 @@ class IDSCamera:
         pass
 
     def stop(self):
-        """ Called during shutdown.  """
+        """ Called when changing UserSet, and at shutdown. """
         if self.device is None:
             return
 
-        if not self.taking_acquisition:
+        if not self.started:
             log.debug("stop: not running")
             return
 
@@ -565,7 +616,7 @@ class IDSCamera:
             # Discard all buffers from the acquisition engine
             # They remain in the announced buffer pool
             self.datastream.Flush(IDSPeak.DataStreamFlushMode_DiscardAll)
-            self.taking_acquisition = False
+            self.started = False
 
             # Unlock parameters
             self.node_map.FindNode("TLParamsLocked").SetValue(0)
@@ -618,27 +669,33 @@ class IDSCamera:
                 self.take_one_request = None
 
     def send_trigger(self):
+        # log.debug("send_trigger: start...")
         self.node_map.FindNode("TriggerSoftware").Execute()
         self.node_map.FindNode("TriggerSoftware").WaitUntilDone()
+        # log.debug("send_trigger: ...done")
 
     def get_spectrum(self):
+        # log.debug("get_spectrum: start")
         if self.datastream is None:
             log.error("get_spectrum: no datastream?!")
             return
 
         timeout_ms = int(round(1000 + 2 * max(self.integration_time_ms, self.last_integration_time_ms)))
         try:
+            # log.debug(f"get_spectrum: waiting on finished buffer (timeout {timeout_ms}ms)")
             buffer = self.datastream.WaitForFinishedBuffer(timeout_ms) # takes ms
         except:
-            # log.error(f"failed on datastream.WaitForFinishedBuffer({timeout_ms}ms)", exc_info=1)
+            log.error(f"failed on datastream.WaitForFinishedBuffer(timeout {timeout_ms}ms)", exc_info=1)
             return
 
         # Get image from buffer (shallow copy)
+        # log.debug(f"get_spectrum: converting to image")
         image = EXT.BufferToImage(buffer)
 
         if True:
             # normal case, just vertically bin using the configured format
             # (pass the buffer so it can be released after conversion)
+            # log.debug(f"get_spectrum: vertically binning")
             spectrum = self.vertically_bin_image(image, buffer=buffer)
         else:
             # debug code to experimentally convert the same frame into every 
@@ -655,6 +712,7 @@ class IDSCamera:
                     log.error(f"exception during conversion to {format_name}", exc_info=1)
 
         self.last_integration_time_ms = self.integration_time_ms
+        # log.debug("get_spectrum: done")
         return spectrum
 
     def vertically_bin_image(self, image, format_name=None, buffer=None, save_csv=False, save_png=False):

{wasatch-2.3.8 → wasatch-2.3.12}/wasatch/IDSDevice.py

@@ -58,6 +58,8 @@ class IDSDevice(InterfaceDevice):
         self.settings = SpectrometerSettings(self.device_id)
         self.settings.eeprom.excitation_nm_float = 785 
         self.settings.eeprom.wavecal_coeffs = [0, 1, 0, 0, 0]
+        self.settings.eeprom.min_integration_time_ms = 15       # Default UserSet
+        self.settings.eeprom.max_integration_time_ms = 120_000  # LongExposure UserSet
 
         # stomp from camera
         self.settings.eeprom.model = self.camera.model_name
@@ -113,39 +115,44 @@ class IDSDevice(InterfaceDevice):
         }
 
         """
-        json_path = os.path.join(self.config_dir, f"IDS-{self.camera.serial_number}.json")
-        if os.path.exists(json_path):
-            with open(json_path) as config_file:
-                data = json.load(config_file)
-            log.debug(f"loaded from {json_path}: {data}")
-
-            def stomp(k, attr=None):
-                if attr is None:
-                    attr = k
-                    log.debug(f"attempting to stomp {k}")
-                else:
-                    log.debug(f"attempting to stomp {k} --> {attr}")
-
-                if k in data:
-                    value = data[k]
-                    log.debug(f"stomping eeprom.{attr} = {value}")
-                    setattr(self.settings.eeprom, attr, value)
-
-            for k in [ "detector_gain",
-                       "excitation_nm_float", 
-                       "invert_x_axis", 
-                       "horiz_binning_enabled",       
-                       "horiz_binning_mode",
-                       "startup_integration_time_ms",
-                       "wavelength_coeffs",
-                       "roi_horizontal_end",
-                       "roi_horizontal_start",
-                       "roi_vertical_region_1_start",
-                       "roi_vertical_region_1_end" ]:
-                stomp(k)
-            for k, attr in [ [ "wp_model",         "model" ],
-                             [ "wp_serial_number", "serial_number" ] ]:
-                stomp(k, attr)
+        prefix = f"IDS-{self.camera.serial_number}"
+        suffix = ".json"
+        json_path = utils.find_first_file(path=self.config_dir, prefix=prefix, suffix=suffix)
+        if not json_path:
+            log.debug(f"could not find file with prefix {prefix}, suffix {suffix} in path {self.config_dir}")
+            return
+
+        with open(json_path) as config_file:
+            data = json.load(config_file)
+        log.debug(f"loaded from {json_path}: {data}")
+
+        def stomp(k, attr=None):
+            if attr is None:
+                attr = k
+                log.debug(f"attempting to stomp {k}")
+            else:
+                log.debug(f"attempting to stomp {k} --> {attr}")
+
+            if k in data:
+                value = data[k]
+                log.debug(f"stomping eeprom.{attr} = {value}")
+                setattr(self.settings.eeprom, attr, value)
+
+        for k in [ "detector_gain",
+                   "excitation_nm_float", 
+                   "invert_x_axis", 
+                   "horiz_binning_enabled",       
+                   "horiz_binning_mode",
+                   "startup_integration_time_ms",
+                   "wavelength_coeffs",
+                   "roi_horizontal_end",
+                   "roi_horizontal_start",
+                   "roi_vertical_region_1_start",
+                   "roi_vertical_region_1_end" ]:
+            stomp(k)
+        for k, attr in [ [ "wp_model",         "model" ],
+                         [ "wp_serial_number", "serial_number" ] ]:
+            stomp(k, attr)
 
     def set_integration_time_ms(self, ms):
         """
@@ -213,17 +220,22 @@ class IDSDevice(InterfaceDevice):
 
     def get_spectrum(self):
         try:
+            # log.debug("get_spectrum: calling send_trigger")
             self.camera.send_trigger()
+            # log.debug("get_spectrum: back from send_trigger, calling camera.get_spectrum")
             spectrum = self.camera.get_spectrum()
+            # log.debug("get_spectrum: back from camera.get_spectrum")
         except:
             log.error("error getting spectrum from IDSCamera", exc_info=1)
             return SpectrometerResponse(False)
             
         if spectrum is None:
-            # log.error("get_spectrum: received None?!")
+            log.debug("get_spectrum: received None")
             return SpectrometerResponse(False)
 
+        # log.debug("get_spectrum: applying horizontal binning")
         spectrum = self.apply_horizontal_binning(spectrum)
+        # log.debug("get_spectrum: done")
         return spectrum
 
     def apply_horizontal_binning(self, spectrum):
@@ -262,14 +274,15 @@ class IDSDevice(InterfaceDevice):
 
     def acquire_data(self):
         # pre-process scan averaging
-        log.debug(f"acquire_data: scans_to_average {self.settings.state.scans_to_average}")
+        # log.debug(f"acquire_data: start (scans_to_average {self.settings.state.scans_to_average})")
         if self.settings.state.scans_to_average > 1:
             if self.sum_count > self.settings.state.scans_to_average:
                 self.reset_averaging()
 
         reading = Reading(self.device_id)
-
+        # log.debug("acquire_data: calling get_spectrum")
         reading.spectrum = self.get_spectrum()
+        # log.debug("acquire_data: back from get_spectrum")
 
         if not self.camera:
             return SpectrometerResponse(False)
@@ -301,9 +314,12 @@ class IDSDevice(InterfaceDevice):
             else:
                 log.debug(f"acquire_data: averaged {self.sum_count}/{self.settings.state.scans_to_average}")
 
-        log.debug(f"acquire_data: returning {reading}")
+        # log.debug(f"acquire_data: returning {reading}")
         return SpectrometerResponse(data=reading)
 
+    def heartbeat(self, arg):
+        return SpectrometerResponse(data=True)
+
     ############################################################################
     # utility
     ############################################################################
@@ -319,6 +335,7 @@ class IDSDevice(InterfaceDevice):
         process_f["close"]               = self.disconnect
 
         process_f["acquire_data"]        = self.acquire_data
+        process_f["heartbeat"]           = self.heartbeat
                                          
         # deliberately don't support gain_factor or detector_gain
         process_f["gain_db"]             = lambda x: self.set_gain_db(float(x)) 

{wasatch-2.3.8 → wasatch-2.3.12}/wasatch/__init__.py

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

{wasatch-2.3.8 → wasatch-2.3.12}/wasatch/utils.py

@@ -218,10 +218,25 @@ def get_default_data_dir():
         return os.path.join(os.path.expanduser("~"), "Documents", "EnlightenSpectra")
     return os.path.join(os.environ["HOME"], "EnlightenSpectra")
 
-## iterate down a directory, returning pathnames that match the given pattern
+def find_first_file(path, prefix=None, suffix=None, recursive=False):
+    pat = f"^{prefix}" if prefix else ""
+    if suffix:
+        suffix = suffix.replace(".", "\\.")
+        pat += f".*{suffix}"
+    # log.debug(f"find_first_file: pat [{pat}]")
+    files = get_pathnames_from_directory(rootdir=path, pattern=pat, recursive=recursive)
+    if len(files) < 1:
+        return None
+    else:
+        return files[0]
+
 def get_pathnames_from_directory(rootdir, pattern=None, recursive=False):
+    """ 
+    Iterate down a directory, returning pathnames that match the given pattern in
+    deterministic sorted order.
+    """
     pathnames = []
-    # log.debug("searching %s matching %s with recursive %s", rootdir, pattern, recursive)
+    # log.debug("get_pathnames_from_directory: searching %s matching %s with recursive %s", rootdir, pattern, recursive)
     if recursive:
         for (directory, _, filenames) in os.walk(rootdir):
             for filename in filenames:
@@ -230,7 +245,7 @@ def get_pathnames_from_directory(rootdir, pattern=None, recursive=False):
                     if re.search(pattern, filename):
                         pathnames.append(pathname)
                     else:
-                        # log.debug("%s does not match %s", pathname, pattern)
+                        # log.debug("get_pathnames_from_directory: %s does not match %s", pathname, pattern)
                         pass
                 else:
                     pathnames.append(pathname)
@@ -242,11 +257,12 @@ def get_pathnames_from_directory(rootdir, pattern=None, recursive=False):
                     if re.search(pattern, filename):
                         pathnames.append(pathname)
                     else:
-                        # log.debug("%s does not match %s", pathname, pattern)
+                        # log.debug("get_pathnames_from_directory: %s does not match %s", pathname, pattern)
                         pass
                 else:
                     pathnames.append(pathname)
-    # log.debug("returning %s", pathnames)
+    pathnames.sort()
+    # log.debug("get_pathnames_from_directory: returning %s", pathnames)
     return pathnames
 
 ##