Agilent B1500 Semiconductor Parameter Analyzer 

General Information 

This instrument driver does not support all configuration options of the B1500 mainframe yet. So far, it is possible to interface multiple SMU modules and source/measure currents and voltages, perform sampling and staircase sweep measurements. The implementation of further measurement functionalities is highly encouraged. Meanwhile the model is managed by Keysight, see the corresponding “Programming Guide” for details on the control methods and their parameters

Command Translation 

Alphabetical list of implemented B1500 commands and their corresponding method/attribute names in this instrument driver.

Command	Property/Method
`AAD`	`SMU.adc_type`
`AB`	`abort()`
`AIT`	`adc_setup()`
`AV`	`adc_averaging()`
`AZ`	`adc_auto_zero`
`BC`	`clear_buffer()`
`CL`	`SMU.disable()`
`CM`	`auto_calibration`
`CMM`	`SMU.meas_op_mode`
`CN`	`SMU.enable()`
`DI`	`SMU.force()` mode: `'CURRENT'`
`DV`	`SMU.force()` mode: `'VOLTAGE'`
`DZ`	`force_gnd()`, `SMU.force_gnd()`
`ERRX?`	`check_errors()`
`FL`	`SMU.filter`
`FMT`	`data_format()`
`*IDN?`	`id`
`*LRN?`	`query_learn()`, multiple methods to read/format settings directly
`MI`	`SMU.sampling_source()` mode: `'CURRENT'`
`ML`	`sampling_mode`
`MM`	`meas_mode()`
`MSC`	`sampling_auto_abort()`
`MT`	`sampling_timing()`
`MV`	`SMU.sampling_source()` mode: `'VOLTAGE'`
`*OPC?`	`check_idle()`
`PA`	`pause()`
`PAD`	`parallel_meas`
`RI`	`meas_range_current`
`RM`	`SMU.meas_range_current_auto()`
`*RST`	`reset()`
`RV`	`meas_range_voltage`
`SSR`	`series_resistor`
`TSC`	`time_stamp`
`TSR`	`clear_timer()`
`UNT?`	`query_modules()`
`WAT`	`wait_time()`
`WI`	`SMU.staircase_sweep_source()` mode: `'CURRENT'`
`WM`	`sweep_auto_abort()`
`WSI`	`SMU.synchronous_sweep_source()` mode: `'CURRENT'`
`WSV`	`SMU.synchronous_sweep_source()` mode: `'VOLTAGE'`
`WT`	`sweep_timing()`
`WV`	`SMU.staircase_sweep_source()` mode: `'VOLTAGE'`
`XE`	`send_trigger()`

Examples 

Initialization of the Instrument 

from pymeasure.instruments.agilent import AgilentB1500

# explicitly define r/w terminations; set sufficiently large timeout in milliseconds or None.
b1500=AgilentB1500("GPIB0::17::INSTR", read_termination='\r\n', write_termination='\r\n', timeout=600000)
# query SMU config from instrument and initialize all SMU instances
b1500.initialize_all_smus()
# set data output format (required!)
b1500.data_format(21, mode=1) #call after SMUs are initialized to get names for the channels

IV measurement with 4 SMUs 

# choose measurement mode
b1500.meas_mode('STAIRCASE_SWEEP', *b1500.smu_references) #order in smu_references determines order of measurement

# settings for individual SMUs
for smu in b1500.smu_references:
    smu.enable() #enable SMU
    smu.adc_type = 'HRADC' #set ADC to high-resoultion ADC
    smu.meas_range_current = '1 nA'
    smu.meas_op_mode = 'COMPLIANCE_SIDE' # other choices: Current, Voltage, FORCE_SIDE, COMPLIANCE_AND_FORCE_SIDE

# General Instrument Settings
# b1500.adc_averaging = 1
# b1500.adc_auto_zero = True
b1500.adc_setup('HRADC','AUTO',6)
#b1500.adc_setup('HRADC','PLC',1)

#Sweep Settings
b1500.sweep_timing(0,5,step_delay=0.1) #hold,delay
b1500.sweep_auto_abort(False,post='STOP') #disable auto abort, set post measurement output condition to stop value of sweep
# Sweep Source
nop = 11
b1500.smu1.staircase_sweep_source('VOLTAGE','LINEAR_DOUBLE','Auto Ranging',0,1,nop,0.001) #type, mode, range, start, stop, steps, compliance
# Synchronous Sweep Source
b1500.smu2.synchronous_sweep_source('VOLTAGE','Auto Ranging',0,1,0.001) #type, range, start, stop, comp
# Constant Output (could also be done using synchronous sweep source with start=stop, but then the output is not ramped up)
b1500.smu3.ramp_source('VOLTAGE','Auto Ranging',-1,stepsize=0.1,pause=20e-3) #output starts immediately! (compared to sweeps)
b1500.smu4.ramp_source('VOLTAGE','Auto Ranging',0,stepsize=0.1,pause=20e-3)

