Monitors 

Main Classes 

class pymeasure.instruments.advantest.advantestR624X.AdvantestR6245(adapter, name='Advantest R6245 SourceMeter', **kwargs)

Bases: AdvantestR624X

Represent the Advantest R6245 DC Voltage/Current Source/Monitor.

ch_A

Channel:: SMUChannel

ch_B

Channel:: SMUChannel

class pymeasure.instruments.advantest.advantestR624X.AdvantestR6246(adapter, name='Advantest R6246 SourceMeter', **kwargs)

Bases: AdvantestR624X

Represent the Advantest R6246 DC Voltage/Current Source/Monitor.

ch_A

Channel:: SMUChannel

ch_B

Channel:: SMUChannel

class pymeasure.instruments.advantest.advantestR624X.AdvantestR624X(adapter, name='R624X Source meter Base Class', **kwargs)

Bases: Instrument

Represents the Advantest R624X series (channel A and B) SourceMeter and provides a high-level interface for interacting with the instrument.

This is the base class for both AdvantestR6245 and AdvantestR6246 devices. It’s not necessary to instantiate this class directly instead create an instance of the AdvantestR6245 or AdvantestR6246 class as shown in the following example:

smu = AdvantestR6246("GPIB::1")
smu.reset()                                                     # Set default parameters
smu.ch_A.current_source(source_range = CurrentRange.FIXED_60mA,
                        source_value = 0,                       # Source current at 0 A
                        voltage_compliance = 10)                # Voltage compliance at 10 V
smu.ch_A.enable_source()                                        # Enables the source output
smu.ch_A.measure_voltage()
smu.ch_A.current_change_source = 5e-3                           # Change to 5mA
print(smu.read_measurement())                                   # Read and print the voltage
smu.ch_A.standby()                                              # Put channel A in standby

write(command, **kwargs)

Write a string command to the instrument appending write_termination.

Parameters:

command – command string to be sent to the instrument
kwargs – Keyword arguments for the adapter.

check_errors(): Check the error register and raise an exception if an error occurred.

enable_source(): Enable channel A and B output (CN).

Note

When the ‘interlock control’ of the ‘SCT’ command is ‘2’ and the clock signal is ‘HI’, it will not enter the operating state.

standby(): Put channel A and B in standby mode (CL).

reset(): Reset the instrument to default settings (*RST).

clear_status_register(): Clear the Standard Event Status Register (SESR) and related queues (excluding output queues) (*CLS).

property srq_enabled: Any

Set whether the GPIB SRQ feature is enabled (bool) (S0/S1).

Type:: bool

The SRQ feature of the GPIB bus provides hardware handshaking between the GPIB controller card in the PC and the instrument. This allows synchronization between moving data to the PC with the state of the instrument without the need to use time delay functions.

trigger()

Output the trigger signal or start sweep and search measurement for both A and B channels and the trigger link (XE).

Note

When both A channel and B channel are waiting for a trigger, both channels are triggered.
When either channel A or B is waiting for a trigger, only the channel that is waiting for a trigger is triggered.
When both A channel and B channel are waiting for sweep start, this will apply sweep start to both channels.
When either channel A or B is in the sweep start waiting state, only the channel in the sweep start waiting state is started.
When either channel A or B is waiting for a trigger and the other is waiting for a sweep start, trigger and sweep start are applied, respectively.
When the trigger link is ON and this is the master unit, set the *TRG signal on the trigger link bus to TRUE.
When the trigger link is ON and the master unit, the trigger link is activated.

stop(): Stop the sweep started by the XE command or the trigger input signal (SP).

set_digital_output(values)

Output a 16-bit signal from the DIGITAL OUT output terminal on the rear panel (DIOS). If there are multiple values specified, the data is output at intervals of about 2ms and fixed as the final data.

Parameters:: values (int or list) – Digital out bit values

Note

The output of digital data to the DIGITAL OUT pin is only the bits specified by the DIOE command. Bits that are not specified will result in alarm output or unused, and no digital data will be output.

property sweep_delay_time: Any

Set the sweep delay time (Ta) or generation/delay time (Ta) of the master and slave channels during delayed sweep or synchronous pulse measurement operation (GDLY).

Type:: float

Note

If the sweep delay time does not meet (Ta<Tw and Ta<Td+Tit), an execution error will occur and it will not be set:

Tw: Pulse width Td: Major delay time Tit: Integration time

property operation_mode: Get the operation mode and sweep delay time (LDS?).

query_operation_mode(): Get the operation mode and sweep delay time.

Deprecated since version 0.16: Use operation_mode instead.

property system_settings: Get the output data format, common short, power frequency, and SRQ gate settings (LDS_50?).

query_system_settings(): Get the output data format, common short, power frequency, and SRQ gate settings.

Deprecated since version 0.16: Use system_settings instead.

search_measurement_setup(search_mode, occurrence_after_stop, command)

Configure search measurement sense/search channel parameters (MAR~;NENT).

Parameters:

search_mode (int or SearchMode) – Search mode specifying binary/linear and sense/search channel.
occurrence_after_stop (int or OccurrenceAfterStop) – Output behavior after stopping.
command (str) – Inner command string (e.g. 'FXV 1,20,6,17,2,0'). Valid prefixes: FXV, FXI, PXV, PXI, WV, WI, PWV, PWI, CMD.

Note

Parameter meanings of the inner command change in search context. See the instrument manual for details on how FXV/FXI/PXV/PXI and WV/WI/PWV/PWI parameters are reinterpreted.

search_comparison_setup(search_mode, occurrence_after_stop, channel, comparison, comparison_function, upper_limit, lower_limit)

Configure search measurement comparison calculation (MAR~;CMD~;NENT).

Parameters:

search_mode (int or SearchMode) – Search mode specifying binary/linear and sense/search channel.
occurrence_after_stop (int or OccurrenceAfterStop) – Output behavior after stopping.
channel (int) – Channel number (1 or 2, ignored by instrument).
comparison (int or ComparisonMode) – Comparison mode.
comparison_function (int or ComparisonValueType) – Comparison value type.
upper_limit (float) – Upper comparison limit.
lower_limit (float) – Lower comparison limit.

Note

If the lower value is greater than the upper value, the instrument will return an error.

append_sequence_command(command): Append a command to the sequence being recorded.

init_sequence(): Start redirecting write() calls to build a sequence program.

start_sequence(repeat=1): Start the sequence program built by init_sequence().

end_sequence(): End sequence recording started by init_sequence() and store the program.

sequence_wait(wait_mode, wait_value)

Wait during sequence program execution (WAIT).

Parameters:

wait_mode (int or SequenceWaitMode) – Whether wait time (1) or trigger input count (2) is specified.
wait_value (float) – Wait time or trigger input count as specified by wait_mode.

This command has the following functions:

Make the execution of the next program wait for the specified time.

Makes the next program execution wait until the specified number of triggers is input.

Regardless of the wait mode, if the wait data is 0, the wait operation is not performed. When the wait mode is “2”, the following commands and signals can be used as trigger inputs:

XE (XE 0, XE 1, XE 2)

*TRG

GET command (group execute trigger)

Trigger input signal on rear panel

start_sequence_program(start, stop, repeat)

Execute the sequence program from start to stop line, repeating as specified (RU).

Parameters:

start (int) – Number of the program to start from ranging 1 to 100
stop (int) – Number of the program to stop at ranging from 1 to 100
repeat (int) – Number of times repeated from 1 to 100

store_sequence_command(line, command)

Store a command string at the specified sequence program line (ST).

Parameters:

line (int) – Line number specified of memory location
command (str) – Command(s) specified to be stored delimited by a semicolon (;)

interrupt_sequence(action)

Interrupt the sequence program executed by start_sequence_program() (SQSP).

Parameters:: action (SequenceInterruptionType) – Specifies sequence interruption setup

interrupt_sequence_command(action): Interrupt the sequence program.

Deprecated since version 0.16: Use interrupt_sequence() instead.

property sequence_program_number: Any

Get the number of program sequences stored in sequence memory (LNUB?).

The response has the format #3XXX,line1,line2,... where XXX is a 3-digit count of stored programs and the remaining values are line numbers. This property returns only the count as an integer.

query_sequence_program(line)

Query the commands stored at a sequence program line (LST?).

Parameters:: line (int) – Line number specifying the memory location to read.
Returns:: Commands stored in sequence memory.
Return type:: str

