Scripts automate source-measure units

Programming an SMU with internal scripts let system controllers focus on higher-level test functions.

Andrew Street, NXP Semiconductors -- Test & Measurement World, 10/28/2011 1:00:00 PM

A version of this article appeared in the Dec. 2011/Jan. 2012 issue of Test & Measurement World. See the PDF. Listing 1 at the end of this article contains script code.

Source-measure units (SMUs), often used in semiconductor device characterization, can supply constant-voltage sources or constant-current to circuits and devices. At NXP's Billerica, MA design center, we use SMUs to characterize ICs in the early stages of development, particularly if the device under test doesn't have an on-chip current source or if the design engineer needs to manipulate the device's operating points. SMUs let us accurately set both the stimulus level and compliance limit. Most SMUs have a high-resolution, high-accuracy DMM (digital multimeter) that can measure the parameter that the SMU is sourcing. We often use SMUs as the power supplies of our automated characterization systems rather than using separate power supplies, DMMs, and switching units to connect the DMM to the power supply.

Characterizing semiconductor devices requires sourcing voltage or current and measuring the device's response to various stimuli. While that may seem simple, each test can involve many steps. While we could run a test using an SMU's front panel, automating the steps saves considerable time. In our lab, we use Keithley 2600 series SMUs that run internal scripts written in a Lua-based language (Ref. 1). This language, in addition to supporting the usual branching and conditional software constructs, supports mathematical operations and string processing. The SMU's host-processor memory can accommodate scripts with at least 50,000 lines of code and it can manage memory buffers that hold from 50,000 to 100,000 data points.

Because the SMU can run scripts, we can download test code from the system controller into the SMU and execute the script within the SMU. Once a test or series of tests have run, the SMU sends the test results to the system controller. Running a script in the SMU results in significant time saving on I/O overhead and test time. Scripts internal to the SMU let us perform DC testing of discrete devices, but we can extend this approach to the development and characterization stages of an IC. We have implemented a variety of tests that involve increasing power-supply outputs to check for ESD protection integrity, run fault diagnostics, and run internal function tests. Further, the test code can run from the instrument front panel, thereby extending its functionality. Two simple examples illustrate how to use test scripts.

Measure current stabilization

During a test, an analog IC such as an RF gain block warms, which can result in measurement instabilities. Because production test times are less than 1 s, we need to understand the device's thermal time constants because they play a role in testing.

Figure 1. An RF block's current consumption drops for the first 200 ms after turn on.

Listing 1 at the end of this article contains script code that sets the SMU's output voltage to Vstart and measures the current consumption Nmeas times at Tsamp intervals between measurements and then sets the output voltage to Vstop. The SMU time stamps each measurement using its high-resolution timer, which lets us plot current consumption versus time. Once the system controller downloads the script code to the SMU, the system controller simply calls the function monI() with the necessary arguments. When a the SMU returns a ‘1' (similar to a *opc in SCPI), the controller reads the data in the SMU's memory buffer.

Figure 1 shows current versus time from an RF gain block. The actual sample period is the sum of Tsamp, the measurement integration time, which is set by the number of power line cycles (nplc) and the internal processing of the unit. With nplc=1 (for good noise rejection) and Tsamp=0, the actual sample period is about 17.6 ms in a 60-Hz system. The measured jitter on the sampling has a standard deviation of about 75 μs.

Now, consider the implementation using a separate power supply and DMM. That method would require the system controller to command a power supply to turn on at the desired voltage and then trigger a DMM to collect a number of readings, assuming the DMM were capable of capturing a number of measurement samples with a single trigger. A hardware trigger would initiate the data capture. Another alternative to an SMU uses an oscilloscope to sample the voltage across a current-monitoring resistor, but that would require access to the necessary test points.

Curve Tracing

Figure 2. A curve trace shows that a diode-based structure's forward current increases rapidly when the forward voltage reaches a threshold of about 1.4 V in this instance.

As part of an IC evaluation, we measure I-V characteristics between certain pins on an IC. That lets us verify the correct operation of circuit elements such as ESD (electrostatic discharge) structures. I-V signatures are often useful during ESD testing because they provide an early indication of a failure. The Keithley SMUs come with a number of factory installed curve-trace scripts. We often modify these scripts to meet our specific needs. Listing 1 also illustrates a simple script that sweeps the voltage and measures the current. The input arguments to the function are the SMU unit, the start and stop voltages, the source-current limit, the measurement dwell time, and the number of sweep points, respectively. In this case, the function checks the current configuration of the SMU and ensures it's configured as a voltage source prior to performing the sweep. Note that the buffer for the results is created using another user-written function genBuffer(smu) that also resides in the SMU memory. The source voltage range is set to accommodate the larger of Vstart and Vstop and illustrates the use of the math library. Once the sweep is complete, the original settings are restored and the function returns a logic 1 to the system. Figure 2 shows the results of the I-V measurement on a diode-based structure.

These examples show how we automate measurements using scripts that run in an SMU. Scripts let the SMU handle its own operational details, which frees the system controller to focus on higher-level functions such as test-system configuration, test management, data analysis, and operator interfaces.

References
1. The Programming Language Lua, www.lua.org.

2. Diode Production Testing with Series 2600 System SourceMeterInstruments, Application Note 2633, Keithley Instruments. www.keithley.com/support/data?asset=50312

For further reading
DC Characterization of Semiconductor Power Devices, Application 4212B-1(Hewlett Packard 4142B Modular DC Source/Monitor), Agilent Technologies, www.home.agilent.com/upload/cmc_upload/All/50912744.pdf.

Creating Scaleable, Multipin, Multi-Function IC Test Systems Using the Model 2602 System SourceMeter Instrument, Keithley Application Note 2614, Keithley Instruments, www.keithley.com/support/data?asset=50278.

