wasatch 2.2.0__tar.gz → 2.2.13__tar.gz

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

@@ -1,5 +1,69 @@
 # Changelog
 
+- 2024-11-01 2.2.13
+    - support for InGaAs linear pixel calibration
+    - re-enable STM32 serial number
+- 2024-10-31 2.2.12
+    - prefer new EEPROM location for startup laser TEC setpoint
+- 2024-10-30 2.2.11
+    - IMX385.bin_4x2_avg tweak
+- 2024-10-30 2.2.10
+    - don't configure laser TEC and laser warning delay unless laser present
+- 2024-10-29 2.2.9
+    - add BIN_4X2_AVG
+    - add more firmware version checks around new features to avoid breaking old FW
+    - Auto-Raman
+        - support new onboard Auto-Raman opcode and parameters
+        - start refresh of BLEDevice
+- 2024-10-16 2.2.8
+    - add alert_queue to allow caller (ENLIGHTEN) to send hints and interrupts 
+      downstream into Wasatch.PY, visible even within long-running operations 
+      like Auto-Raman which are encapsulated within a single call from 
+      WrapperWorker and therefore unsuitable for the normal "command_queue"
+    - added AutoRaman support for new "auto_raman_cancel" alert
+- 2024-10-15 2.2.7
+    - fixed AutoRaman on X series
+    - added IMX385.bin_4x2_interp
+- 2024-10-14 2.2.6
+    - removed 
+        - EEPROM.ssc_enabled
+    - changed 
+        - EEPROM.LATEST_REV to 16
+        - EEPROM.bin_2x2 --> .horiz_binning_enabled
+        - EEPROM.actual_horizontal to .actual_pixels_horizontal
+        - EEPROM.actual_vertical to .actual_pixels_vertical
+    - added 
+        - EEPROM.horiz_binning_mode
+        - EEPROM.power_timeout_sec 
+        - EEPROM.detector_timeout_sec
+        - IMX385.bin_4x2
+- 2024-10-10 2.2.5
+    - added IMX385
+    - added EEPROM.ssc_enabled
+    - added AutoRaman throwaway before dark to let laser fully disable
+    - bugfix in SpectrometerSettings.has_excitation
+- 2024-10-03 2.2.4
+    - added EEPROM.disable_ble_power
+    - added EEPROM.disable_laser_armed_indicator
+    - added SpectrometerSettings.ble_firmware_version
+- 2024-09-17 2.2.3
+    - ensure all queued messages are flowed upstream
+    - AutoRaman
+        - output progress bar updates
+        - support configurable Laser Warning Delay
+        - averaging bugfix
+        - trying to support non-zero initial gain dB
+        - enable saving individual spectral components via environment variable
+        - don't perform dark-correction; leave that for caller
+- 2024-09-12 2.2.2
+    - added set/get_laser_warning_delay through change_settings
+    - updated reset_fpga to restore key FPGA settings
+    - enriched AutoRaman status messages
+    - AutoRaman bugfix
+- 2024-09-12 2.2.1
+    - fixed get_detector_gain on XS
+    - reduced number of implicit throwaways after acquisition parameter changes
+    - added AutoRaman via TakeOneRequest
 - 2024-08-22 2.2.0
     - cutting release for ENLIGHTEN 4.1.0
 - 2024-06-27 2.1.73

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

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

wasatch-2.2.13/demo-auto-raman.py

