Added Controlling Thermal Platform Temperature example

eljayg · eljayg · commit f7a2b6bc6fb5 · 2020-12-09T15:35:59.000-08:00
diff --git a/README.md b/README.md
@@ -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'`.
 
diff --git a/application_specific_examples/README.md b/application_specific_examples/README.md
@@ -3,6 +3,7 @@
 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)
diff --git a/application_specific_examples/controlling_thermal_platform_temperature/ControllingThermalPlatformTemperature.py b/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)
diff --git a/application_specific_examples/controlling_thermal_platform_temperature/README.md b/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 sales@vektrex.com.
diff --git a/application_specific_examples/controlling_thermal_platform_temperature/SerialInterface.py b/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 
diff --git a/application_specific_examples/controlling_thermal_platform_temperature/control_panel_tj_screenshot.png b/application_specific_examples/controlling_thermal_platform_temperature/control_panel_tj_screenshot.png