sequence_program_listing(line): Query the commands stored at a sequence program line.

Deprecated since version 0.16: Use query_sequence_program() instead.

store_highspeed_sequence(program_number, command)

Store commands in a high-speed sequence program number (PGST~;END).

Parameters:

program_number (int) – Program number from 1 to 20.
command (str) – Semicolon-delimited command string to store.

Note

This method should not be called while a standard sequence is being built (between init_sequence() and end_sequence()), as the write will be intercepted by the standard sequence system.

conditional_jump(channel, condition, destination)

Set a conditional jump in a high-speed sequence program (EXT).

Parameters:

channel (int) – Channel selection (1=A, 2=B, 3=A|B OR condition).
condition (int or JumpCondition) – Jump condition.
destination (int) – Jump destination program number (1 to 20).

Note

Conditions 1-4: proceed to the next program if condition is not met.
Conditions 7-10: stay at the current program if condition is not met.
Condition 5: cancel conditional jump.
Condition 6: jump unconditionally (channel data is ignored).
Destination must be >= current program number to be executed.

enable_highspeed_sequence(trigger_mode)

Enable the start of a high-speed sequence program (PGON).

Parameters:: trigger_mode (int or HighSpeedTriggerMode) – Trigger mode for program execution.

Trigger modes:

Continuous: executes all programs sequentially on one trigger.
Step: executes one program per trigger.
Execution trigger measurement: applies settings, then waits for a trigger before each measurement.

Note

Store programs in program numbers 1-20 using store_highspeed_sequence() before calling this method. Program numbers without stored programs are skipped.

disable_highspeed_sequence(): Cancel the start/enable state of the high-speed sequence program set by enable_highspeed_sequence() (PGOF).

clear_highspeed_sequence(program_number, clear_mode)

Clear program(s) stored in high-speed sequence memory (PCEL).

Parameters:

program_number (int) – Program number from 1 to 20.
clear_mode (int or ProgramClearMode) – Clear mode.

Clear modes:

Clear only the specified program number.
Clear the specified program number and all subsequent programs.

trigger_output_signal(trigger_output, alarm_output, scanner_output)

Output the trigger, alarm, and scanner (start/stop) signals from GPIB (OSIG).

Parameters:

trigger_output (int) – Number specifying type of trigger output
alarm_output (int) – Number specifying type of alarm output
scanner_output (int) – Number specifying the type of scanner output

Trigger output:

Do not output to trigger output.
Output a negative pulse to the trigger output.

Alarm output:

Finish output GO, LO.HI both set to HI level. (reset)
Finish output Set GO to LO level.
Set home output LO to LO level.
Terminate output HI to LO level.

Scanner - (start/stop) output:

Set the scanner scoot output to HI level. Output a negative pulse to the stop output.
Make the scanner start output low.
Output a HI level for the scanner start output and a negative pulse for the stop output.

set_output_format(delimiter_format, block_delimiter, terminator)

Set the format and terminator of the GPIB output data (FMT).

Parameters:

delimiter_format (int) – Type of delimiter format
block_delimiter (int) – Type of block delimiter
terminator (int) – Type of termination character

The output of <EOI> (End or Identify) is output at the following timing: 1,2: Simultaneously with LF 4: Simultaneously with the last output data

If the output data format is specified as binary format, the terminator is fixed to <EOI> only and the terminator selection is ignored.

delimiter_format:

ASCII format with header

No header, ASCII format

Binary format

block_delimiter:

Make it the same as the terminator.

Use semicolon ;

Use comma ,

terminator:

CR, LF<EOI>

LF<EOI>

LF

<EOI>

1st character header:
	Normal measurement data
	Measurement data during overrange
	Compliance (limiter) is working.
	Oscillation detection is working.
	[Indicates the generated data]
	Measurement data when an error occurs in the search measurement
	Measurement data is not stored in the buffer memory.

2nd character header:
	A-channel data during asynchronous operation (A-channel generation data)
	B-channel data during asynchronous operation (B channel generation data)
	A-channel data for synchronous, sweeping, delayed sweep, and double synchronous sweep operations.
	B-channel data for synchronous, sweeping, delayed sweep, and double synchronous sweep operations.

3rd character header:
	Current generation, voltage measurement (ISVM) [Current generation]
	Voltage generation, current measurement (VSIM) [Voltage generation]
	Current generation, current measurement (ISIM)
	Voltage generation, voltage measurement (VSVM)
	Current generation, external voltage measurement (IS, EXT, VM)
	Voltage generation, external current measurement (VS, EXT, IM)
	Current generation, external current measurement (IS, EXT. IM)
	Voltage generation, external voltage measurement (VS, EXT, VM)
	The measurement data is not stored in the buffer memory.

4th character header:
	No operation (fixed to A)
	Null operation result
	The result of the comparison operation is GO.
	The result of the comparison operation is LO.
	The result of the comparison operation is HI.
	The result of null operation + comparison operation is GO.
	The result of null operation + comparison operation is LO.
	The result of null operation + comparison operation is HI.
	Measurement data is not stored in the buffer memory.

property service_request_enable_register: Any: Control the service request enable register (SRER) as a SRER IntFlag (*SRE).

Note

Bits other than the RQS bit are not cleared by serial polling. When power_on_clear() is set, status byte enable register, SESER, device operation enable register, channel operation, the enable register is cleared and no SRQ is issued.

property event_status_enable: Any: Control the standard event status enable register (*ESE).

property power_on_clear: Any: Control the power-on clear flag (bool) (*PSC).

property device_operation_enable_register: Any: Control the device operation output enable register (DOER) (DOE?).

property digital_output_enable: Any: Control the digital output enable data register (DIOE).

property digital_out_enable_data: Control the digital output enable data register.

Deprecated since version 0.16: Use digital_output_enable instead.

property status_byte_register: Any

Measure the status byte register and MSS bits without using a serial poll (*STB?).

The Status Byte Register has a hierarchical structure. ERR, DOP, ESB, and COP bits, except RQS and MAV, have lower-level status registers. Each register is paired with an enable register that can be selected to output to the Status Byte register or not. The status byte register also has an enable register, which allows you to select whether or not to issue a service request SRQ.

Note

*STB? command can read bit 6 as MSS (logical OR of other bits).

property event_status_register: Any: Measure the standard event status register (SESR) as a SESR IntFlag (*ESR?).

Note

SESR is cleared after being read.

property device_operation_register: Any: Measure the device operations register (DOR) as a DOR IntFlag (DOC?).

property error_register: Any

Measure the error register contents as a 5-digit integer (ERR?).

The response format is UUEEN where UU is the unit number (00=system, 01=ch A, 02=ch B) and EEN is the error code. Use check_errors() for structured error checking with messages.

property self_test: Any: Get the result of the self-test (*TST?).

Warning

This command may take a long time to complete or may not be supported on all models. A VISA timeout error is possible. Consider wrapping in a try/except block or increasing the adapter timeout before calling.

property trigger_link_enabled: Any

Set whether the trigger link function is enabled (bool) (TLNK).

Type:: bool

property display_enabled: Any

Set whether the front panel display is enabled (bool) (DISP).

Type:: bool

property line_frequency: Any

Set the power supply frequency to 50 or 60 Hz (LF).

Type:: int

The integration time per PLC for measurements is set to one cycle of the specified power supply frequency.

property store_config: Any

Set the memory area (0-4) to store the configuration (SAV).

Type:: int

property load_config: Any

Set the memory area (0-4) to load the configuration from (RCL).

Type:: int

set_lo_common_connection_relay(enable, lo_relay=None)

Configure the LO common connection relay between channels A and B (LTL).

Parameters:

enable (bool) – A boolean property that controls whether or not the connection relay is enabled. Valid values are True and False.
lo_relay (bool, optional) – A boolean property that controls whether or not the internal analog common relay is enabled. Valid values are True, False and None (don’t change lo relay setting). (default: None)

parse_measurement(measurement): Parse a measurement response string into a (value, header) tuple.

read_measurement(): Read the last triggered measurement value.

class pymeasure.instruments.advantest.advantestR624X.SMUChannel(parent, id, voltage_range, current_range)

Bases: Channel

Represent a single SMU channel (A or B) of the Advantest R624X.

insert_id(command)

Insert the channel id in a command replacing placeholder.

Subclass this method if you want to do something else, like always prepending the channel id.