#Start Measurement
b1500.check_errors()
b1500.clear_buffer()
b1500.clear_timer()
b1500.send_trigger()

# read measurement data all at once
b1500.check_idle() #wait until measurement is finished
data = b1500.read_data(2*nop) #Factor 2 because of double sweep

#alternatively: read measurement data live
meas = []
for i in range(nop*2):
    read_data = b1500.read_channels(4+1) # 4 measurement channels, 1 sweep source (returned due to mode=1 of data_format)
    # process live data for plotting etc.
    # data format for every channel (status code, channel name e.g. 'SMU1', data name e.g 'Current Measurement (A)', value)
    meas.append(read_data)

#sweep constant sources back to 0V
b1500.smu3.ramp_source('VOLTAGE','Auto Ranging',0,stepsize=0.1,pause=20e-3)
b1500.smu4.ramp_source('VOLTAGE','Auto Ranging',0,stepsize=0.1,pause=20e-3)

Sampling measurement with 4 SMUs 

# choose measurement mode
b1500.meas_mode('SAMPLING', *b1500.smu_references) #order in smu_references determines order of measurement
number_of_channels = len(b1500.smu_references)

# settings for individual SMUs
for smu in b1500.smu_references:
    smu.enable() #enable SMU
    smu.adc_type = 'HSADC' #set ADC to high-speed ADC
    smu.meas_range_current = '1 nA'
    smu.meas_op_mode = 'COMPLIANCE_SIDE' # other choices: Current, Voltage, FORCE_SIDE, COMPLIANCE_AND_FORCE_SIDE

b1500.sampling_mode = 'LINEAR'
# b1500.adc_averaging = 1
# b1500.adc_auto_zero = True
b1500.adc_setup('HSADC','AUTO',1)
#b1500.adc_setup('HSADC','PLC',1)
nop=11
b1500.sampling_timing(2,0.005,nop) #MT: bias hold time, sampling interval, number of points
b1500.sampling_auto_abort(False,post='BIAS') #MSC: BASE/BIAS
b1500.time_stamp = True

# Sources
b1500.smu1.sampling_source('VOLTAGE','Auto Ranging',0,1,0.001) #MV/MI: type, range, base, bias, compliance
b1500.smu2.sampling_source('VOLTAGE','Auto Ranging',0,1,0.001)
b1500.smu3.ramp_source('VOLTAGE','Auto Ranging',-1,stepsize=0.1,pause=20e-3) #output starts immediately! (compared to sweeps)
b1500.smu4.ramp_source('VOLTAGE','Auto Ranging',-1,stepsize=0.1,pause=20e-3)

#Start Measurement
b1500.check_errors()
b1500.clear_buffer()
b1500.clear_timer()
b1500.send_trigger()

meas=[]
for i in range(nop):
    read_data = b1500.read_channels(1+2*number_of_channels) #Sampling Index + (time stamp + measurement value) * number of channels
    # process live data for plotting etc.
    # data format for every channel (status code, channel name e.g. 'SMU1', data name e.g 'Current Measurement (A)', value)
    meas.append(read_data)

#sweep constant sources back to 0V
b1500.smu3.ramp_source('VOLTAGE','Auto Ranging',0,stepsize=0.1,pause=20e-3)
b1500.smu4.ramp_source('VOLTAGE','Auto Ranging',0,stepsize=0.1,pause=20e-3)

Main Classes 

Classes to communicate with the instrument:

AgilentB1500: Main instrument class
SMU: Instantiated by main instrument class for every SMU
SPGU: Instantiated by main instrument class for every SPGU
SPGUChannel: Instantiated by SPGU for each channel
CMU: Instantiated by main instrument class for CMU

All query commands return a human readable dict of settings. These are intended for debugging/logging/file headers, not for passing to the accompanying setting commands.

class pymeasure.instruments.agilent.agilentB1500.AgilentB1500(adapter, name='Agilent B1500 Semiconductor Parameter Analyzer', **kwargs)

Bases: SCPIMixin, Instrument

Represent the Agilent B1500 Semiconductor Parameter Analyzer and provide a high-level interface for taking different kinds of measurements.

property smu_references: Get all SMU instances as dict_values.

property smu_names: Get all SMU names as dict.

query_learn(query_type)

Query settings from the instrument. (*LRN?)

Parameters:: query_type (int or str) – Query type (number according to manual)
Return type:: dict

query_learn_header(query_type, **kwargs)

Query settings from the instrument. (*LRN?)

Return dict of settings in human-readable format for debugging or file headers. For optional arguments check the underlying definition of QueryLearn.query_learn_header().

Parameters:: query_type (int or str) – Query type (number according to manual)
Return type:: dict

query_modules()

Query module models from the instrument.

Return dictionary of channel and module type.

Returns:: Channel:Module Type
Return type:: dict

initialize_all_smus()

Initialize all SMUs.

Query available modules and create a SMU instance for each. SMUs are accessible via attributes such as .smu1, etc.

initialize_all_spgus()

