Merge pull request #44 from VektrexElectronicSystems/development

Development

Author: eljayg

.vscode/settings.json

@@ -1,5 +1,5 @@
 {
-    "python.pythonPath": ".venv\\Scripts\\python.exe",
     "python.linting.pylintEnabled": true,
-    "python.linting.enabled": true
+    "python.linting.enabled": true,
+    "python.envFile": "${workspaceFolder}/.env"
 }

README.md

@@ -1,15 +1,15 @@
 # SpikeSafe Python Samples
 
 Use these code samples to start learning how to communicate with your SpikeSafe via TCP/IP using Python. Sequences can be run with the following Vektrex products:
- - [SpikeSafe SMU](https://www.vektrex.com/products/spikesafe-source-measure-unit/)
+ - [SpikeSafe PSMU](https://www.vektrex.com/products/spikesafe-source-measure-unit/)
  - [SpikeSafe Performance Series ("PRF")](https://www.vektrex.com/products/spikesafe-performance-series-precision-pulsed-current-sources/)
 
 ## Directory
 
 - [Getting Started](getting_started) - These sequences are primarily intended for first-time users of Vektrex products. They contain steps to perform the basic tasks that are necessary to run the sequences within the run_spikesafe_operating_modes folder.
 - [Run SpikeSafe Operating Modes](run_spikesafe_operating_modes) - These folders contain examples to run specific SpikeSafe modes designed to test LEDs, Lasers, and electrical equipment. Basic settings will be sent to the SpikeSafe, and then one or more channels will be enabled to demonstrate the operation of each mode.
-- [Making Integrated Voltage Measurements](making_integrated_voltage_measurements) - These folders contain examples to measure voltage using the SpikeSafe SMU's integrated voltage Digitizer. The SpikeSafe outputs current to an LED, Laser, or electrical equipment, and then voltage measurements are read and displayed onscreen.
-- [Using the Force Sense Selector Switch](using_force_sense_selector_switch) - These folders contain examples to operate the optional integrated switch within the SpikeSafe SMU. The SpikeSafe outputs to an LED, Laser, or electrical equipment as in the previous examples, and the switch is used to either disconnect the SpikeSafe from the test circuit or to operate an auxiliary source to power the DUT.
+- [Making Integrated Voltage Measurements](making_integrated_voltage_measurements) - These folders contain examples to measure voltage using the SpikeSafe PSMU's integrated voltage Digitizer. The SpikeSafe outputs current to an LED, Laser, or electrical equipment, and then voltage measurements are read and displayed onscreen.
+- [Using the Force Sense Selector Switch](using_force_sense_selector_switch) - These folders contain examples to operate the optional integrated switch within the SpikeSafe PSMU. The SpikeSafe outputs to an LED, Laser, or electrical equipment as in the previous examples, and the switch is used to either disconnect the SpikeSafe from the test circuit or to operate an auxiliary source to power the DUT.
 - [Application-Specific Examples](application_specific_examples) - These folders consist of more advanced sequences to address specific test scenarios, as well as some demonstrations to fine-tune your SpikeSafe current output. These sequences explain how to make light measurements using a SpikeSafe and a spectrometer, how to make in-situ junction temperature measurements on LEDs, and how to take full advantage of all SpikeSafe features.
 
 ## Usage
@@ -28,6 +28,9 @@ Some sequences involve graphing measurement results. To properly graph results,
 ### Installing PyCLibrary Package
 Some sequences require external C resources, and requires the [PyCLibrary](https://pyclibrary.readthedocs.io/en/latest/) library. To install this library, enter the command `python -m pip install pyclibrary`. Once the PyCLibrary library is installed, each sequence that involves external C resources can be run as a standalone Python file.
 
+### Installing pyserial Package
+Some sequences involve connecting to a serial interface instrument and requires the [pyserial](https://pypi.org/project/pyserial/) library (version 3.5 or greater). Use the command `python -m pip install pyserial` to install the latest version of pyserial. Once the pyserial library is installed, each sequence that involves a serial interface can be run as a standalone Python file.
+
 ### General Usage
 For most examples, you may need to modify the specified IP address within a sequence to match the IP address that is physically set on your SpikeSafe's DIP switch. In each sequence, the default IP address of 10.0.0.220 is set in the line `ip_address = '10.0.0.220'`.
 

application_specific_examples/README.md

@@ -1,9 +1,12 @@
 # Application-Specific Examples
 
-These sequences address specific scenarios in which SpikeSafe functionality is used in an integrated test system, or scenarios where more advanced SpikeSafe settings need to be tuned to meet specific criteria. These sequences are for users that are comfortable with the basic functionality of the SpikeSafe PRF or SMU. See individual folders' descriptions for more information on each sequence.
+These sequences address specific scenarios in which SpikeSafe functionality is used in an integrated test system, or scenarios where more advanced SpikeSafe settings need to be tuned to meet specific criteria. These sequences are for users that are comfortable with the basic functionality of the SpikeSafe PRF or PSMU. See individual folders' descriptions for more information on each sequence.
 
 ## Directory
+- [Controlling Thermal Platform Temperature](controlling_thermal_platform_temperature)
+- [Fixed Pulse Count Using Software Timing](fixed_pulse_count_using_software_timing)
 - [Making Tj Measurements](making_tj_measurements)
+- [Measuring DC Staircase Voltages](measuring_dc_staircase_voltages)
 - [Measuring Wavelength Spectrum](measuring_wavelength_spectrum)
 - [Pulse Tuning](pulse_tuning)
 - [Running LIV Sweeps](running_liv_sweeps)

application_specific_examples/controlling_thermal_platform_temperature/ControllingThermalPlatformTemperature.py

@@ -0,0 +1,104 @@
+# Goal: 
+# Use TEC to ramp up to 50°C, stabilize, and run for 10 minutes; then ramp down to 25°C, stabilize, and run for 10 minutes.
+
+import logging
+import sys
+import time
+from datetime import datetime, timedelta
+from SerialInterface import SerialInterfaceDll
+from time import sleep
+
+### set these before starting application
+set_temperature_one = 50
+set_temperature_one_stability_minutes = 10
+set_temperature_two = 25
+set_temperature_two_stability_minutes = 10
+
+### setting up sequence log
+log = logging.getLogger(__name__)
+logging.basicConfig(filename='SpikeSafePythonSamples.log',format='%(asctime)s, %(levelname)s, %(message)s',datefmt='%m/%d/%Y %I:%M:%S',level=logging.INFO)
+
+### start of main program
+try:
+    log.info("ControllingThermalPlatformTemperature.py started.")
+
+    TEC_controller = SerialInterfaceDll()
+
+    # Set the beep enable sound
+    TEC_controller.write_command("BEEP 1")
+
+    # Set the mount type to 284 TEC High Power LaserMount.
+    # Will default sensor type, sensor coefficients, gain, fan mode, and current limit
+    TEC_controller.write_command("TEC:MOUNT 284")
+
+    # Set temperature control mode
+    TEC_controller.write_command("TEC:MODE:T")
+
+    # Set the heat/cool mode to both
+    TEC_controller.write_command("TEC:HEATCOOL BOTH")
+
+    # Set the low set temperature limit to 10°C
+    TEC_controller.write_command("TEC:LIMit:TLO 10")
+
+    # Set the high set temperature limit to 85°C
+    TEC_controller.write_command("TEC:LIMit:THI 85")
+
+    # Set platform tolerance to be within 0.5°C of set point for 30 seconds
+    TEC_controller.write_command("TEC:TOLerance 0.5, 30")
+
+    ##### Target temperature 1
+
+    # Set set temperature to set_temperature_one
+    TEC_controller.write_command("TEC:T {0}".format(set_temperature_one))
+
+    # Set controller output to on
+    TEC_controller.write_command("TEC:OUT 1")
+
+    # Monitor until TEC is in tolerance
+    while True:
+        TEC_out_of_tolerance = TEC_controller.write_command("TEC:COND?")
+        if TEC_controller.isKthBitSet(TEC_out_of_tolerance, 9) == True:
+            break
+
+    # Let TEC temperature stabilize while in tolerance
+    TEC_stability_start_time = time.time()
+    while True:
+        TEC_out_of_tolerance = TEC_controller.write_command("TEC:COND?")
+        if ((TEC_controller.isKthBitSet(TEC_out_of_tolerance, 9) == True) and 
+            (time.time() - TEC_stability_start_time - 30 >= set_temperature_one_stability_minutes * 60)):
+                break
+        else:
+            break
+
+    # Set set temperature to set_temperature_two
+    TEC_controller.write_command("TEC:T {0}".format(set_temperature_two))
+
+    ##### Target temperature 2
+
+    # Monitor until TEC is in tolerance
+    while True:
+        TEC_out_of_tolerance = TEC_controller.write_command("TEC:COND?")
+        if TEC_controller.isKthBitSet(TEC_out_of_tolerance, 9) == True:
+            break
+
+    # Let TEC temperature stabilize while in tolerance
+    TEC_stability_start_time = time.time()
+    while True:
+        TEC_out_of_tolerance = TEC_controller.write_command("TEC:COND?")
+        if ((TEC_controller.isKthBitSet(TEC_out_of_tolerance, 9) == True) and 
+            (time.time() - TEC_stability_start_time - 30 >= set_temperature_two_stability_minutes * 60 * 60)):
+                break
+        else:
+            break
+
+    ##### Disconnect
+    TEC_controller.close()
+
+    log.info("ControllingThermalPlatformTemperature.py completed.\n")
+
+except Exception as err:
+    # print any general exception to both the terminal and the log file, then exit the application
+    error_message = 'Program error: {}\n'.format(err)
+    log.error(error_message)       
+    print(error_message)   
+    sys.exit(1)

application_specific_examples/controlling_thermal_platform_temperature/README.md

@@ -0,0 +1,32 @@
+# Example for Controlling Thermal Platform Temperature using a Thermal Controller
+
+## **Purpose**
+In this sequence, we will address how to control a thermal platform's temperature using a thermal controller in an integrated system. A thermal controlled platform is often used in LED/laser systems to control DUT temperature for taking precise junction temperature (Tj) measurements, and stabilizing temperature-controlled environments.
+
+## Overview 
+Operates a thermal controller (Arroyo 5400 Series TECSource) to control a thermal platform (Arroyo TEC 284 Series High Power LaserMount). The controller will have the platform to ramp up to 50°C, stabilize, and run for 10 minutes; then ramp down to 25°C, stabilize, and run for 10 minutes. 
+
+Install the libraries listed in the [Considerations](#considerations) section of this document. More information on TECSources can be found [here](https://www.arroyoinstruments.com/categories/temperature-controllers) and LaserMounts [here](https://www.arroyoinstruments.com/categories/lasermounts).
+
+## Key Settings 
+The following settings are configured by default. At the top of the sequence, there are multiple lines corresponding to individual test parameters. These lines may be modified to match the necessary parameters for your specific LED or Laser.
+
+### Thermal Controller Settings
+- **Set Temperature One:** 50°C
+- **Set Temperature One Stability Time:** 10 minutes
+- **Set Temperature Two:** 25°C
+- **Set Temperature Two Stability Time:** 10 minutes
+
+## Considerations
+- This sequence involves connecting to a serial thermal controller using RS-232 interface and requires the [pyserial](https://pypi.org/project/pyserial/) library. See instructions on installing this library under the "Usage" section in the [SpikeSafePythonSamples markdown file](/README.md#installing-pyserial-package).
+
+## Expected Results
+After initializing the thermal controller, the thermal controller will ramp up to Set Temperature One at 50°C and stabilize for 10 minutes. Afterwards the thermal controller will ramp down to Set Temperature Two at 25°C and stabilize for 10 minutes.
+
+## Useful Products for Controlling Thermal Platform Temperature using a Thermal Controller
+
+Vektrex [Control Panel Software Application](https://www.vektrex.com/software-applications/control-panel/) provides a user interface to easily perform Tj measurements in minutes. Control Panel provides control over SpikeSafe current output, Voltage Digitizer measurements, and graphing tools such as a time square-root graphing and line-of-best-fit y-axis extrapolation in order to programmatically determine Vf(0). See the figure below:
+
+![](control_panel_tj_screenshot.png)
+
+For more information regarding Vektrex Control Panel, contact [email protected].

application_specific_examples/controlling_thermal_platform_temperature/SerialInterface.py

@@ -0,0 +1,71 @@
+import serial
+import serial.tools.list_ports as port_list
+from time import sleep 
+
+class SerialInterfaceDll(object):
+
+    def __init__(self, port=None, baudrate=38400, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS, timeout=0, write_timeout=0, command_delay=0.1):
+        self.port = port
+        self.baudrate = baudrate
+        self.parity = parity
+        self.stopbits = stopbits
+        self.bytesize = bytesize
+        self.timeout = timeout
+        self.write_timeout = write_timeout
+        self.command_delay = command_delay
+
+        if port == None:
+            ports = list(port_list.comports())
+            for p in ports:
+                print (p)
+                # Choosing COM port from list of available connections 
+                if "USB Serial Port" in p[1]:
+                    try:
+                        self.port = p[0]
+                        # Setting up and connecting to device
+                        self.ser = serial.Serial(port =     self.port,
+                                                baudrate = self.baudrate,
+                                                parity =   self.parity,
+                                                stopbits = self.stopbits,
+                                                bytesize = self.bytesize,
+                                                timeout =  self.timeout,
+                                                write_timeout = self.write_timeout)
+                        if self.ser.is_open:
+                            print("\n" + self.port + " has been opened.\n")
+                            self.ser.write(b'*IDN? \r\n')
+                            sleep(0.1)
+                            print(bytes.decode(self.ser.read(256)))
+                        else:
+                            print("\nDid not connect to " + self.port + "\n")
+                        return
+                    except:
+                        print("Failed to connect to " + p[0])
+        else:
+            self.ser = serial.Serial(port =     self.port,
+                                                baudrate = self.baudrate,
+                                                parity =   self.parity,
+                                                stopbits = self.stopbits,
+                                                bytesize = self.bytesize,
+                                                timeout =  self.timeout,
+                                                write_timeout = self.write_timeout)
+    
+
+    def close(self):
+        self.ser.close()
+        sleep(self.command_delay)
+        if not self.ser.is_open:
+            print("\n" + self.port + " has been closed.\n")
+        return
+
+    def write_command(self,command):
+        response = None
+        self.ser.write(str.encode(command) + b'\r\n')
+        sleep(self.command_delay)
+        response = bytes.decode(self.ser.read(256))
+        return(response)
+
+    def isKthBitSet(self, n, k): 
+        if n & (1 << (k - 1)): 
+            return True
+        else: 
+            return False 

application_specific_examples/controlling_thermal_platform_temperature/control_panel_tj_screenshot.png

@@ -0,0 +1,112 @@
+# Goal: 
+# Make 10,000 pulses using software based timing and then shutoff pulsing
+
+import sys
+import time
+import logging
+from spikesafe_python.ReadAllEvents import log_all_events
+from spikesafe_python.ReadAllEvents import read_until_event
+from spikesafe_python.SpikeSafeError import SpikeSafeError
+from spikesafe_python.TcpSocket import TcpSocket
+
+### set these before starting application
+
+# SpikeSafe IP address and port number
+ip_address = '10.0.0.220'
+port_number = 8282 
+
+### setting up sequence log
+log = logging.getLogger(__name__)
+logging.basicConfig(filename='SpikeSafePythonSamples.log',format='%(asctime)s, %(levelname)s, %(message)s',datefmt='%m/%d/%Y %I:%M:%S',level=logging.INFO)
+
+### start of main program
+try:
+    log.info("FixedPulseCountUsingSoftwareTimingExample.py started.")
+        
+    # instantiate new TcpSocket to connect to SpikeSafe
+    tcp_socket = TcpSocket()
+    tcp_socket.open_socket(ip_address, port_number)
+
+    # reset to default state and check for all events,
+    # it is best practice to check for errors after sending each command      
+    tcp_socket.send_scpi_command('*RST')                  
+    log_all_events(tcp_socket)
+
+    # set Channel 1's mode to DC Dynamic and check for all events
+    tcp_socket.send_scpi_command('SOUR1:FUNC:SHAP PULSEDDYNAMIC')
+    log_all_events(tcp_socket)
+
+    # set Channel 1's Trigger Output to Positive and check for all events
+    tcp_socket.send_scpi_command('OUTP1:TRIG:SLOP POS')
+    log_all_events(tcp_socket)
+
+    # set Channel 1's Trigger Output Always and check for all events
+    tcp_socket.send_scpi_command('SOUR0:PULS:TRIG ALWAYS')
+    log_all_events(tcp_socket)
+
+    # set Channel 1's Pulse On Time to 1us and check for all events
+    tcp_socket.send_scpi_command('SOUR1:PULS:TON 0.000001')
+    log_all_events(tcp_socket)
+
+    # set Channel 1's Pulse Off Time 9us and check for all events
+    tcp_socket.send_scpi_command('SOUR1:PULS:TOFF 0.000009')
+    log_all_events(tcp_socket)
+
+    # set Channel 1's Pulse Width adjustment to disabled and check for all events
+    tcp_socket.send_scpi_command('SOUR1:PULS:AADJ 0')
+    log_all_events(tcp_socket)
+
+    # set Channel 1's current to 100mA and check for all events
+    tcp_socket.send_scpi_command('SOUR1:CURR 0.1')
+    log_all_events(tcp_socket)
+
+    # set Channel 1's voltage to 20V and check for all events
+    tcp_socket.send_scpi_command('SOUR1:VOLT 20')
+    log_all_events(tcp_socket)
+
+    # set Channel 1's Auto Range to On and check for all events
+    tcp_socket.send_scpi_command('SOUR1:CURR:RANG:AUTO 1')
+    log_all_events(tcp_socket)
+
+    # set Channel 1's Load Impedance to High and check for all events
+    tcp_socket.send_scpi_command('SOUR1:PULS:CCOM 1')
+    log_all_events(tcp_socket)
+
+    # set Channel 1's Rise Time to Fast and check for all events
+    tcp_socket.send_scpi_command('SOUR1:PULS:RCOM 1')
+    log_all_events(tcp_socket)
+
+    # set Channel 1's Ramp mode to Fast and check for all events
+    tcp_socket.send_scpi_command('OUTP1:RAMP FAST')
+    log_all_events(tcp_socket)
+
+    # Start the channel
+    tcp_socket.send_scpi_command('OUTP1 ON')
+
+    # wait until Channel 1 is ready
+    read_until_event(tcp_socket, 100) # event 100 is "Channel Ready"
+
+    # pulsing starts before before getting Channel Ready message
+    # wait 30ms for getting ~10000 pulses
+    time.sleep(0.030)
+    
+    # disable Channel
+    tcp_socket.send_scpi_command('OUTP1 OFF')
+        
+    # disconnect from SpikeSafe    
+    tcp_socket.close_socket()      
+
+    log.info("FixedPulseCountUsingSoftwareTimingExample.py completed.\n")
+
+except SpikeSafeError as ssErr:
+    # print any SpikeSafe-specific error to both the terminal and the log file, then exit the application
+    error_message = 'SpikeSafe error: {}\n'.format(ssErr)
+    log.error(error_message)
+    print(error_message)
+    sys.exit(1)
+except Exception as err:
+    # print any general exception to both the terminal and the log file, then exit the application
+    error_message = 'Program error: {}\n'.format(err)
+    log.error(error_message)       
+    print(error_message)   
+    sys.exit(1)