clear_measurement_buffer(): Clear the measurement data buffer (MBC).

property output_waveform_settings: Get the output waveform settings for this channel (LDS_0x?).

query_output_waveform(): Get the output waveform settings for this channel.

Deprecated since version 0.16: Use output_waveform_settings instead.

property measurement_range_settings: Get the measurement range, integration time, hold time, delay time, pulse width, and pulse period for this channel (LDS_1x?).

query_measurement_settings(): Get the measurement range settings for this channel.

Deprecated since version 0.16: Use measurement_range_settings instead.

property response_settings: Get the response mode, operate mode, and remote sense settings for this channel (LDS_2x?).

query_response_settings(): Get the response mode settings for this channel.

Deprecated since version 0.16: Use response_settings instead.

property data_output_settings: Get the null operation, comparison operation, output data type, and sweep stop condition for this channel (LDS_3x?).

query_data_output_settings(): Get the data output settings for this channel.

Deprecated since version 0.16: Use data_output_settings instead.

property io_settings: Get the analog input, trigger output timing, trigger input type, scanner control, and interlock control for this channel (LDS_4x?).

query_io_settings(): Get the I/O settings for this channel.

Deprecated since version 0.16: Use io_settings instead.

set_output_type(output_type, measurement_type)

Set the output method and type of the GPIB output (OFM).

Parameters:

output_type (int or OutputType) – A property that controls the type of output
measurement_type (int or MeasurementType) – A property that controls the measurement type

Note

For the format of the output data, refer to AdvantestR624X.set_output_format(). For DC and pulse measurements, the output method is fixed to ‘1’ (real-time output). When the output method ‘3’ (buffering output) is specified, the measured data is not stored in memory.

property analog_input: Any

Set the analog input terminal (ANALOG INPUT) on the rear panel ON or OFF (IAN).

Type:

int

Turn off the analog input.
Analog input ON, gain x1.
Analog input ON, gain x2.5.

property trigger_output_timing: Any

Set the timing of the trigger output signal from TRIGGER OUT on the rear panel (TOT).

Type:: TriggerOutputSignalTiming

set_scanner_control(output, interlock)

Set the SCANNER CONTROL (START, STOP) output signal and INTERLOCK input signal on the rear panel (SCT).

Parameters:

output (int) – A property that controls the scanner output
interlock (int) – A property that controls the scanner interlock type

output:

Scanner, Turn off the control signal output.

Output to the scanner control signal at the start / stop of the sweep.

Operate / Standby Scanner, Output to the control signal.

interlock:

Turn off the interlock signal input.

Set as a stamper when the interlock signal input is HI.

When the interlock signal input is HI, it is on standby, and when it is LO, it is operated.

property trigger_input: Any

Set the type of trigger input (TJM).

Type:: TriggerInputType

Trigger input types	1	2	3
*TRG	O	O	X
XE 0	O	O	X
XE Channel	O	O	O
GET	O	O	X
Trigger input signal	O	X	X

O can be used, X cannot be used

Note

The sweep operation cannot be started by the trigger input signal. Be sure to start it with the ‘XE’ command. Once started, it is possible to advance the sweep with a trigger input signal.

property fast_mode_enabled: Any

Set the channel response mode to fast or slow (bool) (FL).

Type:: bool

property sample_hold_mode: Any

Set the integration time of the measurement (MST).

Type:: SampleHold

Note

Valid only for pulse measurement and pulse sweep measurement.
In sample hold mode, the AD transformation is just before the fall of the pulse width.
The sample hold mode cannot be set during DC measurement and DC sweep measurement. When set to sample-and-hold mode, the integration time is 100 µs. However, in 2-channel synchronous operation, if one channel is in pulse generation and the other is in sample-and-hold mode, the DC measurement side also operates in sample-and-hold mode.
When performing pulse measurement and pulse sweep measurement, it is necessary to satisfy the restrictions on the pulse width (Tw), pulse period (Tp), and measure delay time (Td) of the WT command. If the constraint is not satisfied, the integration time is unchanged. To lengthen the integration time, first change the pulse width (Tw) and pulse period (Tp). When shortening the pulse width and pulse cycle, shorten the integration time first.

set_sample_mode(mode, auto_sampling=True)

Set the synchronous, asynchronous, or tracking operation and search measurement mode between channels (JM).

Parameters:

mode (SampleMode) – Sample Mode
auto_sampling (bool, optional) – Whether or not auto sampling is enabled, defaults to True. When True, measurement data is automatically output after each trigger. When False, data is output only on explicit request (e.g. FCH?). (default: True)

Warning

For dual-channel synchronous modes (PULSED_SYNC, SWEEP_SYNC, etc.), use auto_sampling=False. With auto_sampling=True (the default), the auto-output data contains the generated/source value rather than the actual measurement result when reading via select_for_output() / FCH?.

set_timing_parameters(hold_time, measurement_delay, pulsed_width, pulsed_period)

Set the hold time, measurement delay, pulse width, and pulse period (WT).

Parameters:

hold_time (float) – total amount of time for the complete pulse, until next pulse comes
measurement_delay (float) – time between measurements
pulsed_width (float) – Time specifying the pulse width
pulsed_period (float) – Time specifying the pulse period

Note

Pulse measurement has the following restrictions depending on the pulse period (Tp) setting. (For pulse sweep measurements, there are no restrictions.)

Tp < 2ms : Not measured.

2ms <= Tp < 10ms : Measure once every 5 ~ 20ms.

10ms <= Tp: Measured at each pulse generation.

select_for_output()

Select this channel for measurement data output (FCH?).

Sends the FCH? query to select which channel’s measurement data will be output. Call read_measurement() afterward to read the data.

The recommended usage pattern (per the instrument manual) is:

smu.ch_A.select_for_output()   # Select channel A
smu.trigger()                   # Trigger measurement
value = smu.read_measurement()  # Read channel A data

Or, when data already exists from a previous trigger:

smu.ch_B.select_for_output()   # Switch to channel B
value = smu.read_measurement()  # Read channel B data

Note

Reading measurements with the RMM command does not affect channel specification with the FCH command. In the default state, the measurement data of channel A is output.

trigger(): Send a measurement trigger for sweep, search measurement, or sweep step (XE).

measure_voltage(enable=True, internal_measurement=True, voltage_range=VoltageRange.AUTO)

Set the voltage measurement ON/OFF, measurement input, and voltage measurement range (RV).

Parameters:

enable (bool, optional) – boolean property that enables or disables voltage measurement. Valid values are True (Measure the voltage flowing at the OUTPUT terminal) and False (Measure the voltage from the rear panel -ANALOG COMMON). (default: True)
internal_measurement (bool, optional) – A boolean property that enables or disables the internal measurement. (default: True)
voltage_range (VoltageRange, optional) – Specifying voltage range (default: <VoltageRange.AUTO: 0>)

voltage_source(source_range, source_value, current_compliance)

Set the source range, source value, and current compliance for DC (constant voltage) measurement (DV).

Parameters:

source_range (VoltageRange) – Specifying source range
source_value (float) – A number specifying the source voltage value
current_compliance (float) – A number specifying the current compliance

Note

Regardless of the specified current compliance polarity, both polarities (+ and -) are set. The current compliance range is automatically set to the minimum range that includes the set value.

voltage_pulsed_source(source_range, pulse_value, base_value, current_compliance): Set the source range, pulse value, base value, and current compliance for pulse (voltage) measurement (PV).

Note

Regardless of the specified current compliance polarity, both polarities (+ and -) are set. The current compliance range is automatically set to the minimum range that includes the set value.

Warning

When using pulsed sources, measure_current() must be called with a fixed range (e.g. CurrentRange.FIXED_BEST). CurrentRange.AUTO and AUTO_* ranges are not supported in pulsed modes (error 00211).

property change_source_voltage: Any

Set new target voltage (SPOT).

Type:: float

Note

Only the DC action source value and pulse action pulse value are changed using the currently set DC action and pulse action parameters. Measure after the change and set the channel to output the measured data to the specified ch. In other words, it’s the same as running the following commands:

DV/DI/PV/PI

XE xx

FCH xx

voltage_fixed_level_sweep(voltage_range, voltage_level, measurement_count, current_compliance, bias=0): Set the fixed level sweep (voltage) generation range, level value, current compliance, and bias value (FXV).

Note