Initialize all SPGUs.

Query available modules and create a SPGU instance for each. SPGUs are accessible via attributes such as .spgu1, etc.

initialize_cmu()

Initialize CMU.

Query available modules and create a CMU instance for the CMU. CMU is accessible via attribute .cmu.

pause(pause_seconds)

Pause command execution for given time in seconds. (PA)

Parameters:: pause_seconds (int) – Seconds to pause

abort(): Abort the present operation but channels may still output current/voltage. (AB)

force_gnd(): Force 0 V on all channels immediately. Current settings can be restored with restore_settings(). (DZ)

restore_settings(): Restore the settings of all channels to the state before using force_gnd(). (RZ)

property io_control_mode: Any: Control the control mode for the digital I/O ports (ControlMode). (ERMOD)

set_port_connection(port, status)

Set the connection status for a specific port. (ERSSP)

Parameters:

port (PgSelectorPort) – Port number
status (PgSelectorConnectionStatus) – Connection status

check_errors(): Check for errors. (ERRX?)

check_idle()

Check if instrument is idle. (*OPC?)

Alias for complete().

clear_buffer(): Clear output data buffer. (BC)

clear_timer(): Clear timer count. (TSR)

send_trigger(): Send trigger to start measurement (except High Speed Spot). (XE)

property auto_calibration: Control SMU auto-calibration every 30 minutes (bool). (CM)

data_format(output_format, mode=0)

Specify data output format. Check documentation for parameters. (FMT)

Should be called once per session to set the data format for interpreting the measurement values read from the instrument.

Currently implemented are format 1, 11, and 21.

Parameters:

output_format (str) – Output format string, e.g. FMT21
mode (int) – Data output mode, defaults to 0 (only measurement data is returned)

property parallel_meas

Control whether parallel measurements are enabled (bool). (PAD)

Effective for SMUs using HSADC and measurement modes 1, 2, 10, 18.

Type:: bool

query_meas_settings(): Read settings for TM, AV, CM, FMT and MM commands (31) from the instrument.

query_meas_mode(): Read settings for MM command (part of 31) from the instrument.

meas_mode(mode, *args)

Set measurement mode of channels. (MM)

Measurements will be taken in the same order as the SMU or CMU references are passed.

Parameters:

mode (MeasMode) – Measurement mode
args (SMU) – SMU or CMU references

query_adc_setup(): Read ADC settings (55, 56) from the instrument.

adc_setup(adc_type, mode, N='')

Set up operation mode and parameters of ADC for each ADC type. (AIT)

Defaults:

HSADC: Auto N=1, Manual N=1, PLC N=1, Time N=0.000002(s)

HRADC: Auto N=6, Manual N=3, PLC N=1

Parameters:

adc_type (ADCType) – ADC type
mode (ADCMode) – ADC mode
N (str) – additional parameter, check documentation, defaults to ''

adc_averaging(number, mode='Auto')

Set number of averaging samples of the HSADC. (AV)

Defaults: N=1, Auto

Parameters:

number (int) – Number of averages
mode (AutoManual) – Mode ('Auto','Manual'), defaults to ‘Auto’

property adc_auto_zero

Control ADC zero function (bool). (AZ)

Halves the integration time when disabled.

property time_stamp: Control Time Stamp function (bool). (TSC)

query_time_stamp_setting(): Read time stamp settings (60) from the instrument.

wait_time(wait_type, N, offset=0)

Configure wait time. (WAT)

Parameters:

wait_type (WaitTimeType) – Wait time type
N (float) – Coefficient for initial wait time, default: 1
offset (int) – Offset for wait time, defaults to 0

query_staircase_sweep_settings(): Read Staircase Sweep Measurement settings (33) from the instrument.

sweep_timing(hold, delay, step_delay=0, step_trigger_delay=0, measurement_trigger_delay=0)

Set timing parameters for staircase or multi channel sweep. (WT)

Parameters:

hold (float) – Hold time
delay (float) – Delay time
step_delay (float) – Step delay time, defaults to 0
step_trigger_delay (float) – Trigger delay time, defaults to 0
measurement_trigger_delay (float) – Measurement trigger delay time, defaults to 0

sweep_auto_abort(abort, post='START')

Enable/Disable the automatic abort function. (WM)

Also set the post measurement condition.

Parameters:

abort (bool) – Enable/Disable automatic abort
post (StaircaseSweepPostOutput) – Output after measurement, defaults to ‘Start’

query_sampling_settings(): Read sampling measurement settings (47) from the instrument.

property sampling_mode

Control sampling mode, linear or logarithmic. (ML)

Type:: SamplingMode

sampling_timing(hold_bias, interval, number, hold_base=0)

Set timing parameters for the sampling measurement. (MT)

Parameters:

hold_bias (float) – Bias hold time
interval (float) – Sampling interval
number (int) – Number of Samples
hold_base (float) – Base hold time, defaults to 0

sampling_auto_abort(abort, post='Bias')

