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: ValuesView[SMU]: Get all SMU instances as dict_values.

property smu_names: dict[int, str]: Get all SMU names as dict.

query_learn(query_type)

Query settings from the instrument. (*LRN?)

Parameters:: query_type (Union[int, str]) – Query type (number according to manual)
Return type:: dict[str, Union[str, list[str]]]

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 (Union[int, str]) – Query type (number according to manual)
Return type:: Union[dict[str, str], dict[str, Union[str, bool]], dict[str, OrderedDict[str, Union[str, bool]]]]

query_modules()

Query module models from the instrument.

Return dictionary of channel and module type.

Returns:: dict[int, str] – Channel:Module Type

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.

Return type:: None

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.

Return type:: None

initialize_cmu()

Initialize CMU.

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

Return type:: None

pause(pause_seconds)

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

Parameters:: pause_seconds (int) – Seconds to pause
Return type:: None

abort()

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

Return type:: None

force_gnd()

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

Return type:: None

restore_settings()

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

Return type:: None

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

Return type:

None

check_errors()

Check for errors. (ERRX?)

Return type:: list

check_idle()

Check if instrument is idle. (*OPC?)

Alias for complete().

Return type:: str

clear_buffer()

Clear output data buffer. (BC)

Return type:: None

clear_timer()

Clear timer count. (TSR)

Return type:: None

send_trigger()

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

Return type:: None

property auto_calibration: bool: 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 (int) – Output format string, e.g. 11
mode (int) – Data output mode, defaults to 0 (only measurement data is returned) (default: 0)

Return type:

None

property parallel_meas: bool

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.

Return type:: dict[str, Union[str, bool]]

query_meas_mode()

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

Return type:: dict

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 (Union[SMU, CMU]) – SMU or CMU references

Return type:

None

query_adc_setup()

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

Return type:: dict[str, str]

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 (Union[ADCType, int, str]) – ADC type
mode (Union[ADCMode, int]) – ADC mode
N (str) – additional parameter, check documentation, defaults to '' (default: '')

Return type:

None

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 (Union[AutoManual, str]) – Mode ('Auto','Manual'), defaults to ‘Auto’ (default: 'Auto')

Return type:

None

property adc_auto_zero: bool

Control ADC zero function (bool). (AZ)

Halves the integration time when disabled.

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

query_time_stamp_setting()

Read time stamp settings (60) from the instrument.

Return type:: dict[str, str]

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 (default: 0)

Return type:

None

query_staircase_sweep_settings()

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

Return type:: dict[str, Union[str, bool]]

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 (default: 0)
step_trigger_delay (float) – Trigger delay time, defaults to 0 (default: 0)
measurement_trigger_delay (float) – Measurement trigger delay time, defaults to 0 (default: 0)

Return type:

None

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 (Union[StaircaseSweepPostOutput, str]) – Output after measurement, defaults to ‘Start’ (default: 'START')

Return type:

None

query_sampling_settings()

Read sampling measurement settings (47) from the instrument.

Return type:: dict[str, Union[str, bool]]

property sampling_mode: SamplingMode

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 (default: 0)

Return type:

None

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 (Union[SamplingPostOutput, str]) – Output after measurement, defaults to ‘Bias’ (default: 'Bias')

Return type:

None

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:: DataFrame – Measurement Data

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:: tuple[tuple[str, Union[str, int], str, float], ...] – Measurement data

query_series_resistor()

Read series resistor status (53) for all SMUs.

Return type:: dict[str, bool]

query_meas_range_current_auto()

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

Return type:: dict[str, str]

query_meas_op_mode()

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

Return type:: dict[str, str]

query_meas_ranges()

Read measurement ranging status (32) for all SMUs.

Return type:: dict[str, str]

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.

Return type:: str

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

property status: dict[str, OrderedDict[str, str]]: Get status of the SMU.

enable()

Enable source/measurement channel. (CN)

Return type:: None

disable()

Disable source/measurement channel. (CL)

Return type:: None

force_gnd()

Force output to 0 V immediately. (DZ)

Current settings can be restored with restore_settings().

Return type:: None