Regardless of the specified current compliance polarity, both polarities (+ and -) are set. The current compliance range is automatically set to the minimum range that includes the set value.

voltage_fixed_pulsed_sweep(voltage_range, pulse, base, measurement_count, current_compliance, bias=0): Set the fixed pulse (voltage) sweep generation range, pulse value, base value, number of measurements, current compliance, and bias value (PXV).

Note

Regardless of the specified current compliance polarity, both polarities (+ and -) are set. The current compliance range is automatically set to the minimum range that includes the set value.

Warning

When using pulsed sweeps, measure_current() must use a fixed range (e.g. CurrentRange.FIXED_BEST). Auto ranges are not supported (error 00211).

voltage_sweep(sweep_mode, repeat, voltage_range, start_value, stop_value, steps, current_compliance, bias=0)

Set the sweep mode, number of repeats, source range, start value, stop value, number of steps, current compliance, and bias value for staircase (linear/log) voltage sweep (WV).

Note

Sweep mode, number of repeats, and number of steps are subject to the following restrictions.
- Let N = number of steps, m = l (one-way sweep), m = 2 (round-trip sweep).
  When the OFM command sets the output data output method to 1 or 2 m x number of refreshes x N <= 2048
  
  m x N <= 2048 when the OFM command sets the output data output method to 3.
Regardless of the specified current compliance polarity, both polarities (+ and -) are set.
The current compliance range is automatically set to the minimum range that includes the set value.

voltage_pulsed_sweep(sweep_mode, repeat, voltage_range, base, start_value, stop_value, steps, current_compliance, bias=0)

Set the sweep mode, repeat count, generation range, base value, start value, stop value, number of steps, current compliance, and bias value for pulse wave (linear/log) voltage sweep (PWV).

Note

The sweep mode, number of refreshes, and number of steps are subject to the following restrictions:
- Let N = number of steps, m = l (one-way sweep), m = 2 (round-trip sweep).
  When the OFM command sets the output data output method to 1 or 2 m x number of refreshes x N <= 2048
  
  m x N <= 2048 when the OFM command sets the output data output method to 3.
For the current compliance polarity, regardless of the specified current compliance polarity, the compliance of both polarities (+ and -) is set.
The current compliance range is automatically set to the minimum range that includes the set value.

Warning

When using pulsed sweeps, measure_current() must use a fixed range (e.g. CurrentRange.FIXED_BEST). Auto ranges are not supported (error 00211).

voltage_random_sweep(sweep_mode, repeat, start_address, stop_address, current_compliance, bias=0)

Set the sweep mode, repeat count, start address, stop address, current compliance, and bias value for constant voltage random sweep (MDWV).

Note

Sweep mode, number of repeats, start address and stop address are subject to the following restrictions:
- Start address < Stop address
- Let N = number of steps, m = l (one-way sweep), m = 2 (round-trip sweep).
  When the OFM command sets the output data output method to 1 or 2 m x number of refreshes x N <= 2048
  
  m x N <= 2048 when the OFM command sets the output data output method to 3.
Regardless of the specified current compliance polarity, both polarities (+ and -) are set.
The current compliance range is automatically set to the minimum range that includes the set value.

voltage_random_pulsed_sweep(sweep_mode, repeat, start_address, stop_address, current_compliance, bias=0)

Set the sweep mode, repeat count, base value, start address, stop address, current compliance, and bias value for constant voltage random pulse sweep (MPWV).

Note

Sweep mode, number of repeats, start address and stop address are subject to the following restrictions:
- Start address < Stop address
- Let N = number of steps, m = l (one-way sweep), m = 2 (round-trip sweep).
  When the OFM command sets the output data output method to 1 or 2 m x number of refreshes x N <= 2048
  
  m x N <= 2048 when the OFM command sets the output data output method to 3.
Regardless of the specified current compliance polarity, both polarities (+ and -) are set.
The current compliance range is automatically set to the minimum range that includes the set value.

set_voltage_random_memory(address, voltage_range, output, current_compliance)

Store voltage parameters to the random sweep data memory (RMS).

Stored generated values are swept within the specified memory address range by the MDWV, MDWI, MPWV, MPWI commands.

current_source(source_range, source_value, voltage_compliance)

Set the source range, source value, and voltage compliance for DC (constant current) measurement (DI).

Parameters:

source_range (CurrentRange) – Specifying source range
source_value (float) – A number specifying the source current value
voltage_compliance (float) – A number specifying the voltage compliance

Note

Regardless of the specified voltage compliance polarity, both polarities (+ and -) are set. The voltage compliance range is automatically set to the minimum range that includes the set value.

current_pulsed_source(source_range, pulse_value, base_value, voltage_compliance): Set the source range, pulse value, base value, and voltage compliance for pulse (current) measurement (PI).

Note

Regardless of the specified voltage compliance polarity, both polarities (+ and -) are set. The voltage compliance range is automatically set to the minimum range that includes the set value.

Warning

The source_range must be a fixed range (e.g. CurrentRange.FIXED_BEST). CurrentRange.AUTO and AUTO_* ranges are not supported in pulsed modes (error 00211).

property change_source_current: Any

Set new target current (SPOT).

Type:: float

Note

Only the DC action source value and pulse action pulse value are changed using the currently set DC action and pulse action parameters. Measure after the change and set the channel to output the measured data to the specified ch. In other words, it’s the same as running the following commands:

DV/DI/PV/PI

XE xx

FCH xx

current_fixed_level_sweep(current_range, current_level, measurement_count, voltage_compliance, bias=0): Set the fixed level sweep (current) generation range, level value, voltage compliance, and bias value (FXI).

Note

Regardless of the specified voltage compliance polarity, both polarities (+ and -) are set. The voltage compliance range is automatically set to the minimum range that includes the set value.

current_fixed_pulsed_sweep(current_range, pulse, base, measurement_count, voltage_compliance, bias=0): Set the fixed pulse (current) sweep generation range, pulse value, base value, number of measurements, voltage compliance, and bias value (PXI).

Note

Regardless of the specified voltage compliance polarity, both polarities of + and - are set. The voltage compliance range is automatically set to the minimum range that includes the set value.

Warning

The current_range must be a fixed range (e.g. CurrentRange.FIXED_BEST). CurrentRange.AUTO and AUTO_* ranges are not supported for pulse sweep (error 00211).

current_sweep(sweep_mode, repeat, current_range, start_value, stop_value, steps, voltage_compliance, bias=0)

Set the sweep mode, number of repeats, source range, start value, stop value, number of steps, voltage compliance, and bias value for staircase (linear/log) current sweep (WI).

Note

The sweep mode, number of refreshes, and number of steps are subject to the following restrictions:
- Let N = number of steps, m = l (one-way sweep), m = 2 (round-trip sweep).
  When the OFM command sets the output data output method to 1 or 2, m x number of repeats x N <= 2048.
  
  m x N <= 2048 when the OFM command sets the output data output method to 3.
Regardless of the specified voltage compliance polarity, both polarities (+ and -) are set.
The voltage compliance range is automatically set to the minimum range that includes the set value.

current_pulsed_sweep(sweep_mode, repeat, current_range, base, start_value, stop_value, steps, voltage_compliance, bias=0)

Set the sweep mode, repeat count, generation range, base value, start value, stop value, number of steps, voltage compliance, and bias value for pulse wave (linear/log) current sweep (PWI).

Note

The sweep mode, number of refreshes, and number of steps are subject to the following restrictions:
- Let N = number of steps, m = l (one-way sweep), m = 2 (round-trip sweep).
  When the OFM command sets the output data output method to 1 or 2, m x number of repeats x N <= 2048.
  
  m x N <= 2048 when the OFM command sets the output data output method to 3.
Regardless of the specified voltage compliance polarity, both polarities (+ and -) are set.
The voltage compliance range is automatically set to the minimum range that includes the set value.

Warning

The current_range must be a fixed range (e.g. CurrentRange.FIXED_BEST). CurrentRange.AUTO and AUTO_* ranges are not supported for pulse sweep (error 00211).

measure_current(enable=True, internal_measurement=True, current_range=CurrentRange.AUTO)

Set the current measurement ON/OFF, measurement input, and current measurement range (RI).

Parameters:

enable (bool, optional) – boolean property that enables or disables current measurement. Valid values are True (Measure the current flowing at the OUTPUT terminal) and False (Measure the current from the rear panel -ANALOG COMMON). (default: True)
internal_measurement (bool, optional) – A boolean property that enables or disables the internal measurement. (default: True)
current_range (CurrentRange, optional) – Specifying current range. (default: <CurrentRange.AUTO: 0>)