Enable/Disable the automatic abort function. (MSC)

Also set the post measurement condition.

Parameters:

abort (bool) – Enable/Disable automatic abort
post (SamplingPostOutput) – Output after measurement, defaults to ‘Bias’

read_data(number_of_points)

Read all data from buffer and return Pandas DataFrame.

Specify number of measurement points for correct splitting of the data list.

Parameters:: number_of_points (int) – Number of measurement points
Returns:: Measurement Data
Return type:: pd.DataFrame

read_channels(nchannels)

Read data for 1 measurement point from the buffer for the specified number of channels.

Parameters:: nchannels (int) – Number of channels which return data (includes measurement channels and sweep sources, depending on data output settings)
Returns:: Measurement data
Return type:: tuple

query_series_resistor(): Read series resistor status (53) for all SMUs.

query_meas_range_current_auto(): Read auto ranging mode status (54) for all SMUs.

query_meas_op_mode(): Read SMU measurement operation mode (46) for all SMUs.

query_meas_ranges(): Read measurement ranging status (32) for all SMUs.

class pymeasure.instruments.agilent.agilentB1500.SMU(parent, index, smu_type, name, slot, **kwargs)

Bases: Channel

Provide specific methods for the SMUs of the Agilent B1500 mainframe.

Parameters:

parent (AgilentB1500) – Instance of the B1500 mainframe class
index (int) – Index of the SMU
smu_type (str) – Type of the SMU
name (str) – Name of the SMU
slot (int) – Slot number of the SMU

query_learn(query_type, command): Wrap query_learn() method of B1500.

check_errors(): Wrap check_errors() method of B1500.

property status: Get status of the SMU.

enable(): Enable source/measurement channel. (CN)

disable(): Disable source/measurement channel. (CL)

force_gnd()

Force output to 0 V immediately. (DZ)

Current settings can be restored with restore_settings().

restore_settings(): Restore the settings of the channel to the state before using force_gnd(). (RZ)

property filter: Control SMU filter enable/disable state (bool). (FL)

property series_resistor: Control 1 MOhm series resistor enable/disable state (bool). (SSR)

property meas_op_mode

Control SMU measurement operation mode. (CMM)

Type:: MeasOpMode

property adc_type

Control ADC type of individual measurement channel. (AAD)

Type:: ADCType

force(source_type, source_range, output, comp='', comp_polarity='', comp_range='')

Apply DC current or voltage from SMU immediately. (DI, DV)

Parameters:

source_type (str) – Source type ('Voltage','Current')
source_range (int or str) – Output range index or name
output (float) – Source output value in A or V
comp (float) – Compliance value, defaults to previous setting
comp_polarity (CompliancePolarity) – Compliance polarity, defaults to auto
comp_range (int or str) – Compliance ranging type, defaults to auto

ramp_source(source_type, source_range, target_output, comp='', comp_polarity='', comp_range='', stepsize=0.001, pause=0.02)

Ramp to a target output from the set value with a given step size.

Each step is separated by a pause duration.

Parameters:

source_type (str) – Source type ('Voltage' or 'Current')
source_range (int or str) – Output range index or name
target_output (float) – Target output voltage or current
comp (float) – Compliance, defaults to previous setting
comp_polarity (CompliancePolarity) – Compliance polarity, defaults to auto
comp_range (int or str) – Compliance ranging type, defaults to auto
stepsize (float) – Maximum size of steps
pause (float) – Duration in seconds to wait between steps

property meas_range_current

Control current measurement range index. (RI)

Possible settings depend on SMU type, e.g. 0 for Auto Ranging: SMUCurrentRanging

property meas_range_voltage

Control voltage measurement range index. (RV)

Possible settings depend on SMU type, e.g. 0 for Auto Ranging: SMUVoltageRanging

meas_range_current_auto(mode, rate=50)

Specify the auto range operation. Check Documentation. (RM)

Parameters:

mode (int) – Range changing operation mode
rate (int) – Parameter used to calculate the current value, defaults to 50

staircase_sweep_source(source_type, mode, source_range, start, stop, steps, comp, Pcomp='')

Specify staircase sweep source parameters. (WV or WI)

Parameters:

source_type (str) – Source type ('Voltage', 'Current')
mode (SweepMode) – Sweep mode
source_range (int) – Source range index
start (float) – Sweep start value
stop (float) – Sweep stop value
steps (int) – Number of sweep steps
comp (float) – Compliance value
Pcomp (float) – Power compliance, defaults to not set

synchronous_sweep_source(source_type, source_range, start, stop, comp, Pcomp='')

Specify synchronous staircase sweep source (current or voltage) and its parameters. (WSV or WSI)

Parameters:

source_type (str) – Source type ('Voltage','Current')
source_range (int) – Source range index
start (float) – Sweep start value
stop (float) – Sweep stop value
comp (float) – Compliance value
Pcomp (float) – Power compliance, defaults to not set

sampling_source(source_type, source_range, base, bias, comp)