restore_settings()

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

Return type:: None

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

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

property meas_op_mode: MeasOpMode

Control SMU measurement operation mode. (CMM)

Type:: MeasOpMode

property adc_type: ADCType

Control ADC type of individual measurement channel. (AAD)

Type:: ADCType

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

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

Parameters:

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

Return type:

None

Deprecated since version 0.17.0: Passing "" to comp is deprecated; pass None (the default) instead.

ramp_source(source_type, source_range, target_output, comp=None, 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 (Union[int, str]) – Output range index or name
target_output (float) – Target output voltage or current
comp (Optional[float]) – Compliance, defaults to previous setting (default: None)
comp_polarity (Union[CompliancePolarity, str]) – Compliance polarity, defaults to auto (default: '')
comp_range (Union[int, str]) – Compliance ranging type, defaults to auto (default: '')
stepsize (float) – Maximum size of steps (default: 0.001)
pause (float) – Duration in seconds to wait between steps (default: 0.02)

Return type:

None

Deprecated since version 0.17.0: Passing "" to comp is deprecated; pass None (the default) instead.

property meas_range_current: Range

Control current measurement range index. (RI)

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

property meas_range_voltage: Range

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 (default: 50)

Return type:

None

measure_current(meas_range=None, timestamp=False)

Perform a high speed spot measurement of current. (TI or TTI)

The measurement starts immediately, regardless of the SMU operation mode, trigger mode, and measurement mode. The channel must be enabled (enable()).

Parameters:

meas_range (Union[int, str, None]) – Current measurement range index or name (0 for auto ranging), defaults to the minimum range covering the compliance value (default: None)
timestamp (bool) – Whether to also return the time from timer reset (AgilentB1500.clear_timer()) to the start of the measurement (default: False)

Returns:

Union[float, TimedSpotCurrent] – Current in A, or TimedSpotCurrent of time in s and current in A if timestamp is enabled

measure_voltage(meas_range=None, timestamp=False)

Perform a high speed spot measurement of voltage. (TV or TTV)

The measurement starts immediately, regardless of the SMU operation mode, trigger mode, and measurement mode. The channel must be enabled (enable()).

Parameters:

meas_range (Union[int, str, None]) – Voltage measurement range index or name (0 for auto ranging), defaults to the minimum range covering the compliance value (default: None)
timestamp (bool) – Whether to also return the time from timer reset (AgilentB1500.clear_timer()) to the start of the measurement (default: False)

Returns:

Union[float, TimedSpotVoltage] – Voltage in V, or TimedSpotVoltage of time in s and voltage in V if timestamp is enabled

measure_iv(current_range=None, voltage_range=None, timestamp=False)

Perform a high speed spot measurement of current and voltage. (TIV or TTIV)

The measurement starts immediately, regardless of the SMU operation mode, trigger mode, and measurement mode. The channel must be enabled (enable()).

HCSMU, HVSMU, and MCSMU measure current and voltage simultaneously. HRSMU, MPSMU, and HPSMU measure the compliance side and the force side in this order.

Parameters:

current_range (Union[int, str, None]) – Current measurement range index or name (0 for auto ranging), defaults to the minimum range covering the compliance value. Must be specified together with voltage_range. (default: None)
voltage_range (Union[int, str, None]) – Voltage measurement range index or name (0 for auto ranging), defaults to the minimum range covering the output value. Must be specified together with current_range. (default: None)
timestamp (bool) – Whether to also return the time from timer reset (AgilentB1500.clear_timer()) to the start of the measurement (default: False)

Returns:

Union[SpotIV, TimedSpotIV] – SpotIV of current in A and voltage in V, or TimedSpotIV additionally containing the time in s if timestamp is enabled

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

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 (Optional[float]) – Power compliance, defaults to not set (default: None)

Return type:

None

Deprecated since version 0.17.0: Passing "" to Pcomp is deprecated; pass None (the default) instead.

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

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 (Optional[float]) – Power compliance, defaults to not set (default: None)

Return type:

None

Deprecated since version 0.17.0: Passing "" to Pcomp is deprecated; pass None (the default) instead.

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

Return type:

None

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 (Optional[float]) – 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 (SPGUOutputMode) – SPGU operation mode
condition (Union[int, float, None]) – Number of pulses for SPGUOutputMode.COUNT or output duration for SPGUOutputMode.DURATION. Not used for SPGUOutputMode.FREE_RUN (default: None)

Return type:

None

get_output_mode()

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

Returns:: tuple[SPGUOutputMode, Optional[float]] – Tuple of (mode, condition)

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 (Union[SPGUSignalSource, int]) – Signal source for the output voltage, defaults to SPGUSignalSource.PULSE_SIGNAL_1 (default: 1)
base_voltage (float) – Pulse base voltage or DC output voltage in V, defaults to 0 (default: 0)
peak_voltage (float) – Pulse peak voltage in V, defaults to 0 (default: 0)

Return type:

None

get_output_voltage(source=1)

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

Parameters:: source (Union[SPGUSignalSource, int]) – Signal source (default: 1)
Returns:: tuple[float, float] – Tuple of (base_voltage, peak_voltage)

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 (Union[SPGUSignalSource, int]) – Signal source for the pulse timings, defaults to SPGUSignalSource.PULSE_SIGNAL_1 (default: 1)
delay (float) – Pulse delay in seconds, defaults to 0 (default: 0)
width (float) – Pulse width in seconds, defaults to 1e-7 (default: 1e-07)
rise_time (float) – Pulse rise time in seconds, defaults to 2e-8 (default: 2e-08)
fall_time (Optional[float]) – Pulse fall time in seconds, defaults to rise_time if None (default: None)

Return type:

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 (Union[SPGUSignalSource, int]) – Signal source for the pulse timings, defaults to SPGUSignalSource.PULSE_SIGNAL_1 (default: 1)
Returns:: tuple[float, ...] – Tuple of (delay, width, rise_time, fall_time)

apply_setup()

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

Depends on the SPGU.operation_mode (SIM): :rtype: None

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

property voltage_monitor_enabled: bool

Control the MFCMU AC and DC voltage data monitor and output. (LMN)

When enabled, the AC (oscillator level) and DC bias voltage values are returned together with the measurement data.

MEASUREMENT_RANGES = [50, 100, 300, 1000, 3000, 10000, 30000, 100000, 300000]: Fixed measurement ranges (impedance, Ohm) selectable for the MFCMU high speed spot measurement. Available ranges depend on the output signal frequency set by frequency_ac (FC).

measure(meas_range=None, timestamp=False)

Perform a high speed spot measurement with the MFCMU. (TC or TTC)

The measurement starts immediately, regardless of the trigger mode and measurement mode. The channel must be enabled (enable()) and the measurement parameters must be selected with set_measurement_mode() beforehand.

The primary and secondary parameters are selected by set_measurement_mode(), e.g. Cp and G for MFCMUMeasurementMode.CP_G. If voltage_monitor_enabled is set, the AC (oscillator level) and DC bias voltage monitor values are appended, and a tuple with the extra ac_voltage and dc_voltage fields is returned instead.

Parameters:

meas_range (Optional[int]) – Fixed measurement range from MEASUREMENT_RANGES in Ohm, defaults to auto ranging (default: None)
timestamp (bool) – Whether to also return the time from timer reset (AgilentB1500.clear_timer()) to the start of the measurement (default: False)

Returns:

Union[SpotCMU, SpotCMUMonitor, TimedSpotCMU, TimedSpotCMUMonitor] – SpotCMU (or TimedSpotCMU with timestamp) of the primary and secondary parameter; the SpotCMUMonitor / TimedSpotCMUMonitor variant additionally carrying ac_voltage and dc_voltage when voltage_monitor_enabled

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 (Union[int, str]) – Query type according to the programming guide
Returns:: dict[str, Union[str, list[str]]] – Dictionary of command and set values

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 (Union[int, str]) – Number according to Programming Guide
smu_references (dict[int, SMU]) – SMU references by channel
single_command (Union[str, Literal[False]]) – if only a single command should be returned, defaults to False (default: False)

Returns:

Union[dict[str, str], dict[str, Union[str, bool]], dict[str, OrderedDict[str, Union[str, bool]]]] – Read configuration

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 (Union[str, list[str]]) – Parameters for one command returned by query_learn()
names (Sequence[Union[str, tuple[str, Callable[[str], Union[str, bool]]]]]) – list of names or (name, function) tuples, ordered

Returns:

OrderedDict[str, Union[str, bool]] – Parameter name and (processed) parameter

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[int]) – Ranges which are supported (list of range indices)
ranges (Union[dict[str, int], dict[str, tuple[int, int]]]) – All range names {Name: Indices}
fixed_ranges (bool) – Add fixed ranges (negative indices), defaults to False (default: 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 (Union[str, int]) – Range name or index
Returns:: Range – Named tuple (name/index) of range

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.TimedSpotCurrent(time, current)

Bases: tuple

current: Alias for field number 1

time: Alias for field number 0

class pymeasure.instruments.agilent.agilentB1500.TimedSpotVoltage(time, voltage)

Bases: tuple

time: Alias for field number 0

voltage: Alias for field number 1

class pymeasure.instruments.agilent.agilentB1500.SpotIV(current, voltage)

Bases: tuple

current: Alias for field number 0

voltage: Alias for field number 1

class pymeasure.instruments.agilent.agilentB1500.TimedSpotIV(time, current, voltage)

Bases: tuple

current: Alias for field number 1

time: Alias for field number 0

voltage: Alias for field number 2

class pymeasure.instruments.agilent.agilentB1500.SpotCMU(primary, secondary)

Bases: tuple

primary: Alias for field number 0

secondary: Alias for field number 1

class pymeasure.instruments.agilent.agilentB1500.TimedSpotCMU(time, primary, secondary)

Bases: tuple

primary: Alias for field number 1

secondary: Alias for field number 2

time: Alias for field number 0

class pymeasure.instruments.agilent.agilentB1500.SpotCMUMonitor(primary, secondary, ac_voltage, dc_voltage)

Bases: tuple

ac_voltage: Alias for field number 2

dc_voltage: Alias for field number 3

primary: Alias for field number 0

secondary: Alias for field number 1

class pymeasure.instruments.agilent.agilentB1500.TimedSpotCMUMonitor(time, primary, secondary, ac_voltage, dc_voltage)

Bases: tuple

ac_voltage: Alias for field number 3

dc_voltage: Alias for field number 4

primary: Alias for field number 1

secondary: Alias for field number 2

time: Alias for field number 0

class pymeasure.instruments.agilent.agilentB1500.CustomIntEnum(new_class_name, /, names, *, 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.

Return type:: str

classmethod get(input_value)

Give Enum member by specifying name or value.

Parameters:: input_value (Union[int, str]) – Enum name or value
Returns:: CustomIntEnum – Enum member

class pymeasure.instruments.agilent.agilentB1500.ADCType(*values)

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(*values)

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(*values)

Bases: CustomIntEnum

Auto/Manual selection.

AUTO = 0

MANUAL = 1

class pymeasure.instruments.agilent.agilentB1500.ControlMode(*values)

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(*values)

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(*values)

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(*values)

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(*values)

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(*values)

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(*values)

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(*values)

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(*values)

Bases: CustomIntEnum

Output after sampling.

BASE = 1

BIAS = 2

class pymeasure.instruments.agilent.agilentB1500.SPGUChannelOutputMode(*values)

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(*values)

Bases: CustomIntEnum

Signal source for SPGU.

DC = 0

PULSE_SIGNAL_1 = 1

PULSE_SIGNAL_2 = 2

class pymeasure.instruments.agilent.agilentB1500.SPGUOperationMode(*values)

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(*values)

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(*values)

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(*values)

Bases: CustomIntEnum

Output after staircase sweep.

START = 1

STOP = 2

class pymeasure.instruments.agilent.agilentB1500.CompliancePolarity(*values)

Bases: CustomIntEnum

Compliance polarity.

AUTO = 0

MANUAL = 1

class pymeasure.instruments.agilent.agilentB1500.WaitTimeType(*values)

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