spikesafe-python 1.11.22__tar.gz → 1.13.5__tar.gz

{spikesafe_python-1.11.22/spikesafe_python.egg-info → spikesafe_python-1.13.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spikesafe-python
-Version: 1.11.22
+Version: 1.13.5
 Summary: SpikeSafe Python Library
 Author-email: Vektrex <support@vektrex.com>
 Classifier: Programming Language :: Python :: 3

{spikesafe_python-1.11.22 → spikesafe_python-1.13.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spikesafe-python"
-version = "1.11.22"
+version = "1.13.5"
 authors = [
   { name="Vektrex", email="support@vektrex.com" },
 ]

{spikesafe_python-1.11.22 → spikesafe_python-1.13.5}/spikesafe_python/DigitizerDataFetch.py

@@ -299,7 +299,7 @@ class DigitizerDataFetch:
     @staticmethod
     def wait_for_new_voltage_data(
         spike_safe_socket: TcpSocket,
-        wait_time: float = 0.0,
+        wait_time: float = 0.010,
         enable_logging: bool | None = None,
         timeout: float | None = None,
         digitizer_number: int | None = None
@@ -312,8 +312,8 @@ class DigitizerDataFetch:
         ----------
         spike_safe_socket : TcpSocket
             Socket object used to communicate with SpikeSafe
-        wait_time: float
-            Wait time in between each set of VOLT:NDAT? queries in seconds. Use get_new_voltage_data_estimated_complete_time() for the recommended value
+        wait_time: float, Optional
+            Wait time in between each set of VOLT:NDAT? queries in seconds (default 0.010s). Use get_new_voltage_data_estimated_complete_time() for the recommended value
         enable_logging : bool, Optional
             Overrides spike_safe_socket.enable_logging attribute (default to None will use spike_safe_socket.enable_logging value)
         timeout : float, Optional
@@ -392,12 +392,11 @@ class DigitizerDataFetch:
 
         if hardware_trigger_count == 1:
             # 𝑀𝑖𝑛𝑖𝑚𝑢𝑚 𝑇𝑜𝑡𝑎𝑙 𝐴𝑐𝑞𝑢𝑖𝑠𝑖𝑡𝑖𝑜𝑛 𝑇𝑖𝑚𝑒 = 𝑇𝑟𝑖𝑔𝑔𝑒𝑟 𝐶𝑜𝑢𝑛𝑡 (𝑇𝑟𝑖𝑔𝑔𝑒𝑟 𝐷𝑒𝑙𝑎𝑦+𝐴𝑝𝑒𝑟𝑡𝑢𝑟𝑒 𝑇𝑖𝑚𝑒×𝑅𝑒𝑎𝑑𝑖𝑛𝑔 𝐶𝑜𝑢𝑛𝑡)
-            estimated_complete_time_seconds = (hardware_trigger_count * (hardware_trigger_delay_microseconds + aperture_microseconds * reading_count)) / 100000
+            estimated_complete_time_seconds = (hardware_trigger_count * (hardware_trigger_delay_microseconds + aperture_microseconds * reading_count)) / 1_000_000.0
         else:
             retrigger_time_microseconds = 600
             # 𝑀𝑖𝑛𝑖𝑚𝑢𝑚 𝑇𝑜𝑡𝑎𝑙 𝐴𝑐𝑞𝑢𝑖𝑠𝑖𝑡𝑖𝑜𝑛 𝑇𝑖𝑚𝑒 = 𝑇𝑟𝑖𝑔𝑔𝑒𝑟 𝐶𝑜𝑢𝑛𝑡 (𝑇𝑟𝑖𝑔𝑔𝑒𝑟 𝐷𝑒𝑙𝑎𝑦 + Retrigger Time + 𝐴𝑝𝑒𝑟𝑡𝑢𝑟𝑒 𝑇𝑖𝑚𝑒 × 𝑅𝑒𝑎𝑑𝑖𝑛𝑔 𝐶𝑜𝑢𝑛𝑡) - Retrigger Time (ignore time last trigger)
-            estimated_complete_time_seconds = (hardware_trigger_count * (hardware_trigger_delay_microseconds + retrigger_time_microseconds + aperture_microseconds * reading_count) - retrigger_time_microseconds) / 100000
-
+            estimated_complete_time_seconds = (hardware_trigger_count * (hardware_trigger_delay_microseconds + retrigger_time_microseconds + aperture_microseconds * reading_count) - retrigger_time_microseconds) / 1_000_000.0
         # wait time cannot be less than 0s
         estimated_complete_time_seconds = max(estimated_complete_time_seconds, 0)
 
@@ -616,7 +615,7 @@ def get_new_voltage_data_estimated_complete_time(
 
 def wait_for_new_voltage_data(
     spike_safe_socket: TcpSocket,
-    wait_time: float = 0.0,
+    wait_time: float = 0.010,
     enable_logging: bool | None = None,
     timeout: float | None = None,
     digitizer_number: int | None = None

spikesafe_python-1.13.5/spikesafe_python/Discharge.py

@@ -0,0 +1,105 @@
+import time
+from .SpikeSafeInfo import SpikeSafeInfo
+from .TcpSocket import TcpSocket
+from .Threading import wait
+
+class Discharge:
+    """
+    Class for calculating SpikeSafe channel discharge time based on compliance voltage.
+
+    Methods
+    -------
+    get_spikesafe_channel_discharge_time(compliance_voltage: float) -> float
+        Returns the time in seconds to fully discharge the SpikeSafe channel based on the compliance voltage
+    wait_for_spikesafe_channel_discharge(spike_safe_socket: TcpSocket, spikesafe_info: SpikeSafeInfo, compliance_voltage: float, channel_number: int = 1, enable_logging: bool | None = None) -> None
+        Automatically waits for the SpikeSafe channel to fully discharge based on SpikeSafe capabilities.
+        If the SpikeSafe supports the Discharge Complete query, it will poll the channel until discharge is complete.
+        If not, it will wait for a calculated time based on the compliance voltage.
+    """
+
+    @staticmethod
+    def get_spikesafe_channel_discharge_time(compliance_voltage: float) -> float:
+        """
+        Returns the time in seconds to fully discharge the SpikeSafe channel based on the compliance voltage
+
+        Parameters
+        ----------
+        compliance_voltage : float
+            Compliance voltage to factor in discharge time
+        
+        Returns
+        -------
+        float
+            Discharge time in seconds
+
+        Raises
+        ------
+        None
+        """
+        # Discharge time accounting for compliance voltage, voltage readroom, and discharge voltage per second
+        voltage_headroom_voltage = 7
+        discharge_voltage_per_second = 1000
+        discharge_time = (compliance_voltage + voltage_headroom_voltage) / discharge_voltage_per_second
+        return discharge_time
+
+    @staticmethod
+    def wait_for_spikesafe_channel_discharge(
+        spikesafe_socket: TcpSocket,
+        spikesafe_info: SpikeSafeInfo,
+        compliance_voltage: float,
+        channel_number: int = 1,
+        enable_logging: bool | None = None
+    ) -> None:
+        """
+        Automatically waits for the SpikeSafe channel to fully discharge based on SpikeSafe capabilities.
+        If the SpikeSafe supports the Discharge Complete query, it will poll the channel until discharge is complete.
+        If not, it will wait for a calculated time based on the compliance voltage.
+
+        Parameters
+        ----------
+        spikesafe_socket : TcpSocket
+            Socket object used to communicate with SpikeSafe.
+        spikesafe_info : SpikeSafeInfo
+            An object containing the SpikeSafe information.
+        compliance_voltage : float
+            Compliance voltage to factor in discharge time.
+        channel_number : int, optional
+            Channel number to wait for discharge. By default, this is 1.
+        enable_logging : bool, optional
+            Overrides spikesafe_socket.enable_logging attribute (default to None will use spikesafe_socket.enable_logging value).
+
+        Raises
+        ------
+        TimeoutError
+            Thrown when the wait times out.
+        Exception
+            On any error.
+        """
+        if spikesafe_info.supports_discharge_query:
+            # when Discharge Complete query is supported, query for completion
+            expected_compliance_voltage_discharge_time = Discharge.get_spikesafe_channel_discharge_time(compliance_voltage)
+            expected_max_model_discharge_time = Discharge.get_spikesafe_channel_discharge_time(spikesafe_info.maximum_compliance_voltage + 35) # 35V gives extra time, some windows pcs return early from wait function
+
+            start_time = time.time()
+            # wait until the channel is fully discharged before disconnecting the load
+            is_discharge_complete = ""
+            while True:
+                spikesafe_socket.send_scpi_command(f"OUTP{channel_number}:DISC:COMP?", enable_logging)
+                is_discharge_complete = spikesafe_socket.read_data(enable_logging)
+
+                if is_discharge_complete == "TRUE":
+                    break
+
+                elapsed_seconds = time.time() - start_time
+                if elapsed_seconds > expected_max_model_discharge_time:
+                    raise TimeoutError(f"SpikeSafe channel discharge expected discharge time is {expected_compliance_voltage_discharge_time} seconds, but this exceeded the model {spikesafe_info.maximum_compliance_voltage}V maximum time of {expected_max_model_discharge_time} seconds.")
+        else:
+            # when Discharge Complete query is not supported, use a calculated wait time
+            wait_time = Discharge.get_spikesafe_channel_discharge_time(compliance_voltage + 35) # 35V gives extra time, some windows pcs return early from wait function
+            wait(wait_time)
+
+def get_spikesafe_channel_discharge_time(compliance_voltage: float) -> float:
+    """
+    Obsolete: use Discharge.get_spikesafe_channel_discharge_time instead
+    """
+    return Discharge.get_spikesafe_channel_discharge_time(compliance_voltage)

{spikesafe_python-1.11.22 → spikesafe_python-1.13.5}/spikesafe_python/PulseWidthCorrection.py

@@ -1,4 +1,5 @@
 from .SpikeSafeEnums import LoadImpedance, RiseTime
+from .SpikeSafeInfo import SpikeSafeInfo
 
 class PulseWidthCorrection:
     """
@@ -12,7 +13,7 @@ class PulseWidthCorrection:
 
     @staticmethod
     def get_optimum_pulse_width_correction(
-        spikesafe_model_max_current_amps: float,
+        spikesafe_info: SpikeSafeInfo,
         set_current_amps: float,
         load_impedance: LoadImpedance,
         rise_time: RiseTime
@@ -22,8 +23,8 @@ class PulseWidthCorrection:
 
         Parameters
         ----------
-        spikesafe_model_max_current_amps : float
-            Maximum current of the SpikeSafe model.
+        spikesafe_info : SpikeSafeInfo
+            An object containing the SpikeSafe information.
         set_current_amps : float
             Current to be set on SpikeSafe.
         load_impedance : LoadImpedance
@@ -48,25 +49,25 @@ class PulseWidthCorrection:
         default_correction = "1.250"
 
         # Test to see if the current is above the model capability
-        if set_current_amps > spikesafe_model_max_current_amps:
-            raise ValueError(f'Measurement current {set_current_amps}A exceeds SpikeSafe model maximum current capability of {spikesafe_model_max_current_amps}A.')
+        if set_current_amps > spikesafe_info.maximum_set_current:
+            raise ValueError(f'Measurement current {set_current_amps}A exceeds SpikeSafe model maximum current capability of {spikesafe_info.maximum_set_current}A.')
         
         # Dictionary to store values for different model max currents, arranged by max current of model number. The 9th order coefficient is first.
         model_params = PulseWidthCorrection.__get_optimum_pulse_width_correction_table()
     
         # Check if the given spikesafe_model_max_current_amps is in the model_params, if it is not, just return the default correction
-        if spikesafe_model_max_current_amps not in model_params:
+        if spikesafe_info.maximum_set_current not in model_params:
             return default_correction
         
         # Determine if we are in the high or low range
-        low_current_range_maximum = model_params[spikesafe_model_max_current_amps]['low_current_range_maximum']
+        low_current_range_maximum = model_params[spikesafe_info.maximum_set_current]['low_current_range_maximum']
         if set_current_amps > low_current_range_maximum:
             current_range = 'HIGH'
         else:
             current_range = 'LOW'
 
         # Retrieve dictionary
-        dictionary = model_params[spikesafe_model_max_current_amps][(current_range, load_impedance, rise_time)]
+        dictionary = model_params[spikesafe_info.maximum_set_current][(current_range, load_impedance, rise_time)]
 
         # Check if the set current exceeds the max test current, if it does evaluate polynomial at max test current
         if set_current_amps > dictionary['max_test_current']:
@@ -74,7 +75,7 @@ class PulseWidthCorrection:
 
         # Retrieve the polynomial coefficients for the given conditions, if there is no definition for these conditions, return the default correction value
         try:
-            coefficient_data = model_params[spikesafe_model_max_current_amps][(current_range, load_impedance, rise_time)]
+            coefficient_data = model_params[spikesafe_info.maximum_set_current][(current_range, load_impedance, rise_time)]
             # Extract nested coefficients
             polynomial_coefficients = coefficient_data['coefficients']
         except KeyError:
@@ -86,10 +87,12 @@ class PulseWidthCorrection:
         # Evaluate the polynomial
         correction_value = sum(c * (set_current_amps ** i) for i, c in enumerate(reversed(polynomial_coefficients)))
         
-        # If needed, coerce the Pulse Width Correction Value to be within firmware programmable limits
-        if correction_value > 50:
-            correction_value = 50
-        if correction_value < 0: # do not allow negative correction, usually this is caused by polynomial calculation issues
+        # Force to maximum pulse correction due to firmware limitations
+        if correction_value > spikesafe_info.maximum_pulse_width_correction_override:
+            correction_value = spikesafe_info.maximum_pulse_width_correction_override
+        
+        # Negative values are not valid and should not be taken into account when generated by the polynomial
+        if correction_value < 0:
             correction_value = 0
 
         return f"{correction_value:.3f}"
@@ -2624,4 +2627,8 @@ def get_optimum_pulse_width_correction(
     """
     Obsolete: use PulseWidthCorrection.get_optimum_pulse_width_correction() instead
     """
-    return PulseWidthCorrection.get_optimum_pulse_width_correction(spikesafe_model_max_current_amps, set_current_amps, load_impedance, rise_time)
+    spikesafe_info = SpikeSafeInfo()
+    spikesafe_info.maximum_pulse_width_correction_override = 9
+    spikesafe_info.maximum_set_current = spikesafe_model_max_current_amps
+
+    return PulseWidthCorrection.get_optimum_pulse_width_correction(spikesafe_info, set_current_amps, load_impedance, rise_time)

{spikesafe_python-1.11.22 → spikesafe_python-1.13.5}/spikesafe_python/ReadAllEvents.py

@@ -7,6 +7,7 @@
 
 from __future__ import annotations
 import logging
+import time
 from .EventData import EventData
 from .SpikeSafeError import SpikeSafeError
 from .TcpSocket import TcpSocket
@@ -99,7 +100,8 @@ class ReadAllEvents:
     def read_until_event(
         spike_safe_socket: TcpSocket,
         code: int,
-        enable_logging: bool | None = None
+        enable_logging: bool | None = None,
+        timeout: float | None = None
     ) -> list[EventData]:
         """Returns an array of all events from the SpikeSafe event queue until a specific event is read.
 
@@ -111,6 +113,8 @@ class ReadAllEvents:
             Event code for desired event
         enable_logging : bool, Optional
             Overrides spike_safe_socket.enable_logging attribute (default to None will use spike_safe_socket.enable_logging value)
+        timeout: float, Optional
+            Maximum time in seconds to wait for the desired event before raising an exception (default to None will wait indefinitely)
         
         Returns
         -------
@@ -130,7 +134,10 @@ class ReadAllEvents:
             event_data_list = []
 
             # initialize flag to check if event queue is empty 
-            has_desired_event_occurred = False                                                                                                                      
+            has_desired_event_occurred = False
+
+            # Record the start time  
+            start_time = time.time()                                                                                                                    
 
             # run as long as there is an event in the SpikeSafe queue
             while has_desired_event_occurred == False:
@@ -157,7 +164,12 @@ class ReadAllEvents:
                         has_desired_event_occurred = True                                                 
                 else:
                     # unexpected response detected from SpikeSafe, end checking
-                    raise Exception('No event response from SpikeSafe: {}'.format(event_response))  
+                    raise Exception('No event response from SpikeSafe: {}'.format(event_response))                
+                
+                # if a timeout value was provided, check if the timeout has been exceeded and raise an exception if so
+                if timeout is not None:
+                    if time.time() - start_time > timeout:
+                        raise Exception(f'Timeout of {timeout} seconds exceeded while waiting for event code {code}')
 
             # return event list to caller        
             return event_data_list                                                                  

{spikesafe_python-1.11.22 → spikesafe_python-1.13.5}/spikesafe_python/SpikeSafeEvents.py

@@ -28,6 +28,9 @@ class SpikeSafeEvents(IntEnum):
     MAC_ADDRESS_IS_NOT_CONFIGURED = 123
     NO_EXTERNAL_SOURCE_TRIGGER_OUTPUT_DUE_TO_PULSE_WIDTH_ADJUSTMENT_IS_DISABLED_INTERNALLY = 124
     MAX_COMPLIANCE_VOLTAGE_EXCEEDED_LIMIT = 125
+    CURRENT_RAMP_RATE_RESTORED = 126
+    STAIRCASE_SWEEP_IS_COMPLETED = 127
+    STAIRCASE_SWEEP_SHUTDOWN_DUE_TO_ERROR = 128
     MAX_COMPLIANCE_VOLTAGE_EXCEEDED = 200
     HIGH_SIDE_OVER_CURRENT = 201
     LOW_SIDE_OVER_CURRENT = 202
@@ -180,3 +183,5 @@ class SpikeSafeEvents(IntEnum):
     EXCEED_MAX_SAMPLING_CUSTOM_SEQUENCE_APERTURE = 509
     CANNOT_COMMUNICATE_WITH_DIGITIZER = 510
     INVALID_VOLTAGE_PROTECTION_MODE = 600
+    INVALID_STAIRCASE_SWEEP_ON_TIME = 602
+    INVALID_STAIRCASE_SWEEP_STEP_COUNT = 603

{spikesafe_python-1.11.22 → spikesafe_python-1.13.5}/spikesafe_python/SpikeSafeInfo.py

@@ -76,6 +76,7 @@ class SpikeSafeInfo:
     maximum_set_current: float | None
     minimum_pulse_width: float | None
     maximum_pulse_width: float | None
+    maximum_pulse_width_correction_override: float | None
     minimum_pulse_width_offset: float | None
     maximum_pulse_width_offset: float | None
 
@@ -107,6 +108,7 @@ class SpikeSafeInfo:
         self.maximum_set_current = None
         self.minimum_pulse_width = None
         self.maximum_pulse_width = None
+        self.maximum_pulse_width_correction_override = None
         self.minimum_pulse_width_offset = None
         self.maximum_pulse_width_offset = None
 

{spikesafe_python-1.11.22 → spikesafe_python-1.13.5}/spikesafe_python/SpikeSafeInfoParser.py

@@ -49,6 +49,7 @@ class SpikeSafeInfoParser:
         spikesafe_info.maximum_pulse_width = SpikeSafeInfoParser._query_float(spike_safe_socket, 'SOUR0:PULS:TON? MAX', enable_logging)
         spikesafe_info.minimum_pulse_width_offset = SpikeSafeInfoParser._query_float(spike_safe_socket, 'SOUR0:PULS:OFFS? MIN', enable_logging)
         spikesafe_info.maximum_pulse_width_offset = SpikeSafeInfoParser._query_float(spike_safe_socket, 'SOUR0:PULS:OFFS? MAX', enable_logging)
+        spikesafe_info.maximum_pulse_width_correction_override = 50 if SpikeSafeInfoParser.compare_rev_version(spikesafe_info.version, "3.0.15.5") else 9 # Older firmware had a max correction of 9us, but newer firmware supports up to 50us to compensate for the Pulse Width Adjustment algorithm's maximum adjustment
 
         spike_safe_socket.send_scpi_command('MEM:DATA ZINNUM?')
         zin_number = spike_safe_socket.read_data(enable_logging)

{spikesafe_python-1.11.22 → spikesafe_python-1.13.5}/spikesafe_python/TcpSocket.py

@@ -63,9 +63,10 @@ class TcpSocket:
         try:
             self.socket_ip_address = ip_address
 
-            # create socket with 2 second timeout and connect to SpikeSafe
+            # create socket with 2 second timeout, 512 byte send max buffer to match SpikeSafe's command buffer, and connect to SpikeSafe
             self.tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)          
             self.tcp_socket.settimeout(2)
+            self.tcp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 512)
 
             if (self.enable_logging):
                 log.log(self.default_log_level, self.__get_formatted_log_message__('Connecting...'))

{spikesafe_python-1.11.22 → spikesafe_python-1.13.5/spikesafe_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spikesafe-python
-Version: 1.11.22
+Version: 1.13.5
 Summary: SpikeSafe Python Library
 Author-email: Vektrex <support@vektrex.com>
 Classifier: Programming Language :: Python :: 3

{spikesafe_python-1.11.22 → spikesafe_python-1.13.5}/spikesafe_python.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ tests/test_digitizer_fetch_time_of_sampling.py
 tests/test_digitizer_fetch_time_of_sampling_old.py
 tests/test_event_data.py
 tests/test_event_data_old.py
+tests/test_get_new_voltage_data_estimated_complete_time.py
 tests/test_optimum_compensation.py
 tests/test_optimum_compensation_old.py
 tests/test_optimum_pulse_width_correction.py

spikesafe_python-1.13.5/tests/test_get_new_voltage_data_estimated_complete_time.py

@@ -0,0 +1,26 @@
+import pytest
+from spikesafe_python.DigitizerDataFetch import DigitizerDataFetch
+
+@pytest.mark.parametrize(
+    "aperture_microseconds, reading_count, hardware_trigger_count, hardware_trigger_delay_microseconds, expected",
+    [
+        # 488us aperture, 1 reading, 1 hardware trigger, 200us delay
+        (488, 1, 1, 200, 0.000688),        
+        # 500us aperture, 1 reading, 1 hardware trigger, 150us delay
+        (500, 1, 1, 150, 0.00065),
+        # 694us aperture, 1 reading, 1 hardware trigger, 0us delay
+        (694, 1, 1, 0, 0.000694),
+        # 25ms aperture, 1 reading, 1 hardware trigger, 3ms delay
+        (25000, 1, 1, 3000, 0.028),
+    ]
+)
+def test_get_new_voltage_data_estimated_complete_time(
+    aperture_microseconds, reading_count, hardware_trigger_count, hardware_trigger_delay_microseconds, expected
+):
+    result = DigitizerDataFetch.get_new_voltage_data_estimated_complete_time(
+        aperture_microseconds,
+        reading_count,
+        hardware_trigger_count,
+        hardware_trigger_delay_microseconds
+    )
+    assert pytest.approx(result, rel=1e-6) == expected

spikesafe_python-1.13.5/tests/test_optimum_pulse_width_correction.py

@@ -0,0 +1,38 @@
+import pytest
+import spikesafe_python
+
+@pytest.mark.parametrize("maximum_pulse_width_correction_override, model_max_current, set_current, load_impedance, rise_time, expected", [
+    (50, 10, 4, spikesafe_python.SpikeSafeEnums.LoadImpedance.VERY_LOW, spikesafe_python.SpikeSafeEnums.RiseTime.VERY_SLOW, '2.476'),  # Add expected value
+    (9, 0.05, 0.0039, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '9.000'),   # test 50mA low range first entry for older firmware with 9us max correction override
+    (50, 0.05, 0.0039, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '11.289'),   # test 50mA low range first entry
+    (50, 0.5, 0.0159, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.943'),     # test 500mA low range first entry < 0.016 max_test_current
+    (50, 0.5, 0.0160, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.924'),     # test 500mA low range first entry = 0.016 max_test_current
+    (50, 0.5, 0.0161, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.924'),     # test 500mA low range first entry > 0.016 max_test_current
+    (50, 0.5, 0.038, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.924'),      # test 500mA low range second entry = 0.038 max_test_current
+    (50, 0.5, 0.470, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.495'),      # test high 500mA range first entry < 0.470 max_test_current
+    (50, 0.5, 0.471, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.496'),      # test high 500mA range first entry = 0.471 max_test_current
+    (50, 0.5, 0.472, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.496'),      # test high 500mA range first entry > 0.472 max_test_current
+    (50, 0.5, 0.5, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.496'),        # test high model_max_current 500mA range = 0.5 set_current_amps
+    (50, 5, 0.001, spikesafe_python.SpikeSafeEnums.LoadImpedance.VERY_LOW, spikesafe_python.SpikeSafeEnums.RiseTime.VERY_SLOW, '50.000'),   # test calculated >9us correction coerced to 9us
+    (50, 0.5, 0.0438, spikesafe_python.SpikeSafeEnums.LoadImpedance.MEDIUM, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '0.000'),   # test calculated negative correction coerced to 0
+    (50, 25, 21, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.250'),          # test invalid 25A model
+])
+def test_get_optimum_pulse_width_correction_value(maximum_pulse_width_correction_override, model_max_current, set_current, load_impedance, rise_time, expected):
+    spikesafe_info = spikesafe_python.SpikeSafeInfo()
+    spikesafe_info.maximum_pulse_width_correction_override = maximum_pulse_width_correction_override
+    spikesafe_info.maximum_set_current = model_max_current
+
+    correction_value = spikesafe_python.PulseWidthCorrection.get_optimum_pulse_width_correction(spikesafe_info, set_current, load_impedance, rise_time)
+    assert correction_value == expected
+
+@pytest.mark.parametrize("model_max_current, set_current, load_impedance, rise_time, expected_error_message", [
+    (0.05, 0.051, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, 'Measurement current 0.051A exceeds SpikeSafe model maximum current capability of 0.05A.'),   # test set_current > model_max_current
+])
+def test_test_get_optimum_pulse_width_correction_exceptions(model_max_current, set_current, load_impedance, rise_time, expected_error_message):
+    spikesafe_info = spikesafe_python.SpikeSafeInfo()
+    spikesafe_info.maximum_pulse_width_correction_override = 9
+    spikesafe_info.maximum_set_current = model_max_current
+
+    with pytest.raises(ValueError) as exc_info:
+        spikesafe_python.PulseWidthCorrection.get_optimum_pulse_width_correction(spikesafe_info, set_current, load_impedance, rise_time)
+    assert expected_error_message in str(exc_info.value)

{spikesafe_python-1.11.22 → spikesafe_python-1.13.5}/tests/test_optimum_pulse_width_correction_old.py

@@ -4,7 +4,7 @@ from spikesafe_python.SpikeSafeEnums import LoadImpedance, RiseTime
 
 @pytest.mark.parametrize("model_max_current, set_current, load_impedance, rise_time, expected", [
     (10, 4, LoadImpedance.VERY_LOW, RiseTime.VERY_SLOW, '2.476'),  # Add expected value
-    (0.05, 0.0039, LoadImpedance.HIGH, RiseTime.FAST, '11.289'),   # test 50mA low range first entry
+    (0.05, 0.0039, LoadImpedance.HIGH, RiseTime.FAST, '9.000'),   # test 50mA low range first entry
     (0.5, 0.0159, LoadImpedance.HIGH, RiseTime.FAST, '1.943'),     # test 500mA low range first entry < 0.016 max_test_current
     (0.5, 0.0160, LoadImpedance.HIGH, RiseTime.FAST, '1.924'),     # test 500mA low range first entry = 0.016 max_test_current
     (0.5, 0.0161, LoadImpedance.HIGH, RiseTime.FAST, '1.924'),     # test 500mA low range first entry > 0.016 max_test_current
@@ -13,7 +13,7 @@ from spikesafe_python.SpikeSafeEnums import LoadImpedance, RiseTime
     (0.5, 0.471, LoadImpedance.HIGH, RiseTime.FAST, '1.496'),      # test high 500mA range first entry = 0.471 max_test_current
     (0.5, 0.472, LoadImpedance.HIGH, RiseTime.FAST, '1.496'),      # test high 500mA range first entry > 0.472 max_test_current
     (0.5, 0.5, LoadImpedance.HIGH, RiseTime.FAST, '1.496'),        # test high model_max_current 500mA range = 0.5 set_current_amps
-    (5, 0.001, LoadImpedance.VERY_LOW, RiseTime.VERY_SLOW, '50.000'),   # test calculated >50us correction coerced to 50us
+    (5, 0.001, LoadImpedance.VERY_LOW, RiseTime.VERY_SLOW, '9.000'),   # test calculated >9us correction coerced to 9us
     (0.5, 0.0438, LoadImpedance.MEDIUM, RiseTime.FAST, '0.000'),   # test calculated negative correction coerced to 0
     (25, 21, LoadImpedance.HIGH, RiseTime.FAST, '1.250'),          # test invalid 25A model
 ])

spikesafe_python-1.11.22/spikesafe_python/Discharge.py

@@ -1,75 +0,0 @@
-from .TcpSocket import TcpSocket
-
-class Discharge:
-    """
-    Class for calculating SpikeSafe channel discharge time based on compliance voltage.
-
-    Methods
-    -------
-    get_spikesafe_channel_discharge_time(compliance_voltage: float) -> float
-        Returns the time in seconds to fully discharge the SpikeSafe channel based on the compliance voltage
-    wait_for_spikesafe_channel_discharge(tcp_socket: TcpSocket, channel_number: int) -> None
-        Waits for the SpikeSafe channel to fully discharge
-    """
-
-    @staticmethod
-    def get_spikesafe_channel_discharge_time(compliance_voltage: float) -> float:
-        """
-        Returns the time in seconds to fully discharge the SpikeSafe channel based on the compliance voltage
-
-        Parameters
-        ----------
-        compliance_voltage : float
-            Compliance voltage to factor in discharge time
-        
-        Returns
-        -------
-        float
-            Discharge time in seconds
-
-        Raises
-        ------
-        None
-        """
-        # Discharge time accounting for compliance voltage, voltage readroom, and discharge voltage per second
-        voltage_headroom_voltage = 7
-        discharge_voltage_per_second = 1000
-        discharge_time = (compliance_voltage + voltage_headroom_voltage) / discharge_voltage_per_second
-        return discharge_time
-
-    @staticmethod
-    def wait_for_spikesafe_channel_discharge(
-        tcp_socket: TcpSocket, 
-        channel_number: int,
-        enable_logging: bool | None = None
-    ) -> None:
-        """
-        Waits for the SpikeSafe channel to fully discharge
-
-        Parameters
-        ----------
-        tcp_socket : TcpSocket
-            TCP socket connection to the SpikeSafe device
-        channel_number : int
-            Channel number to poll discharge state of
-        
-        Returns
-        -------
-        None
-
-        Raises
-        ------
-        Exception
-            On any error
-        """
-        # wait until the channel is fully discharged before disconnecting the load
-        is_discharge_complete = ''                
-        while is_discharge_complete != 'TRUE':                
-            tcp_socket.send_scpi_command(f'OUTP{channel_number}:DISC:COMP?', enable_logging)
-            is_discharge_complete = tcp_socket.read_data(enable_logging)
-
-def get_spikesafe_channel_discharge_time(compliance_voltage: float) -> float:
-    """
-    Obsolete: use Discharge.get_spikesafe_channel_discharge_time instead
-    """
-    return Discharge.get_spikesafe_channel_discharge_time(compliance_voltage)

spikesafe_python-1.11.22/tests/test_optimum_pulse_width_correction.py

@@ -1,29 +0,0 @@
-import pytest
-import spikesafe_python
-
-@pytest.mark.parametrize("model_max_current, set_current, load_impedance, rise_time, expected", [
-    (10, 4, spikesafe_python.SpikeSafeEnums.LoadImpedance.VERY_LOW, spikesafe_python.SpikeSafeEnums.RiseTime.VERY_SLOW, '2.476'),  # Add expected value
-    (0.05, 0.0039, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '11.289'),   # test 50mA low range first entry
-    (0.5, 0.0159, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.943'),     # test 500mA low range first entry < 0.016 max_test_current
-    (0.5, 0.0160, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.924'),     # test 500mA low range first entry = 0.016 max_test_current
-    (0.5, 0.0161, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.924'),     # test 500mA low range first entry > 0.016 max_test_current
-    (0.5, 0.038, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.924'),      # test 500mA low range second entry = 0.038 max_test_current
-    (0.5, 0.470, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.495'),      # test high 500mA range first entry < 0.470 max_test_current
-    (0.5, 0.471, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.496'),      # test high 500mA range first entry = 0.471 max_test_current
-    (0.5, 0.472, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.496'),      # test high 500mA range first entry > 0.472 max_test_current
-    (0.5, 0.5, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.496'),        # test high model_max_current 500mA range = 0.5 set_current_amps
-    (5, 0.001, spikesafe_python.SpikeSafeEnums.LoadImpedance.VERY_LOW, spikesafe_python.SpikeSafeEnums.RiseTime.VERY_SLOW, '50.000'),   # test calculated >50us correction coerced to 50us
-    (0.5, 0.0438, spikesafe_python.SpikeSafeEnums.LoadImpedance.MEDIUM, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '0.000'),   # test calculated negative correction coerced to 0
-    (25, 21, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, '1.250'),          # test invalid 25A model
-])
-def test_get_optimum_pulse_width_correction_value(model_max_current, set_current, load_impedance, rise_time, expected):
-    correction_value = spikesafe_python.PulseWidthCorrection.get_optimum_pulse_width_correction(model_max_current, set_current, load_impedance, rise_time)
-    assert correction_value == expected
-
-@pytest.mark.parametrize("model_max_current, set_current, load_impedance, rise_time, expected_error_message", [
-    (0.05, 0.051, spikesafe_python.SpikeSafeEnums.LoadImpedance.HIGH, spikesafe_python.SpikeSafeEnums.RiseTime.FAST, 'Measurement current 0.051A exceeds SpikeSafe model maximum current capability of 0.05A.'),   # test set_current > model_max_current
-])
-def test_test_get_optimum_pulse_width_correction_exceptions(model_max_current, set_current, load_impedance, rise_time, expected_error_message):
-    with pytest.raises(ValueError) as exc_info:
-        spikesafe_python.PulseWidthCorrection.get_optimum_pulse_width_correction(model_max_current, set_current, load_impedance, rise_time)
-    assert expected_error_message in str(exc_info.value)