Andrew Street is a test and product engineer with NXP Semiconductors, a maker of RF amplifiers, mixers, up/down converters, and other components.

 

 

Listing 1

--------------------------------------------------------------------------------
-- File: UserFuns4TM.tsp
-- Author: AMS
-- Date: 11-10-20
-- Version: 1-00
-- Notes:
-- 1. Illustrative Functions for T&M World Test Ideas
--
-- Function List
-- getRev() Get script revision info
-- CTv() Curve trace Sweep V meas I
-- monI() Monitor current
--
--------------------------------------------------------------------------------

function getRev()
-- Return version info of script
print "1.00.00,11-10-20"
end

function genBuffer(iSmu)
-- General function to set up NV buffer
iSmu.nvbuffer1.clear()
iSmu.nvbuffer1.appendmode = 1
iSmu.nvbuffer1.collecttimestamps = 1
iSmu.nvbuffer1.collectsourcevalues = 1
iSmu.nvbuffer1.timestampresolution=1E-4
end

function CTv(smu,Vstart,Vstop,iLim,Tdwell,Npts)
----------------------------------------------------------------------------
-- Curve trace: Linear Sweep V, Measure I
----------------------------------------------------------------------------

-- Assign default function arguments
if smu==nil then smu=smua end
if Vstart==nil then Vstart=0.0 end
if Vstop==nil then Vstop=0.5 end
if iLim==nil then iLim=0.1 end
if Tdwell==nil then Tdwell=0 end
if Npts==nil then Npts=11 end
----------------------------------------------------------------------------
-- Local variables to restore SMU state
----------------------------------------------------------------------------
local l_func=smu.source.func -- Get source function (0=Isrc)

local l_level -- Local for existing output level
local l_limit -- Local for existing limit
local l_range -- Local for existing range

if l_func==1 then
-- Voltage source
l_level=smu.source.levelv -- Output level
l_limit=smu.source.limiti -- Limit
l_range=smu.source.rangev -- Range
else
-- Current source
l_level=smu.source.leveli -- Output level
l_limit=smu.source.limitv -- Limit
l_range=smu.source.rangei -- Range
end

local l_autozero=smu.measure.autozero -- Autozero state

local l_stepv=(Vstop-Vstart)/(Npts-1) -- Voltage increment
local l_v=Vstart -- Output voltage
local l_p -- Indexer

genBuffer(smu) -- NV buffer for results storage
----------------------------------------------------------------------------
-- Configure SMU
----------------------------------------------------------------------------
if l_func==0 then
smu.source.output=0
smu.source.func=smu.OUTPUT_DCVOLTS
end

smu.source.rangev=math.max(math.abs(Vstart) , math.abs(Vstop))
smu.measure.autozero = smu.AUTOZERO_OFF
smu.source.limiti=iLim
smu.measure.rangei=1.1*iLim
----------------------------------------------------------------------------
-- Measurement Loop
----------------------------------------------------------------------------
for l_p = 1,Npts do
smu.source.levelv = l_v -- Set source to voltage
delay(Tdwell) -- Dwell to allow for DUT settling
smu.measure.i(smu.nvbuffer1) -- Measure I and store
waitcomplete() -- Wait for measurement to complete
l_v = l_v + l_stepv -- Increment voltage
end
----------------------------------------------------------------------------
-- Restore original settings
----------------------------------------------------------------------------
if l_func==0 then
smu.source.output=0
smu.source.func=smu.OUTPUT_DCAMPS
smu.source.leveli=l_level
smu.source.limitv=l_limit
smu.source.rangei=l_range
smu.source.output=1
else
smu.source.levelv=l_level
smu.source.limiti=l_limit
smu.source.rangev=l_range
end

smu.measure.autozero=l_autozero
waitcomplete()
print(1) -- Return OPC
end

function monI(smu,Vstart,Vstop,iLim,Tsamp,Nmeas)
----------------------------------------------------------------------------
-- Monitor current
----------------------------------------------------------------------------

-- Assign default function arguments
if smu==nil then smu=smua end
if Vstart==nil then Vstart=0 end
if Vstop==nil then Vstop=0 end
if iLim==nil then iLim=1 end
if Tsamp==nil then Tsamp=100e-3 end
if Nmeas==nil then Nmeas=10 end

----------------------------------------------------------------------------
-- Local variables to restore SMU state
----------------------------------------------------------------------------
local l_p -- Local var to index
local l_iRange=smu.measure.rangei -- Store existing current range value
local l_iLimit=smu.source.limiti -- Store existing current limit setting
local l_aRangeV=smua.source.autorangev
smu.measure.rangei=1.05*iLim -- Set current range
smu.source.limiti=iLim -- Set current limit

smu.source.autorangev=1
genBuffer(smu) -- NV buffer for results storage
----------------------------------------------------------------------------
-- Measurement loop
----------------------------------------------------------------------------
smu.source.levelv=Vstart -- Set ON voltage

smu.measure.i(smu.nvbuffer1) -- Mesaure current
for l_p = 1,Nmeas-1 do -- Loop for measurements
delay(Tsamp)
smu.measure.i(smu.nvbuffer1)
waitcomplete()
end

smu.source.levelv=Vstop -- Set OFF voltage
smu.measure.rangei=l_iRange -- Restore current measurement range
smu.source.limiti=l_iLimit -- Restore current limit
smu.source.autorangev=l_aRangeV
print(1) -- Write opc bit
end

-- Add front panel access to functions using:
-- display.loadmenu.add()

-- To download from controller use the following syntax
-- loadscript Make
--
--
-- endScript
-- Make()