Set DC source (current or voltage) for sampling measurement. (MV or MI)

force() commands on the same channel overwrite this setting.

Parameters:

source_type (str) – Source type ('Voltage','Current')
source_range (int) – Source range index
base (float) – Base voltage/current
bias (float) – Bias voltage/current
comp (float) – Compliance value

set_cv_parameters(mode, start, stop, steps, comp=None)

Set the mode and sweep parameters for MeasMode.CV_SWEEP measurement. (WDCV)

Parameters:

mode (SweepMode) – Sweep mode
start (float) – Sweep start voltage in V
stop (float) – Sweep stop voltage in V
steps (int) – Number of steps for staircase sweep
comp (float | None) – Compliance current in A. The previous value is used if not set. (default: None)

Return type:

None

class pymeasure.instruments.agilent.agilentB1500.SPGU(parent, channel, **kwargs)

Bases: Channel

Provide specific methods for the SPGU module of the Agilent B1500 mainframe.

Parameters:

parent (AgilentB1500) – Instance of the B1500 mainframe class
channel (int) – Channel number of the SPGU

property output: Any: Set SPGU output state. (SRP, SPP) When enabled, starts SPGU output. When disabled, stops output and channels output base voltage.

property operation_mode: Any: Control mode for the Semiconductor Pulse Generator Unit (SPGU). (SIM) The setting is effective for the all SPGU modules installed in the B1500. This command also triggers 0 V output of the SPGU channels which output switch has been ON.

property period: Any: Control the pulse period for SPGU channels (SPPER) in seconds (float). Applies to all installed SPGU modules.

set_output_mode(mode, condition=None)

Set the operating mode for SPGU channel outputs. (SPRM)

This setting applies to all SPGU modules installed in the B1500.

Parameters:

mode (SPGUOperationMode) – SPGU operation mode
condition (int or float or None) – Number of pulses for SPGUOutputMode.COUNT or output duration for SPGUOutputMode.DURATION. Not used for SPGUOutputMode.FREE_RUN

get_output_mode()

Get the current operating mode and condition for SPGU channel outputs. (SPRM?)

Returns:: Tuple of (mode, condition)
Return type:: tuple

property complete: Any: Get whether the SPGU output has finished. (SPST?)

class pymeasure.instruments.agilent.agilentB1500.SPGUChannel(parent, id, **kwargs)

Bases: Channel

SPGU Channel of the Agilent B1500 mainframe.

property enabled: Any: Control SPGU channel enable/disable state. (CN, CL)

property load_impedance: Any: Control the load impedance (SER) in Ohm (float).

set_output_voltage(source=1, base_voltage=0, peak_voltage=0)

Set the output voltage of the SPGU channel. (SPV)

Parameters:

source (SPGUSignalSource or int) – Signal source for the output voltage, defaults to SPGUSignalSource.PULSE_SIGNAL_1
base_voltage (float) – Pulse base voltage or DC output voltage in V, defaults to 0
peak_voltage (float) – Pulse peak voltage in V, defaults to 0

get_output_voltage(source=1)

Get the output voltage of the specified signal source. (SPV?)

Parameters:: source (SPGUSignalSource or int) – Signal source
Returns:: Tuple of (base_voltage, peak_voltage)
Return type:: tuple

property output_mode: Any: Control the output mode of the SPGU channel. (SPM) The SPGU operating mode must be set to PG with the SIM 0 command before setting the output mode.

set_pulse_timings(source=1, delay=0, width=1e-07, rise_time=2e-08, fall_time=None)

Set the timing parameters for the SPGU channel. (SPT)

The SPGU operating mode must be set to PG with the SIM 0 command before setting the pulse timings.

Parameters:

source (SPGUSignalSource or int) – Signal source for the pulse timings, defaults to SPGUSignalSource.PULSE_SIGNAL_1
delay (float) – Pulse delay in seconds, defaults to 0
width (float) – Pulse width in seconds, defaults to 1e-7
rise_time (float) – Pulse rise time in seconds, defaults to 2e-8
fall_time (float) – Pulse fall time in seconds, defaults to rise_time if None

get_pulse_timings(source=1)

Get the timing parameters for the SPGU channel. (SPT?)

The SPGU operating mode must be set to PG with the SIM 0 command before getting the pulse timings.

Parameters:: source (SPGUSignalSource or int) – Signal source for the pulse timings, defaults to SPGUSignalSource.PULSE_SIGNAL_1
Returns:: Tuple of (delay, width, rise_time, fall_time)
Return type:: tuple

apply_setup()

Apply the current setup to the SPGU channel. (SPUPD)

Depends on the SPGU.operation_mode (SIM):

PG mode: output base voltage set by SPV command
ALWG mode: output initial value of waveform

class pymeasure.instruments.agilent.agilentB1500.CMU(parent, slot, **kwargs)

Bases: Channel

Provide specific methods for the CMU of the Agilent B1500 mainframe.

Parameters:

parent (AgilentB1500) – Instance of the B1500 mainframe class
slot (int) – Slot number of the CMU

property enabled: Any: Control CMU enable/disable state. (CN, CL)

property voltage_ac: Any: Set AC voltage amplitude in V. (ACV)

property frequency_ac: Any: Set AC voltage frequency in Hz. (FC)

set_measurement_mode(measurement_mode)

Set the impedance measurement mode for the MFCMU. (IMP)

The MFCMU measures two parameters per mode. Defaults to MFCMUMeasurementMode.CP_G.

Note

This command is not effective for binary data output formats (FMT3, FMT4, FMT13, FMT14).

Parameters:: measurement_mode (MFCMUMeasurementMode) – Measurement mode.
Return type:: None

set_cv_timings(hold_time, delay_time, step_delay_time=0.0, step_source_trigger_delay_time=0.0)

Set the timing parameters for MeasMode.CV_SWEEP measurement. (WTDCV)

Parameters:

hold_time (float) – Wait time (in seconds) after starting measurement and before starting delay time for the first step.
delay_time (float) – Wait time (in seconds) after starting to force a step output and before starting a step measurement.
step_delay_time (float) –
Wait time (in seconds) after starting a step measurement and before starting to force the next step output.

If step_delay_time is shorter than the measurement time, the B1500 waits until the measurement completes, then forces the next step output. (default: 0.0)
step_source_trigger_delay_time (float) – Wait time (in seconds) after completing a step output setup and before sending a step output setup completion trigger. (default: 0.0)

Return type:

None

set_cv_parameters(mode, start, stop, steps)

Set the mode and sweep parameters for MeasMode.CV_SWEEP measurement. (WDCV)

Parameters:

mode (SweepMode) – Sweep mode
start (float) – Sweep start voltage in V
stop (float) – Sweep stop voltage in V
steps (int) – Number of steps for staircase sweep

Return type:

None

force_dc_bias(voltage)

Apply DC voltage from CMU immediately. (DCV)

Parameters:: voltage (float) – DC bias voltage in V
Return type:: None

set_scuu_path(path)

Set the connection path of the SMU CMU unify unit (SCUU). (SSP)

This function is available when CMU and SMU CMU unify unit (SCUU) are installed.

Parameters:: path (SCUUPath) – Path for the SCUU measurement
Return type:: None

Supporting Classes 

Classes that provide additional functionalities:

QueryLearn: Process read out of instrument settings
SMUCurrentRanging, SMUVoltageRanging: Allowed ranges for different SMU types and transformation of range names to indices (base: Ranging)

class pymeasure.instruments.agilent.agilentB1500.QueryLearn

Bases: object

Methods to issue and process *LRN? (learn) command and response.

static query_learn(ask, query_type)

Issue *LRN? (learn) command to the instrument to read configuration. Return dictionary of commands and set values.

Parameters:: query_type (int) – Query type according to the programming guide
Returns:: Dictionary of command and set values
Return type:: dict

classmethod query_learn_header(ask, query_type, smu_references, single_command=False)

Issue *LRN? (learn) command to the instrument to read configuration. Processes information to human readable values for debugging purposes or file headers.

Parameters:

ask (Instrument.ask) – ask method of the instrument
query_type (int or str) – Number according to Programming Guide
smu_references (dict) – SMU references by channel
single_command (str) – if only a single command should be returned, defaults to False

Returns:

Read configuration

Return type:

dict

static to_dict(parameters, names, *args)

Take parameters returned by query_learn() and ordered list of corresponding parameter names (optional function) and return dict of parameters including names.

Parameters:

parameters (dict) – Parameters for one command returned by query_learn()
names (list) – list of names or (name, function) tuples, ordered

Returns:

Parameter name and (processed) parameter

Return type:

dict

class pymeasure.instruments.agilent.agilentB1500.Ranging(supported_ranges, ranges, fixed_ranges=False)

Bases: object

Possible Settings for SMU current/voltage output/measurement ranges.

Transformation of available voltage/current range names to index and back.

Parameters:

supported_ranges (list) – Ranges which are supported (list of range indices)
ranges (dict) – All range names {Name: Indices}
fixed_ranges (bool) – Add fixed ranges (negative indices), defaults to False

__call__(input_value)

Give named tuple (name/index) of given Range.

Throws error if range is not supported by this SMU.

Parameters:: input_value (str or int) – Range name or index
Returns:: Named tuple (name/index) of range
Return type:: namedtuple

class pymeasure.instruments.agilent.agilentB1500.SMUCurrentRanging(smu_type)

Bases: object

Provide Range Name/Index transformation for current measurement/sourcing.

Validity of ranges is checked against the type of the SMU.

Omitting the ‘limited auto ranging’/’range fixed’ specification in the range string for current measurement defaults to ‘limited auto ranging’.

Full specification: '1 nA range fixed' or '1 nA limited auto ranging'

'1 nA' defaults to '1 nA limited auto ranging'