Warning

CurrentRange.AUTO and AUTO_* ranges cannot be used when the channel is configured for pulse measurement or pulse sweep (error 00211). Use a fixed range such as CurrentRange.FIXED_BEST for pulsed modes.

current_random_sweep(sweep_mode, repeat, start_address, stop_address, current_compliance, bias=0)

Set the sweep mode, repeat count, start address, stop address, voltage compliance, and bias value for constant current random sweep (MDWI).

Note

Sweep mode, number of repeats, start address and stop address are subject to the following restrictions:
- Start address < Stop address
- Let N = (stop number 1 - start number + 1), m = 1 (one-way sweep), m = 2 (round-trip sweep).
  When the output data output method is set to 1 or 2 with the OFM command m x number of repeats x N <= 2048
  
  When the output data output method is set to 3 with the OFM command m x N <= 2048
For the voltage compliance polarity, regardless of the specified voltage compliance polarity, both polarities of + and – are set.
The voltage compliance range is automatically set to the minimum range that includes the set value.

current_random_pulsed_sweep(sweep_mode, repeat, start_address, stop_address, current_compliance, bias=0)

Set the sweep mode, repeat count, base value, start address, stop address, voltage compliance, and bias value for constant current random pulse sweep (MPWI).

Note

Sweep mode, number of repeats, start address and stop address are subject to the following restrictions:
- Start address < Stop address
- Let N = (stop number 1 - start number + 1), m = 1 (one-way sweep), m = 2 (round-trip sweep).
  When the output data output method is set to 1 or 2 with the OFM command m x number of repeats x N <= 2048
  
  When the output data output method is set to 3 with the OFM command m x N <= 2048
For the voltage compliance polarity, regardless of the specified voltage compliance polarity, both polarities of + and – are set.
The voltage compliance range is automatically set to the minimum range that includes the set value.

set_current_random_memory(address, current_range, output, voltage_compliance)

Store current parameters to the random sweep data memory (RMS).

Stored generated values are swept within the specified memory address range by the MDWV, MDWI, MPWV, MPWI commands.

read_random_memory(address)

Read the random sweep memory at the specified address (RMS?).

Parameters:: address (int) – Address to specify memory location.
Returns:: Set values returned by the device from the specified address location.
Return type:: str

enable_source(): Put this channel into the operating state (CN).

standby(): Put this channel into standby state (CL).

stop(): Stop the sweep started by the XE command or trigger input signal (SP).

output_all_measurements(): Output all measurements from this channel’s measurement data buffer (RMM?).

Note

For the output format, refer to AdvantestR624X.output_format(). When a memory address where no measurement data is stored is read, 999.999E+99 will be returned.

read_measurement_from_addr(addr)

Read one measurement at the specified memory address from this channel’s measurement data buffer (RMM?).

Parameters:: addr (int) – Specifies the address to read from.
Returns:: float Measurement data

Note

For the output format, refer to AdvantestR624X.output_format(). When a memory address where no measurement data is stored is read, 999.999E+99 will be returned.

property measurement_count: Any: Measure the number of measurements in the measurement data buffer (NUB?).

property null_operation_enabled: Any

Set whether the null operation is enabled (bool) (NUG).

Type:: bool

Note

Null data is not rewritten even if the null operation is disabled.
Null data is rewritten only when null operation is changed from OFF to ON or initialized in case of DC operation or pulse operation.

set_wire_mode(four_wire, lo_guard=True)

Switch remote sense and set the LO-GUARD relay ON/OFF (OSL).

Parameters:

four_wire (bool) – A boolean property that enables or disables four wire measurements. Valid values are True (enables 4-wire sensing) and False (enables two-terminal sensing).
lo_guard (bool) – A boolean property that enables or disables the LO-GUARD relay.

property auto_zero_enabled: Any

Set the auto zero option ON or OFF (bool) (CM).

Type:: bool

This command sets auto zero (automatically calibrate the zero point of the measured value operation.

Periodically perform auto zero.
Auto zero once, no periodic auto zeros thereafter.

When the auto zero mode is set to True, the following operations are performed.

For DC operation and pulse operation:
- At the end of one sweep, if he has exceeded the last autozero by more than 10 seconds, he will do one autozero.
- If sweep start is specified during auto zero, the sweep will start after auto zero ends.
Sweep operation
- Auto zero is performed once every 10 seconds.
- If measurement or pulse output is specified during auto zero, it will be executed after auto zero ends.

set_comparison_limits(comparison, voltage_value, upper_limit, lower_limit)

Set the measurement comparison ON/OFF and the upper/lower limit values (CMD).

Parameters:

comparison (bool) – A boolean property that controls whether or not the comparison function is enabled. Valid values are True or False.
voltage_value (bool) – A boolean property that controls whether or not voltage or current values are passed. Valid values are True or False.
upper_limit (float) – Number specifying the upper comparison limit
lower_limit (float) – Number specifying the lower comparison limit

property relay_mode: Any

Set the HI/LO relays for standby mode (OPM).

Type:: int

When executing an operation only the HI side turns ON, in standby both HI and LO are turned OFF.
When executing an operation only the LO side turns ON, in standby both HI and LO are turned OFF.
When executing an operation both HI and LO turn ON, in standby both HI and LO are turned OFF.
When executing an operation only the HI side turns ON, in standby only the HI side is turned OFF.

property operation_register: Any: Measure the Channel Operations Register (COR) as a COR IntFlag (COC?).

property output_enable_register: Any: Control the channel operation output enable register (COER) as a COR IntFlag (COE?).

init_calibration(): Initialize the calibration data (CINI).

store_calibration_factor(): Store the calibration factor in non-volatile memory (EEPROM) (CSRT).

calibration_init(): Initialize the calibration data.

Deprecated since version 0.16: Use init_calibration() instead.

calibration_store_factor(): Store the calibration factor.

Deprecated since version 0.16: Use store_calibration_factor() instead.

property calibration_measured_value: Any

Set the externally measured standard value and start calibration (STD).

Type:: float

property calibration_generation_factor: Any

Set the increment or decrement for the generation calibration factor of the current generation range (CCS).

Type:: float

property calibration_measurement_factor: Any

Set the increment of the measurement calibration factor for the current measurement range (CCM).

Type:: float

class pymeasure.instruments.advantest.advantestR624X.SampleHold(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None): Bases: IntEnum

class pymeasure.instruments.advantest.advantestR624X.SampleMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None): Bases: IntEnum

class pymeasure.instruments.advantest.advantestR624X.VoltageRange(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None): Bases: IntEnum

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

Bases: IntEnum

Current measurement/source range selection.

Warning

AUTO and AUTO_* (limited auto) ranges cannot be used for pulse measurement or pulse sweep. Using them in pulsed modes causes error 00211 (“command cannot be executed in current settings”). Use a fixed range such as FIXED_BEST instead.

When the integration time is sample hold mode (SH) and between 100 μs to 500 μs, the resolution is reduced (10 digits at 100 μs, 5 at 200 μs, 2 at 500 μs).

AUTO = 0: Auto range — automatically selects the range that maximizes digits. Cannot be used for pulse measurement or pulse sweep.

AUTO_6nA = 23: Limited auto range (minimum = 6nA). Same as auto but with a floor. Cannot be used for pulse measurement or pulse sweep.

class pymeasure.instruments.advantest.advantestR624X.SweepMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None): Bases: IntEnum

class pymeasure.instruments.advantest.advantestR624X.OutputType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None): Bases: IntEnum

class pymeasure.instruments.advantest.advantestR624X.TriggerInputType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None): Bases: IntEnum

class pymeasure.instruments.advantest.advantestR624X.MeasurementType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None): Bases: IntEnum

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

Bases: IntEnum

Release pause state is a valid command only in the sequence program pause state. otherwise it is ignored.
Pause state enters the pause state when the currently executing program ends.
Abort sequence program stops the sequence program when the currently executing program ends. If the currently running program is a sweep operation, interrupt the sweep operation and stop the sequence program. The output value will be the bias value.

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

Bases: IntFlag

bit assigment for the Device Operation Register (DOR):

