Harness the Power of TSP™ Toolkit Software

Introduction

In an industry where rapid test development is crucial, the need for effective automation and easy code development has never been more pronounced. As businesses strive to enhance their quality while reducing time to market, the right tools can make all the difference. Enter Keithley TSP Toolkit, a new scripting environment that makes adopting Keithley’s Test Script Processor (TSP) language and leveraging the benefits of on-instrument scripting more straightforward than ever.

In this application note, we’ll define TSP and TSP Toolkit and share some tips and tricks to help you leverage these tools to increase your test throughput.

What is TSP?

TSP is a unique instrument automation command set and programming language. TSP-enabled instruments contain an embedded scripting engine that’s capable of executing both instrument control commands and basic programming functionality.

Each TSP-enabled instrument has a set of commands that covers the entire range of functionality for that instrument. In addition to operating like a traditional command set, TSP is also a programming language. This offers two important benefits for instrument control:

• The commands themselves mimic high-level languages like C# or Python.
• The instruments can execute simple programming structures such as for loops and while loops outside of the instrument specific command set.

With TSP for test automation, we can create a file called a TSP script that contains all or part of the test routine. The TSP script can execute sweeps and collect data without receiving commands remotely or requiring front panel configuration, because it can be run directly on the instrument. Unlike instruments that are only compatible

with SCPI, TSP-enabled instruments can store full scripts, functions or variables in their memory, allowing it to function autonomously once loaded with a script. For writing these scripts, TSP Toolkit is the obvious choice.

TSP Toolkit

TSP Toolkit is an updated script development environment taking the form of a Microsoft Visual Studio Code extension that includes instrument support for Keithley TSP-enabled instrumentation such as source measure units (SMUs), digital multimeters (DMMs) and data acquisition systems (DAQs), plus many quality-of-life features that improve the script development experience. TSP Toolkit is replacing Keithley Test Script Builder (TSB) and features all the same functionality plus more.

TSP Toolkit features the modern user interface (UI) of the Microsoft Visual Studio Code editor (VS Code), complete with syntax-highlighting for TSP to increase readability. VS Code also offers hundreds of additional extensions, so users developing with multiple programming languages can seamlessly integrate TSP script development into their workflows.

The TSP Toolkit extension also features TSP command autocompletion alongside in-line and hover help, eliminating the need to manually parse through dense reference manuals to confirm proper command usage and syntax.

Figure 1: TSP Toolkit command hover help feature in use.

Figure 3: TSP Toolkit instrument terminal in use.

The terminal can be used to send individual TSP commands to the instrument or even execute function calls from pre-loaded scripts. The terminal is also where any errors or queries are returned.

Figure 4: TSP Toolkit script editor window context menu options.

To run your script, right click anywhere within the script editor window and select “Send Script to Terminal”, or, if you have multiple connections and want the script to run on all connected instruments, select “Send Script to All Terminals.”

The script will be sent to the instrument and run directly on the box, which improves throughput by reducing the number of interactions across the bus and takes the processing burden away from the PC.

Saving Example Scripts from Test Script Builder

If you are a user of the original Keithley Test Script Builder, you know that it includes a library of example TSP scripts. TSP Toolkit enables easy migration of these scripts and those developed with TSB.

To use TSB examples in TSP Toolkit, find the TSB Workspace file on your PC and copy it to a local directory on your PC. You can find where the TSB Workspace file is stored on your computer by right clicking on any of the examples in the Navigator tab and selecting properties.

Figure 5: Keithley Test Script Builder example workspace file location.

Aliasing

If you do not like the naming conventions of traditional TSP commands or wish to abbreviate them, you can rename the commands via aliasing. TSP commands are structured in levels, separated by periods. A portion of these levels or the entire command can be stored to a variable and then the variable is used to call the command. With every level aliased, the script performance will be better, and the commands are processed faster.

TSP Toolkit Example 1: Aliasing

          
local dm = dmm.measure
local current = dmm.FUNC_DC_CURRENT
dm.func = current -- Alias for dmm.measure.func = dmm.FUNC_DC_CURRENT

local stop = trigger.model.abort
stop() -- Alias for trigger.model.abort()

local clear = eventlog.clear
clear() -- Alias for eventlog.clear()

This example demonstrates how to create aliases for TSP commands:

Note in the above example, that the first line is aliasing 2 levels of a command, the second line is aliasing an enum and the third line is using the aliases together to set the measure function to current.

When aliasing a function command like trigger.model.abort(), the parenthesis normally accompanied with the function is not used. However, when calling the aliased function, stop(), the parenthesis is used normally. This behavior is the same for any command that is a function.

Store & Run Scripts Locally

TSP scripts can also be saved to the instrument’s internal memory. This allows them to be accessed by any remote control scheme or even be run without a controlling PC from the instrument’s front panel.

Scripts may be sent and saved to an instrument by using the loadscript and endscript keywords. This is especially helpful when you need to automate the delivery of scripts, or when it is more practical to send scripts over an existing remote connection. Note that the use of these keywords is not required for running the script in TSP Toolkit. They are used only if you want to send the script to the instrument’s memory without executing it so that it can be saved on the instrument itself.

TSP Toolkit Example 2: Using the Loadscript and Endscript Keywords

  
loadscript testinfo --Send the loadscript command with a script name. This tells the instrument to start collecting messages for a script named testInfo

display.settext(display.TEXT1, "Batch 233") 
display.settext(display.TEXT2, "Test Information") 
display.changescreen(display.SCREEN_USER_SWIPE)

endscript --Send the command that tells the instrument that the script is complete 
testInfo() --Run the script by sending the script name followed by ()
testInfo.save() --To save the script to nonvolatile memory, send the command scriptname.save()

If using TSP Toolkit, a script can be saved to the instrument without the use of the loadscript and endscript keywords. Simply open a connection to the target instrument and enter:

.script " path="" to="" scriptname.tsp"="" –save<="" strong="">

  
reset() --Reset the instrument to a known state
defbuffer1.capacity = 1000 -- Change the size of the default buffer 
dmm.measure.func = dmm.FUNC_DC_CURRENT -- Set the measurement function to current 
dmm.measure.read() -- Take a reading

Figure 7: 2450_SweepI_MeasV.tsp example script running in TSP Toolkit.

import pyvisa as visa
rm = visa.ResourceManager()
smu_address = "TCPIP0::134.63.75.238::inst0::INSTR" smu = rm.open_resource(smu_address)
smu.timeout = 20000

file_path = "C:\\Users\\stenagli\\OneDrive - Fortive\\Documents\\Scripts\\TSP\\User Manual Test\\KE2450_SweepI_MeasV\\"
file_name = "2450_SweepI_MeasV.tsp" file_path_and_name = file_path + file_name print(file_path_and_name)

smu.write("loadscript SweepI_MeasV") with open(file_path_and_name) as fp:
for line in fp: smu.write(line)

smu.write("endscript") smu.write("SweepI_MeasV.run()") smu.close()