@@ -0,0 +1,130 @@
+import os
+import re
+import sys
+import time
+import numpy
+import signal
+import logging
+import datetime
+import argparse
+
+import wasatch
+from wasatch import utils
+from wasatch import applog
+from wasatch.WasatchBus           import WasatchBus
+from wasatch.WasatchDevice        import WasatchDevice
+from wasatch.WasatchDeviceWrapper import WasatchDeviceWrapper
+from wasatch.TakeOneRequest       import TakeOneRequest
+from wasatch.AutoRamanRequest     import AutoRamanRequest
+
+log = logging.getLogger(__name__)
+
+class Fixture:
+
+    def __init__(self):
+        self.bus     = None
+        self.device  = None
+        self.outfile = None
+        self.reading_count = 0
+
+        self.parse_args()
+
+        self.logger = applog.MainLogger("DEBUG" if self.args.debug else "INFO")
+
+    def parse_args(self):
+        parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+        parser.add_argument("--debug",          action="store_true",          help="logging level")
+        parser.add_argument("--outfile",        type=str,      default=None,  help="output filename (e.g. path/to/spectra.csv)")
+        parser.add_argument("--max-ms",         type=int,      default=10000, help="maximum measurement time (ms)")
+        parser.add_argument("--start-integ-ms", type=int,      default=100,   help="initial integration time (ms)")
+        parser.add_argument("--start-gain-db",  type=float,    default=0,     help="initial gain (dB)")
+        parser.add_argument("--max-integ-ms",   type=int,      default=2000,  help="maximum integration time (ms)")
+        parser.add_argument("--min-integ-ms",   type=int,      default=10,    help="minimum integration time (ms)")
+        parser.add_argument("--max-gain-db",    type=float,    default=32,    help="maximum gain (dB)")
+        parser.add_argument("--min-gain-db",    type=float,    default=0,     help="minimum gain (dB)")
+        parser.add_argument("--target-counts",  type=int,      default=45000, help="target counts")
+        parser.add_argument("--max-counts",     type=int,      default=50000, help="max counts")
+        parser.add_argument("--min-counts",     type=int,      default=40000, help="min counts")
+        parser.add_argument("--max-factor",     type=float,    default=5,     help="max scaling factor")
+        parser.add_argument("--drop-factor",    type=float,    default=0.5,   help="factor when scaling down")
+        parser.add_argument("--saturation",     type=int,      default=65000, help="counts")
+
+        self.args = parser.parse_args()
+        
+    def connect(self):
+        """ Connect to all discoverable Wasatch spectrometers.  """
+
+        self.bus = WasatchBus()
+        if not self.bus.device_ids:
+            print("No Wasatch USB spectrometers found.")
+            return 
+
+        for device_id in self.bus.device_ids:
+            device = WasatchDevice(device_id)
+            if not device.connect():
+                log.critical("connect: can't connect to %s", device_id)
+                continue
+
+            settings = device.settings
+            print(f"connected to {settings.full_model()} {settings.eeprom.serial_number} with {settings.pixels()} 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 "") +
+                  f" (Microcontroller {device.settings.microcontroller_firmware_version}," +
+                  f" FPGA {settings.fpga_firmware_version})")
+
+            self.device = device
+            return True
+
+    def run(self):
+        start_time = datetime.datetime.now()
+
+        # instantiate an AutoRamanRequest, passing in the configured options
+        arr = AutoRamanRequest(max_ms         = self.args.max_ms,
+                               start_integ_ms = self.args.start_integ_ms,
+                               start_gain_db  = self.args.start_gain_db,
+                               max_integ_ms   = self.args.max_integ_ms,
+                               min_integ_ms   = self.args.min_integ_ms,
+                               max_gain_db    = self.args.max_gain_db,
+                               min_gain_db    = self.args.min_gain_db,
+                               target_counts  = self.args.target_counts,
+                               max_counts     = self.args.max_counts,
+                               min_counts     = self.args.min_counts,
+                               max_factor     = self.args.max_factor,
+                               drop_factor    = self.args.drop_factor,
+                               saturation     = self.args.saturation)
+        log.debug(f"instantiated {arr}")
+
+        # add the AutoRamanRequest to a TakeOneRequest
+        tor = TakeOneRequest(auto_raman_request=arr)
+        log.debug(f"instantiated {tor}")
+
+        # send the TakeOneRequest to the driver
+        self.device.change_setting("take_one_request", tor)
+        log.debug("sent TakeOneRequest to spectrometer")
+
+        # block on completion of the TakeOneRequest (ignore keepalives)
+        while True:
+            log.debug("calling WasatchDevice.acquire_data")
+            reading = self.device.acquire_data().data
+            log.debug(f"WasatchDevice.acquire_data returned {reading}")
+            if reading is not None:
+                break
+
+            time.sleep(1)
+
+        elapsed_sec = (datetime.datetime.now() - start_time).total_seconds()
+        print(f"Auto-Raman measurement completed in {elapsed_sec:.2f} sec")
+
+        # process Reading
+        settings = self.device.settings
+
+        # ASCII-Art
+        print("\n".join(wasatch.utils.ascii_spectrum(reading.spectrum, rows=20, cols=80, x_axis=settings.wavenumbers, x_unit="cm⁻¹")))
+
+        if self.outfile:
+            self.outfile.write("{datetime.datetime.now()}, {aar}, {', '.join([f'.2f' for x in reading.spectrum])}\n")
+
+# main()
+fixture = Fixture()
+if fixture.connect():
+    fixture.run()

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