Bit (dec)	Description
13	Indicates that the fast tokens program is running.
12	Error in search measurement
11	End of sequence program/high-speed sequence program execution
10	Sequence program Pause state
9	Fan stop detection
8	Self-test error occurred (logic part)
7	Trigger wait state in trigger link master operation
6	Calibration mode status
5	Trigger link ON state
4	Trigger link bus error
3	Sequence program/high-speed sequence 1 program/add/de) waiting
2	Wait for sequence program wait time
1	Sequence program running
0	Synchronous operation state

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

Bases: IntFlag

bit assigment for the Channel Operations Register (COR):

Bit (dec)	Description
14	The result of the comparison operation is HI
13	The result of the comparison operation is GO
12	The result of the comparison operation is LO
11	Overheat detection
10	Overload detection
9	Oscillation detection
8	Compliance detection
7	Synchronous operation master channel
6	Measurement data output specification
5	There is measurement data
4	Self-test error occurrence (analog part)
3	Measurement data buffer full
2	Waiting for trigger
1	End of sweep
0	Operated state

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

Bases: IntFlag

bit assigment for the Service Request Enable Register (SRER):

Bit (dec)	Description
0	none
1	ERR Set when any of QYE, DDE, EXE, or CME in the Standard Event Status Register (SESR) is set.
2	DOP Set when a bit in the device operation register for which the enable register is set to enabled is set. Cleared by reading the device operation register.
3	none
4	MAV Set when output data is set in the output queue. Cleared when output data is read.
5	ESB Set when a bit in the Standard Event Status Register (SESR) is set and the enable register is set to Enabled. Cleared by reading SESR.
6	RQS (MSS) Set when bit O to bit 5 and bit 7 of the Status Byte register are set. (this bit is read-only)
7	COP Set when a bit in the Channel Operations Register is set with the Enable Register set to Enable. Cleared by reading the Channel Operations Register.

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

Bases: IntFlag

bit assigment for the Standard Event Status Register (SESR):

Bit (dec)	Description
0	OPC (Operation Complete) not used
1	RQC unused
2	QYE (Query Error) Set when the output queue overflows when reading without output data.
3	DDE (Device Dependent Error) Set when an error occurs in the self-test.
4	EXE (Execution Error) Set when the input data is outside the range set internally, or when the command cannot be executed.
5	CME (Command Error) Set when an undefined header or data format is wrong, or when there is a syntax error in the command.
6	URQ unused
7	PON Set when power is switched from OFF to ON.

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

Bases: IntFlag

bit assigment for the timing of the trigger output signal output from TRIGGER OUT on the rear panel:

Bit (dec)

Description

5

At the end of the sweep

4

At the end of the pulse width

3

At the end of the pulse cycle

2

At the end of measurement

1

At the start of measurement

0

At the start of occurrence

class pymeasure.instruments.advantest.advantestR624X.SearchMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None): Bases: IntEnum

class pymeasure.instruments.advantest.advantestR624X.OccurrenceAfterStop(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None): Bases: IntEnum

class pymeasure.instruments.advantest.advantestR624X.HighSpeedTriggerMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None): Bases: IntEnum

class pymeasure.instruments.advantest.advantestR624X.JumpCondition(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None): Bases: IntEnum

class pymeasure.instruments.advantest.advantestR624X.ProgramClearMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None): Bases: IntEnum

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

Bases: IntEnum

Comparison mode for search comparison setup.

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

Bases: IntEnum

Value type for search comparison setup.

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

Bases: IntEnum

Wait mode for the WAIT sequence command.

pymeasure.instruments.advantest.advantestR624X.seq_voltage_source(channel, source_range, source_value, compliance)

Build a DV (DC voltage source) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
source_range (int or VoltageRange) – Voltage source range.
source_value (float) – Source voltage value.
compliance (float) – Current compliance value.

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_current_source(channel, source_range, source_value, compliance)

Build a DI (DC current source) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
source_range (int or CurrentRange) – Current source range.
source_value (float) – Source current value.
compliance (float) – Voltage compliance value.

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_voltage_pulsed_source(channel, source_range, pulse_value, base_value, compliance)

Build a PV (pulsed voltage source) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
source_range (int or VoltageRange) – Voltage source range.
pulse_value (float) – Pulse voltage value.
base_value (float) – Base voltage value.
compliance (float) – Current compliance value.

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_current_pulsed_source(channel, source_range, pulse_value, base_value, compliance)

Build a PI (pulsed current source) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
source_range (int or CurrentRange) – Current source range.
pulse_value (float) – Pulse current value.
base_value (float) – Base current value.
compliance (float) – Voltage compliance value.

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_measure_voltage(channel, enable=True, internal_measurement=True, voltage_range=VoltageRange.AUTO)

Build an RV (voltage measurement) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
enable (bool) – Enable voltage measurement.
internal_measurement (bool) – Use internal measurement input.
voltage_range (int or VoltageRange) – Voltage measurement range. (default: <VoltageRange.AUTO: 0>)

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_measure_current(channel, enable=True, internal_measurement=True, current_range=CurrentRange.AUTO)

Build an RI (current measurement) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
enable (bool) – Enable current measurement.
internal_measurement (bool) – Use internal measurement input.
current_range (int or CurrentRange) – Current measurement range. (default: <CurrentRange.AUTO: 0>)

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_timing_parameters(channel, hold_time, measurement_delay, pulsed_width, pulsed_period)

Build a WT (timing parameters) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
hold_time (float) – Hold time in seconds.
measurement_delay (float) – Measurement delay time in seconds.
pulsed_width (float) – Pulse width in seconds.
pulsed_period (float) – Pulse period in seconds.

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_sample_hold_mode(channel, mode)

Build an MST (sample/hold mode) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
mode (int or SampleHold) – Integration time mode.

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_comparison_limits(channel, comparison, voltage_value, upper_limit, lower_limit)

Build a CMD (comparison limits) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
comparison (bool) – Enable comparison (True=ON, False=OFF).
voltage_value (bool) – True for voltage, False for current.
upper_limit (float) – Upper comparison limit.
lower_limit (float) – Lower comparison limit.

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_enable_source(channel)

Build a CN (enable output) command string.

Parameters:: channel (int) – Channel number (1=A, 2=B).
Return type:: str

pymeasure.instruments.advantest.advantestR624X.seq_standby(channel)

Build a CL (standby/disable output) command string.

Parameters:: channel (int) – Channel number (1=A, 2=B).
Return type:: str

pymeasure.instruments.advantest.advantestR624X.seq_relay_mode(channel, mode)

Build an OPM (relay mode) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
mode (int) – Relay mode (1-4).

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_fast_mode(channel, fast)

Build an FL (fast/slow response) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
fast (bool) – True for fast response, False for slow.

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_voltage_fixed_level_sweep(channel, voltage_range, voltage_level, measurement_count, current_compliance, bias=0)

Build an FXV (fixed level voltage sweep) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
voltage_range (int or VoltageRange) – Voltage source range.
voltage_level (float) – Voltage level value.
measurement_count (int) – Number of measurements.
current_compliance (float) – Current compliance value.
bias (float) – Bias value (default 0).

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_current_fixed_level_sweep(channel, current_range, current_level, measurement_count, voltage_compliance, bias=0)

Build an FXI (fixed level current sweep) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
current_range (int or CurrentRange) – Current source range.
current_level (float) – Current level value.
measurement_count (int) – Number of measurements.
voltage_compliance (float) – Voltage compliance value.
bias (float) – Bias value (default 0).

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_voltage_fixed_pulsed_sweep(channel, voltage_range, pulse, base, measurement_count, current_compliance, bias=0)

Build a PXV (fixed pulsed voltage sweep) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
voltage_range (int or VoltageRange) – Voltage source range.
pulse (float) – Pulse voltage value.
base (float) – Base voltage value.
measurement_count (int) – Number of measurements.
current_compliance (float) – Current compliance value.
bias (float) – Bias value (default 0).

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_current_fixed_pulsed_sweep(channel, current_range, pulse, base, measurement_count, voltage_compliance, bias=0)

Build a PXI (fixed pulsed current sweep) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
current_range (int or CurrentRange) – Current source range.
pulse (float) – Pulse current value.
base (float) – Base current value.
measurement_count (int) – Number of measurements.
voltage_compliance (float) – Voltage compliance value.
bias (float) – Bias value (default 0).

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_voltage_sweep(channel, sweep_mode, repeat, voltage_range, start_value, stop_value, steps, current_compliance, bias=0)