class pymeasure.instruments.agilent.agilentB1500.SMUVoltageRanging(smu_type)

Bases: object

Provide Range Name/Index transformation for voltage measurement/sourcing.

Validity of ranges is checked against the type of the SMU.

Omitting the ‘limited auto ranging’/’range fixed’ specification in the range string for voltage measurement defaults to ‘limited auto ranging’.

Full specification: '2 V range fixed' or '2 V limited auto ranging'

'2 V' defaults to '2 V limited auto ranging'

Enumerations 

Enumerations are used for easy selection of the available parameters (where it is applicable). Methods accept member name or number as input, but name is recommended for readability reasons. The member number is passed to the instrument. Converting an enumeration member into a string gives a title case, whitespace separated string (__str__()) which cannot be used to select an enumeration member again. It’s purpose is only logging or documentation.

class pymeasure.instruments.agilent.agilentB1500.CustomIntEnum(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: IntEnum

Provide additional methods to IntEnum:

Conversion to string automatically replaces ‘_’ with ‘ ‘ in names and converts to title case
get classmethod to get enum reference with name or integer

__str__(): Give title case string of enum value.

classmethod get(input_value)

Give Enum member by specifying name or value.

Parameters:: input_value (str or int) – Enum name or value
Returns:: Enum member

class pymeasure.instruments.agilent.agilentB1500.ADCType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

ADC Type.

HSADC = 0: High-speed ADC

HRADC = 1: High-resolution ADC

HSADC_PULSED = 2: High-speed ADC for pulsed measurements

class pymeasure.instruments.agilent.agilentB1500.ADCMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

ADC Mode.

AUTO = 0

MANUAL = 1

PLC = 2: Power line cycle mode

TIME = 3: Measurement time mode

class pymeasure.instruments.agilent.agilentB1500.AutoManual(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Auto/Manual selection.

AUTO = 0

MANUAL = 1

class pymeasure.instruments.agilent.agilentB1500.ControlMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Control mode for the digital I/O ports.

GENERAL = 0: General purpose control mode (default)

SMU_PGU_SELECTOR = 1: 16440A SMU/PGU selector (B1500A-A04) control mode

N1258A_N1259A = 2: N1258A/N1259A module selector control mode

N1265A = 4: N1265A Ultra High Current Expander/Fixture control mode

N1266A = 8: N1266A High Voltage Source Monitor Unit Current Expander control mode

N1268A = 16: N1268A Ultra High Voltage Expander control mode

N1272A = 32: N1272A Device Capacitance Selector control mode

class pymeasure.instruments.agilent.agilentB1500.MeasMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Measurement Mode.

SPOT = 1

STAIRCASE_SWEEP = 2

SAMPLING = 10

SPOT_C = 17: Spot capacitance measurement (MFCMU)

CV_SWEEP = 18: CV (DC bias) sweep measurement (SMU/MFCMU)

PULSED_SPOT_C = 19: Pulsed spot capacitance measurement (MFCMU)

PULSED_CV_SWEEP = 20: Pulsed CV sweep measurement (MFCMU)

C_F_SWEEP = 22: Capacitance frequency sweep (MFCMU)

CV_AC_SWEEP = 23: CV (AC bias) sweep measurement (MFCMU)

C_T_SAMPLING = 26: Capacitance sampling measurement (MFCMU)

class pymeasure.instruments.agilent.agilentB1500.MeasOpMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Measurement Operation Mode.

COMPLIANCE_SIDE = 0: Measure current in the voltage source operation or voltage in the current source operation.

CURRENT = 1

VOLTAGE = 2

FORCE_SIDE = 3: Measure current in the current source operation or voltage in the voltage source operation.

COMPLIANCE_AND_FORCE_SIDE = 4: Current and voltage synchronous measurement. Measurement result contains the compliance side data and the force side data in this order.

class pymeasure.instruments.agilent.agilentB1500.PgSelectorPort(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Output port of SMU/PG selector.

OUTPUT_1_FIRST = 0: Output 1 on the first selector

OUTPUT_2_FIRST = 1: Output 2 on the first selector

OUTPUT_1_SECOND = 2: Output 1 on the second selector

OUTPUT_2_SECOND = 3: Output 2 on the second selector

class pymeasure.instruments.agilent.agilentB1500.PgSelectorConnectionStatus(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Connection status of I/O port.

NO_CONNECTION = 0: All open. Breaks connection. Initial setting

SMU_ON = 1: SMU on. Makes connection to the SMU input.

PGU_ON = 2: PGU on. Makes connection to the PGU input.

PGU_OPEN = 3: PGU open. Made by opening the semiconductor relay installed on the PGU on port.

class pymeasure.instruments.agilent.agilentB1500.SCUUPath(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Connection path of the SMU CMU unify unit (SCUU)

SMU1 = 1: Output SMU in slot cmu.id - 1

SMU2 = 2: Output SMU in slot cmu.id - 2

SMU_BOTH = 3: Output SMU in slot cmu.id - 1 and cmu.id - 2

class pymeasure.instruments.agilent.agilentB1500.SweepMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Sweep Mode.

LINEAR_SINGLE = 1: Linear sweep (single stair, start to stop.)

LOG_SINGLE = 2: Log sweep (single stair, start to stop.)

LINEAR_DOUBLE = 3: Linear sweep (double stair, start to stop to start.)

LOG_DOUBLE = 4: Log sweep (double stair, start to stop to start.)

class pymeasure.instruments.agilent.agilentB1500.SamplingMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Sampling Mode.

LINEAR = 1

LOG_10 = 2: Logarithmic 10 data points/decade

LOG_25 = 3: Logarithmic 25 data points/decade

LOG_50 = 4: Logarithmic 50 data points/decade

LOG_100 = 5: Logarithmic 100 data points/decade

LOG_250 = 6: Logarithmic 250 data points/decade

LOG_5000 = 7: Logarithmic 5000 data points/decade

class pymeasure.instruments.agilent.agilentB1500.SamplingPostOutput(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Output after sampling.

BASE = 1

BIAS = 2

class pymeasure.instruments.agilent.agilentB1500.SPGUChannelOutputMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Output mode of SPGU channel.

DC = 0: DC output mode

SIGNAL_SOURCE_1 = 1: 2-level pulse output mode using pulse signal source 1

SIGNAL_SOURCE_2 = 2: 2-level pulse output mode using pulse signal source 2

SIGNAL_SOURCE_1_2 = 3: 3-level pulse output mode using pulse signal source 1 and 2

class pymeasure.instruments.agilent.agilentB1500.SPGUSignalSource(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Signal source for SPGU.

DC = 0

PULSE_SIGNAL_1 = 1

PULSE_SIGNAL_2 = 2

class pymeasure.instruments.agilent.agilentB1500.SPGUOperationMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Operation mode of Semiconductor Pulse Generator Unit (SPGU)

PG = 0: PG (pulse output) mode

ALWG = 1: ALWG (arbitrary linear wave output) mode

class pymeasure.instruments.agilent.agilentB1500.SPGUOutputMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Operating mode for SPGU channel outputs

FREE_RUN = 0: Free Run mode. Continues outputting until the SPP command is executed. The condition parameter is not required.

COUNT = 1: Count mode. Outputs the number of pulses (when set to PG mode with the SIM 0 command), or the number of sequences (when set to ALWG mode with the SIM 1 command) specified by the condition parameter.

DURATION = 2: Duration mode. Outputs for a duration specified by the condition parameter.

class pymeasure.instruments.agilent.agilentB1500.MFCMUMeasurementMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Measurement mode for the Multi Frequency Capacitance Measurement Unit (MFCMU).

R_X = 1: R (resistance, Ohm) and X (reactance, Ohm)

G_B = 2: G (conductance, S) and B (susceptance, S)

Z_PHASE_RAD = 10: Z (impedance, Ohm) and phase (radian)

Z_PHASE_DEG = 11: Z (impedance, Ohm) and phase (degree)

Y_PHASE_RAD = 20: Y (admittance, S) and phase (radian)

Y_PHASE_DEG = 21: Y (admittance, S) and phase (degree)

CP_G = 100: Cp (parallel capacitance, F) and G (conductance, S)

CP_D = 101: Cp (parallel capacitance, F) and D (dissipation factor)

CP_Q = 102: Cp (parallel capacitance, F) and Q (quality factor)

CP_RP = 103: Cp (parallel capacitance, F) and Rp (parallel resistance, Ohm)

CS_RS = 200: Cs (series capacitance, F) and Rs (series resistance, Ohm)

CS_D = 201: Cs (series capacitance, F) and D (dissipation factor)

CS_Q = 202: Cs (series capacitance, F) and Q (quality factor)

LP_G = 300: Lp (parallel inductance, H) and G (conductance, S)

LP_D = 301: Lp (parallel inductance, H) and D (dissipation factor)

LP_Q = 302: Lp (parallel inductance, H) and Q (quality factor)

LP_RP = 303: Lp (parallel inductance, H) and Rp (parallel resistance, Ohm)

LS_RS = 400: Ls (series inductance, H) and Rs (series resistance, Ohm)

LS_D = 401: Ls (series inductance, H) and D (dissipation factor)

LS_Q = 402: Ls (series inductance, H) and Q (quality factor)

class pymeasure.instruments.agilent.agilentB1500.StaircaseSweepPostOutput(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Output after staircase sweep.

START = 1

STOP = 2

class pymeasure.instruments.agilent.agilentB1500.CompliancePolarity(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Compliance polarity.

AUTO = 0

MANUAL = 1

class pymeasure.instruments.agilent.agilentB1500.WaitTimeType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: CustomIntEnum

Wait time type.

SMU_SOURCE = 1: wait before changing the output value

SMU_MEASUREMENT = 2: wait before starting the measurement

CMU_MEASUREMENT = 3: wait before starting the measurement