@@ -6,13 +6,7 @@
 #  DESCRIPTION:  Simple cmd-line demo to confirm that Wasatch.PY is working    #
 #                and can connect to and control a spectrometer.                #
 #                                                                              #
-#  ENVIRONMENT:  (if using Miniconda3)                                         #
-#                $ rm -f environment.yml                                       #
-#                $ ln -s environments/conda-linux.yml  (or macos, etc)         #
-#                $ conda env create -n wasatch3                                #
-#                $ conda activate wasatch3                                     #
-#  INVOCATION:                                                                 #
-#                $ python -u demo.py                                           #
+#  INVOCATION:   $ python -u demo.py                                           #
 #                                                                              #
 ################################################################################
 
@@ -22,7 +16,6 @@ import sys
 import time
 import numpy
 import signal
-import psutil
 import logging
 import datetime
 import argparse
@@ -33,7 +26,6 @@ from wasatch import applog
 from wasatch.WasatchBus           import WasatchBus
 from wasatch.WasatchDevice        import WasatchDevice
 from wasatch.WasatchDeviceWrapper import WasatchDeviceWrapper
-from wasatch.RealUSBDevice        import RealUSBDevice
 
 log = logging.getLogger(__name__)
 
@@ -45,7 +37,7 @@ class WasatchDemo:
     #                                                                          #
     ############################################################################
 
-    def __init__(self, argv=None):
+    def __init__(self):
         self.bus     = None
         self.devices = {}
         self.logger  = None
@@ -53,7 +45,7 @@ class WasatchDemo:
         self.exiting = False
         self.reading_count = 0
 
-        self.args = self.parse_args(argv)
+        self.args = self.parse_args()
 
         if self.args.log_level != "NEVER":
             self.logger = applog.MainLogger(self.args.log_level)
@@ -65,7 +57,7 @@ class WasatchDemo:
     #                                                                          #
     ############################################################################
 
-    def parse_args(self, argv):
+    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=10,     help="integration time (ms, default 10)")
@@ -78,8 +70,7 @@ class WasatchDemo:
         parser.add_argument("--ascii-art",           action="store_true",      help="graph spectra in ASCII")
         parser.add_argument("--version",             action="store_true",      help="display Wasatch.PY version and exit")
 
-        # parse argv into dict
-        args = parser.parse_args(argv[1:])
+        args = parser.parse_args()
         if args.version:
             print("Wasatch.PY %s" % wasatch.__version__)
             sys.exit(0)
@@ -100,7 +91,7 @@ class WasatchDemo:
         # lazy-load a USB bus
         if self.bus is None:
             log.debug("instantiating WasatchBus")
-            self.bus = WasatchBus(use_sim = False)
+            self.bus = WasatchBus()
 
         if not self.bus.device_ids:
             print("No Wasatch USB spectrometers found.")