Build a WV (staircase voltage sweep) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
sweep_mode (int or SweepMode) – Sweep mode.
repeat (int) – Number of repeats (0-1024).
voltage_range (int or VoltageRange) – Voltage source range.
start_value (float) – Start voltage value.
stop_value (float) – Stop voltage value.
steps (int) – Number of steps (2-2048).
current_compliance (float) – Current compliance value.
bias (float) – Bias value (default 0).

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_current_sweep(channel, sweep_mode, repeat, current_range, start_value, stop_value, steps, voltage_compliance, bias=0)

Build a WI (staircase current sweep) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
sweep_mode (int or SweepMode) – Sweep mode.
repeat (int) – Number of repeats (0-1024).
current_range (int or CurrentRange) – Current source range.
start_value (float) – Start current value.
stop_value (float) – Stop current value.
steps (int) – Number of steps (2-2048).
voltage_compliance (float) – Voltage compliance value.
bias (float) – Bias value (default 0).

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_voltage_pulsed_sweep(channel, sweep_mode, repeat, voltage_range, base, start_value, stop_value, steps, current_compliance, bias=0)

Build a PWV (pulsed voltage sweep) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
sweep_mode (int or SweepMode) – Sweep mode.
repeat (int) – Number of repeats (0-1024).
voltage_range (int or VoltageRange) – Voltage source range.
base (float) – Base voltage value.
start_value (float) – Start voltage value.
stop_value (float) – Stop voltage value.
steps (int) – Number of steps (2-2048).
current_compliance (float) – Current compliance value.
bias (float) – Bias value (default 0).

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_current_pulsed_sweep(channel, sweep_mode, repeat, current_range, base, start_value, stop_value, steps, voltage_compliance, bias=0)

Build a PWI (pulsed current sweep) command string.

Parameters:

channel (int) – Channel number (1=A, 2=B).
sweep_mode (int or SweepMode) – Sweep mode.
repeat (int) – Number of repeats (0-1024).
current_range (int or CurrentRange) – Current source range.
base (float) – Base current value.
start_value (float) – Start current value.
stop_value (float) – Stop current value.
steps (int) – Number of steps (2-2048).
voltage_compliance (float) – Voltage compliance value.
bias (float) – Bias value (default 0).

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_sample_mode(mode, auto_sampling=True, channel=1)

Build a JM (sample mode) command string.

Parameters:

mode (int or SampleMode) – Sample mode.
auto_sampling (bool) – Enable auto sampling. When True, measurement data is automatically output after each trigger. When False, data is output only on explicit request (e.g. FCH?). Use False for dual-channel synchronous modes (PULSED_SYNC, SWEEP_SYNC, etc.) to get actual measurement results.
channel (int) – Channel number (1=A, 2=B).

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_lo_common_relay(enable, lo_relay=None)

Build an LTL (LO common connection relay) command string.

Parameters:

enable (bool) – Enable the connection relay.
lo_relay (bool or None) – Enable internal analog common relay (None=no change). (default: None)

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_digital_output(values)

Build a DIOS (digital output) command string.

Parameters:: values (int or list) – Digital output bit values.
Return type:: str

pymeasure.instruments.advantest.advantestR624X.seq_digital_output_enable(data)

Build a DIOE (digital output enable) command string.

Parameters:: data (int) – Digital output enable data (0-65535).
Return type:: str

pymeasure.instruments.advantest.advantestR624X.seq_conditional_jump(channel, condition, destination)

Build an EXT (conditional jump) command string.

Parameters:

channel (int) – Channel selection (1=A, 2=B, 3=A|B OR).
condition (int or JumpCondition) – Jump condition.
destination (int) – Jump destination program number (1-20).

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_clear_program(program_number, clear_mode)

Build a PCEL (program clear) command string.

Parameters:

program_number (int) – Program number (1-20).
clear_mode (int or ProgramClearMode) – Clear mode.

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_wait(wait_mode, wait_value)

Build a WAIT (sequence wait) command string.

Parameters:

wait_mode (int or SequenceWaitMode) – Wait mode (1=wait time, 2=trigger input count).
wait_value (float) – Wait time or trigger count.

Return type:

str

pymeasure.instruments.advantest.advantestR624X.seq_join(*commands)

Join multiple sequence command strings with semicolons.

Parameters:: commands – One or more command strings from seq_* functions.
Return type:: str

Example:

cmd = seq_join(
    seq_voltage_source(1, VoltageRange.FIXED_BEST, 5.0, 0.1),
    seq_enable_source(1),
)
inst.store_highspeed_sequence(1, cmd)

General Information 

The R6245/6246 Series are DC voltage/current sources and monitors having source measurement units (SMUs) with 2 isolated channels. The series covers wide source and measurement ranges. It is ideal for measurement of DC characteristics of items ranging from separate semiconductors such as bipolar transistors, MOSFETs and GaAsFETs, to ICs and power devices. Further, due to the increased measuring speed and synchronized 2-channel measurement function, device I/O characteristics can be measured with precise timing at high speed which was previously difficult to accomplish. Due to features such as the trigger link function and the sequence programming function which automatically performs a series of evaluation tests, the R6245/6246 enable much more efficient evaluation tests.

There is a total of 99 commands, the majority of commands have been implemented. Device documentation is in Japanese, and the device options are enormous. The implementation is based on 6245S-GPIB-B-FHJ-8335160E01.pdf, which can be downloaded from the ADCMT website.

Examples 

Initialization of the Instrument 

from pymeasure.instruments.advantest import AdvantestR6246
from pymeasure.instruments.advantest.advantestR624X import *

smu = AdvantestR6246("GPIB::1")

Simple dual channel synchronous measurement example 

Measurement characteristics:: Channel A (MASTER): DC voltage source + current measurement Channel B (SLAVE): Pulsed voltage source + current measurement

Note

For dual-channel synchronous mode (PULSED_SYNC), use auto_sampling=False in the sample_mode() call. With auto_sampling=True (the default), the auto-output data contains the generated/source value, not the measurement result.

Warning

CurrentRange.AUTO and AUTO_* (limited auto) ranges cannot be used for pulse measurement or pulse sweep — the instrument returns error 00211. Always use a fixed range such as CurrentRange.FIXED_BEST when configuring pulsed modes.

smu = AdvantestR6246("GPIB::1")
smu.reset()                                               # Set default parameters

# Ch A (MASTER): DC voltage source + current measurement
smu.ch_A.voltage_source(source_range=VoltageRange.FIXED_6V,
                        source_value=5,
                        current_compliance=2)
smu.ch_A.measure_current(current_range=CurrentRange.FIXED_BEST)

# Ch B (SLAVE): Pulsed voltage source + current measurement
smu.ch_B.fast_mode_enabled = True
smu.ch_B.sample_hold_mode = SampleHold.MODE_1mS
smu.ch_B.voltage_pulsed_source(source_range=VoltageRange.FIXED_6V,
                               pulse_value=6, base_value=0,
                               current_compliance=2)
smu.ch_B.measure_current(current_range=CurrentRange.FIXED_BEST)
smu.ch_B.set_timing_parameters(hold_time=0, measurement_delay=1e-4,
                           pulsed_width=1e-2, pulsed_period=2e-2)

# PULSED_SYNC with auto_sampling=False (critical for correct readout)
smu.ch_A.set_sample_mode(SampleMode.PULSED_SYNC, auto_sampling=False)

smu.ch_A.enable_source()
smu.ch_B.enable_source()

for i in range(10):
    smu.ch_A.select_for_output()                          # Select channel A (FCH 01?)
    smu.ch_A.trigger()                                    # Trigger (XE 1, syncs both)
    Ic_a = smu.read_measurement()                         # Read channel A measurement

    smu.ch_B.select_for_output()                          # Select channel B (FCH 02?)
    Ic_b = smu.read_measurement()                         # Read channel B measurement
    print(f'Ic_a={Ic_a}, Ic_b={Ic_b}')

smu.standby()                                             # Put channel A & B in standby

Program example for DC measurement 

Measurement characteristics:: Function: VSIM - Source voltage and measure current Trigger voltage: 10V Current compliance: 0.5A Measurement delay time: 1ms Integration time: 1 PLC Response: Fast

After operating, the measurement is repeated 10 times with a trigger command and he prints out the results.

smu = AdvantestR6246("GPIB::1")
smu.reset()                                                      # Set default parameters
smu.ch_A.set_sample_mode(SampleMode.ASYNC, False)                     # Asynchronous operation and single shot sampling by trigger and command
smu.ch_A.voltage_source(source_range = VoltageRange.FIXED_BEST,
                        source_value = 10,
                        current_compliance = 0.5)                # compliance of 0.5A
smu.ch_A.measure_current()                                       # Measure current
smu.ch_A.set_timing_parameters(hold_time = 0,                    # 0 sec hold time
                               measurement_delay = 1E-3,         # 1ms delay between measurements
                               pulsed_width = 5E-3,              # 5ms pulse width
                               pulsed_period = 10E-3)            # 10ms pulse period
smu.ch_A.sample_hold_mode = SampleHold.MODE_1PLC                 # Sample at 1 power line cycle
smu.ch_A.fast_mode_enabled = True                                # Set channel response to fast
smu.ch_A.enable_source()                                         # Set channel in operating state
smu.ch_A.select_for_output()                                     # Select channel for measurement output

for i in range(1, 10):
    smu.ch_A.trigger()                                           # Trigger a measurement
    measurement = smu.read_measurement()
    print(f"NO {i} {measurement}")

smu.ch_A.standby()                                               # Put channel A in standby mode

Program example for DC measurement (with external trigger)

Measurement characteristics:: Function: VSIM - Source voltage and measure current Source voltage: 10 V Base voltage 1 V Current compliance: 0.5 A Pulse width: 5 ms Pulse period: 10 ms Measurement delay time: 1 ms Integration time: 1 ms Response: Fast

After operating, an external trigger input signal is pulsed to measure the channel operation register. Reads the fixed end bit, captures the measurement data, and prints out the measurement result.

smu = AdvantestR6246("GPIB::1")
smu.reset()                                                      # Set default parameters

smu.ch_A.auto_zero_enabled = False
smu.ch_A.set_sample_mode(SampleMode.ASYNC, False)                     # Asynchronous operation and single shot sampling by trigger and command
smu.ch_A.voltage_pulsed_source(
      source_range = VoltageRange.FIXED_BEST,
      pulse_value = 10,
      base_value = 1,
      current_compliance = 0.5)
smu.ch_A.measure_current(current_range=CurrentRange.FIXED_BEST)  # Fixed range required for pulsed
smu.ch_A.fast_mode_enabled = True                                # Set channel response to fast
smu.ch_A.sample_hold_mode = SampleHold.MODE_1mS                  # Sample at 1mS
smu.ch_A.set_timing_parameters(hold_time = 0,                    # 0 sec hold time
                               measurement_delay = 1E-3,         # 1ms delay between measurements
                               pulsed_width = 5E-3,              # 5ms pulse width
                               pulsed_period = 10E-3)            # 10ms pulse period
smu.ch_A.trigger_input = TriggerInputType.ALL                    # Mode 1 enables the trigger input signal
smu.ch_A.output_enable_register = COR.HAS_MEASUREMENT_DATA       # Measurement data available
smu.service_request_enable_register = SRER.COP                   # COP Set when a bit in the Channel Operations Register is set with the Enable Register set to Enable.
smu.ch_A.enable_source()                                         # Set channel in operating state
smu.ch_A.select_for_output()                                     # Select channel for measurement output

for i in range(1, 10):
    while not smu.ch_A.operation_register & COR.HAS_MEASUREMENT_DATA:
        pass

    measurement = smu.read_measurement()
    print(f"NO {i} {measurement}")

    while not smu.ch_A.operation_register & COR.WAITING_FOR_TRIGGER:
        pass

smu.ch_A.standby()                                               # Put channel A in standby mode

Program example for pulse measurement 

Measurement characteristics:: Function: ISVM - Source current and measure voltage Pulse generation current: 100mA Base current: 1mA Voltage compliance: 5V Pulse width: 0 Pulse period : 0 Measurement delay time: 0 Integration time: 1ms Response: Fast

After the operation, repeat the measurement 10 times with the trigger command and print out the measurement results.

smu = AdvantestR6246("GPIB::1")
smu.reset()                                                         # Set default parameters
smu.ch_A.set_sample_mode(SampleMode.ASYNC, auto_sampling = False)
smu.ch_A.current_pulsed_source(
      source_range = CurrentRange.FIXED_600mA,
      pulse_value = 0.1,                                            # 100mA
      base_value = 1E-3,                                            # 1mA
      voltage_compliance = 5)                                       # 5V
smu.ch_A.measure_voltage(voltage_range = VoltageRange.FIXED_BEST)
smu.ch_A.fast_mode_enabled = True                                   # Set channel response to fast
smu.ch_A.sample_hold_mode = SampleHold.MODE_1mS                     # Sample at 1mS
smu.ch_A.set_timing_parameters(hold_time = 0,                       # 0 sec hold time
                               measurement_delay = 0,               # 0 sec delay between measurements
                               pulsed_width = 0,                    # 0 sec pulse width
                               pulsed_period = 0)                   # 0 sec pulse period
smu.ch_A.enable_source()                                            # Set channel in operating state
smu.ch_A.select_for_output()                                        # Select channel for measurement output

for i in range(1, 10):
    smu.ch_A.trigger()                                              # Trigger measurement

    measurement = smu.read_measurement()
    print(f"NO {i} {measurement}")

    while not smu.ch_A.operation_register & COR.WAITING_FOR_TRIGGER:
        pass

smu.ch_A.standby()                                                  # Put channel A in standby mode

Fixed Level Sweep Program Example 

Measurement characteristics:: function: VSVM - Voltage source and voltage measurement Level value: 15V Bias value: 0V Number of measurements: 20 times Compliance: 6mA Measuring range: Best fixed range (=60V range) Integration time: 100us Measurement delay time: 0 Hold time: 1ms Sampling mode: automatic sweep Measurement data output method: Buffering output (output of specified data)

After operating, make 20 measurements in fixed sweep. Detect the end of sweep by looking at the Channel Operation Register (COR). After the sweep is finished, read the measured data from 1 to 2 using the RMM command.

smu = AdvantestR6246("GPIB::1")

# First we setup our main parameters
smu.reset()                                                      # Set default parameters

smu.ch_A.set_output_type(output_type = OutputType.BUFFERING_OUTPUT_SPECIFIED,
                     measurement_type = MeasurementType.MEASURE_DATA)

smu.set_output_format(delimiter_format = 2,                           # No header, ASCII format
                  block_delimiter = 1,                           # Make it the same as the terminator
                  terminator = 1)                                # CR, LF<EOI>

smu.ch_A.analog_input = 1                                        # Turn off the analog input.

smu.set_lo_common_connection_relay(enable = True)                               # Turns the connection relay on

smu.ch_A.set_wire_mode(four_wire = False,                             # disable four wire measurements
                   lo_guard = True)                              # enable the LO-GUARD relay.

smu.ch_A.auto_zero_enabled = False
smu.ch_A.trigger_input = TriggerInputType.ALL                    # Mode 1 enables the trigger input signal

# Now we set measurement specific variables
smu.ch_A.clear_measurement_buffer()
smu.ch_A.set_sample_mode(SampleMode.ASYNC, auto_sampling = True)
smu.ch_A.voltage_fixed_level_sweep(voltage_range = VoltageRange.FIXED_60V,
                                   voltage_level = 15,
                                   measurement_count = 20,       # 20 measurements
                                   current_compliance = 6E-3,    # compliance at 6mA
                                   bias = 0)
smu.ch_A.measure_voltage(voltage_range = VoltageRange.FIXED_BEST)
smu.ch_A.sample_hold_mode = SampleHold.MODE_100uS
smu.ch_A.set_timing_parameters(hold_time = 1E-3,                 # 1ms sec hold time
                               measurement_delay = 0,            # 0 sec delay between measurements
                               pulsed_width = 0,                 # 0 sec pulse width
                               pulsed_period = 0)                # 0 sec pulse period

smu.ch_A.enable_source()                                         # Set channel in operating state
smu.ch_A.trigger()                                               # Start the sweep

while not smu.ch_A.operation_register & COR.END_OF_SWEEP:        # Wait until the sweep is done
    pass

# Read measurements
for i in range(1, 20):
    measurement = smu.ch_A.read_measurement_from_addr(i)
    print(i, measurement)

smu.ch_A.standby()                                               # Put channel A in standby mode