@@ -170,16 +161,30 @@ class WasatchDemo:
         # read spectra until user presses Control-Break
         while not self.exiting:
             start_time = datetime.datetime.now()
+
             if not self.args.non_blocking:
+                # if not non-blocking (i.e., blocking calls to Wasatch.PY), call 
+                # device.acquire_data() directly -- this will block on each 
+                # spectrometer in turn until we have collected one spectrum from each
+                # connected spectromter
                 for device_id, device in self.devices.items():
                     self.attempt_reading(device)
+            else:
+                # if we are non-blocking (meaning each spectrometer is free-
+                # running in its own background thread, then we don't need to do
+                # anything here -- spectra will magically "show up" at 
+                # WasatchDeviceWrapper_callback without us having to do anything,
+                # and all we need to here is check whether we've collected enough
+                # spectra to shutdown
+                pass
+
             end_time = datetime.datetime.now()
 
             if self.args.max > 0 and self.reading_count >= self.args.max:
                 log.debug("max spectra reached, exiting")
                 self.exiting = True
             else:
-                # compute how much longer we should wait before the next reading
+                # compute how much longer we should wait before the next "tick"
                 reading_time_ms = int((end_time - start_time).microseconds / 1000)
                 sleep_ms = self.args.delay_ms - reading_time_ms
                 if sleep_ms > 0:
@@ -215,11 +220,10 @@ class WasatchDemo:
         self.process_reading(reading_response.data)
 
     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).
+        # We want the demo to effectively block on new scans, so keep polling the
+        # background thread 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 = device.acquire_data()
             if reading is None:
@@ -241,8 +245,8 @@ class WasatchDemo:
 
     def process_reading(self, reading):
         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)):
+            (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
@@ -264,9 +268,8 @@ class WasatchDemo:
             spectrum_max = numpy.amax(spectrum)
             spectrum_avg = numpy.mean(spectrum)
             spectrum_std = numpy.std (spectrum)
-            size_in_bytes = psutil.Process(os.getpid()).memory_info().rss
 
-            print("%s: %s %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" % (
                 reading.timestamp,
                 settings.eeprom.serial_number,
                 self.reading_count,
@@ -274,8 +277,7 @@ class WasatchDemo:
                 spectrum_min,
                 spectrum_max,
                 spectrum_avg,
-                spectrum_std,
-                size_in_bytes))
+                spectrum_std))
             log.debug("%s", str(reading))
 
         if self.outfile:
@@ -313,7 +315,7 @@ demo = None
 if __name__ == "__main__":
     signal.signal(signal.SIGINT, signal_handler)
 
-    demo = WasatchDemo(sys.argv)
+    demo = WasatchDemo()
     if demo.connect():
         # Note that on Windows, Control-Break (SIGBREAK) differs from 
         # Control-C (SIGINT); see https://stackoverflow.com/a/1364199

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

@@ -47,7 +47,7 @@ class AndorDevice(InterfaceDevice):
     SUCCESS = 20002             #!< see load_error_codes()
     SHUTTER_SPEED_MS = 50       #!< allow time for mechanical shutter to stabilize
 
-    def __init__(self, device_id, message_queue=None): # -> None 
+    def __init__(self, device_id, message_queue=None, alert_queue=None): # -> None 
         # if passed a string representation of a DeviceID, deserialize it
         super().__init__()
         if type(device_id) is str:
@@ -55,6 +55,7 @@ class AndorDevice(InterfaceDevice):
 
         self.device_id      = device_id
         self.message_queue  = message_queue
+        self.alert_queue    = alert_queue
 
         self.load_error_codes()
 
@@ -329,7 +330,6 @@ class AndorDevice(InterfaceDevice):
                 log.debug("completed take_one")
                 self.change_setting("cancel_take_one", True)
 
-
         log.debug("device.take_one_averaged_reading: returning %s", reading)
         if reading.spectrum is not None and reading.spectrum != []:
             self.failure_count = 0