๏‚›Edit on GitHub

Impedance Analyzer

TcpInstruments.AgilentImpedAnalyzer โ€” Type
source

Agilent Impedance Analyzer

TcpInstruments.get_frequency โ€” Method
get_frequency(ia::Instr{<:AgilentImpedAnalyzer})

Get an array of frequency values with the same number of points as the data trace Output is in [MHz]

Arguments

  • ia::Instr{<:AgilentImpedAnalyzer}: ImpedanceAnalyzer

Returns

  • Array: frequency values with the same number of points as the data trace
source
TcpInstruments.get_frequency_limits โ€” Method
get_frequency_limits(ia::Instr{<:AgilentImpedAnalyzer})

Gets frequency limits

Arguments

  • ia::Instr{<:AgilentImpedAnalyzer}: ImpedanceAnalyzer

Returns

  • Tuple{Frequency, Frequency}: (lowerlimit, upperlimit)
source
TcpInstruments.get_impedance_analyzer_info โ€” Method
get_impedance_analyzer_info(ia::Instr{<:AgilentImpedAnalyzer})

Get current acquisition parameters from the impedance analyzer

Arguments

  • ia::Instr{<:AgilentImpedAnalyzer}: ImpedanceAnalyzer

Returns

  • ImpedanceAnalyzerInfo: dcvoltage [V] acvoltage [V] numaverages bandwidthlevel [1, 2, 3, 4, 5] pointdelaytime [s] sweepdelaytime [s] sweep_direction ["UP", "DOWN"]
source
TcpInstruments.get_num_averages โ€” Method
get_num_averages(ia::Instr{<:AgilentImpedAnalyzer})

Get the number of sweep averages being used

Arguments

  • ia::Instr{<:AgilentImpedAnalyzer}: ImpedanceAnalyzer

Returns

  • Float64: number of sweet averages being iused
source
TcpInstruments.get_num_data_points โ€” Method
get_num_data_points(ia::Instr{<:AgilentImpedAnalyzer})

Gets the set number of data points

Arguments

  • ia::Instr{<:AgilentImpedAnalyzer: ImpedanceAnalyzer

Returns

  • Int: number of data points
source
TcpInstruments.get_sweep_delay_time โ€” Method
get_sweep_delay_time(ia::Instr{<:AgilentImpedAnalyzer})

Get time delay value used between sweep acquisitions

Arguments

  • ia::Instr{<:AgilentImpedAnalyzer}: ImpedanceAnalyzer

Returns

  • Float64: Get time delay value used between sweep acquisitions in [s]
source
TcpInstruments.get_sweep_direction โ€” Method
get_sweep_direction(ia::Instr{<:AgilentImpedAnalyzer})

Get acquisition sweep direction Output is ["UP", "DOWN"]

Arguments

  • ia::Instr{<:AgilentImpedAnalyzer}: ImpedanceAnalyzer

Returns

  • UP sweeps along increasing values (left to right on screen), DOWN sweeps along decreasing values (right to left on screen)
source
TcpInstruments.get_volt_dc โ€” Method
get_volt_dc(ia::Instr{<:AgilentImpedAnalyzer})

Gets DC voltage

Arguments

  • ia::Instr{<:AgilentImpedAnalyzer: ImpedanceAnalyzer

Returns

  • Float64: Voltage
source
TcpInstruments.is_average_mode_on โ€” Method
is_average_mode_on(ia::Instr{<:AgilentImpedAnalyzer})

Get status for whether average mode is on

Arguments

  • ia::Instr{<:AgilentImpedAnalyzer}: ImpedanceAnalyzer

Returns

  • Bool: [true, false]
source
TcpInstruments.set_frequency_limits โ€” Method
set_frequency_limits(ia::Instr{<:AgilentImpedAnalyzer}, lower_limit, upper_limit)

Sets lower and upper frequency limits

Arguments

  • ia::Instr{<:AgilentImpedAnalyzer}: ImpedanceAnalyzer
  • lower_bound::Frequency: lower bound
  • upper_bound::Frequency: upper bound
source
TcpInstruments.set_num_data_points โ€” Method
set_num_data_points(ia::Instr{<:AgilentImpedAnalyzer}, num_points)

Arguments

  • ia::Instr{<:AgilentImpedAnalyzer: ImpedanceAnalyzer
  • num_data_points: number of data points
source
TcpInstruments.set_volt_dc โ€” Method
set_volt_dc(obj::Instr{<:AgilentImpedAnalyzer}, num::Voltage)

Sets DC voltage

Arguments

  • obj::Instr{<:AgilentImpedAnalyzer: ImpedanceAnalyzer
  • num::Voltage: voltage
source
TcpInstruments.get_bandwidth โ€” Method
get_bandwidth(instr)

Returns bandwidth level (1-5)

Arguments

  • i::Instr{Agilent4294A}: ImpedanceAnalyzer

Returns

  • Int: Between 1 and 5
  1. (Initial value) Specifies bandwidth 1 (shortest measurement time)
  2. Specifies bandwidth 2
  3. Specifies bandwidth 3
  4. Specifies bandwidth 4
  5. Specifies bandwidth 5 (longest measurement time, accurate

measurement).

source
TcpInstruments.get_impedance โ€” Method
get_impedance(ia::Instr{Agilent4294A})

Gets the impedance from the impedance analyzer. This function doesn't change any settings on the device, it only grabs data using the current settings.

Arguments

  • ia::Instr{Agilent4294A}: ImpedanceAnalyzer

Returns

  • ImpedanceAnalyzerData: impedance from impedance analyzer
source
TcpInstruments.get_volt_ac โ€” Method
get_volt_ac(instr)

Returns oscillator (ac) voltage

Arguments

  • i::Instr{Agilent4294A}: ImpedanceAnalyzer

Returns

  • Float64: oscillator (ac) voltage
source
TcpInstruments.set_bandwidth โ€” Method
set_bandwidth(i::Instr{Agilent4294A}, n)

Sets bandwidth level (1-5)

Arguments

  • i::Instr{Agilent4294A}: ImpedanceAnalyzer
  • n::Int: Desired bandwidth level (between 1 and 5)
source
TcpInstruments.set_measurement_to_complex โ€” Method
set_measurement_to_complex(ia::Instr{Agilent4294A})

Set Traces A & B to measure Z & Y, respectively Z: Impedance (complex number R + jX) Y: Admittance (complex number G + jB)

R: Equivalent series resistance X: Equivalent series reactance G: Equivalent parallel conductance B: Equivalent parallel susceptance

source
TcpInstruments.set_volt_ac โ€” Method
set_volt_ac(instr, voltage)

Sets the ImpedanceAnalyzer voltage

Arguments

  • i::Instr{Agilent4294A}: ImpedanceAnalyzer
  • voltage: Desired voltage, range for voltage setting: 5E-3 to 1
source
TcpInstruments.get_impedance โ€” Method
get_impedance(obj::Instr{Agilent4395A})

P. 3-10

Error corrected data The results of error correction are stored in the data arrays as complex number pairs. Formatted data

This is the array of data being displayed. It reflects all post-processing functions such as electrical delay, and the units of the array read out depends on the current display format.

Arguments

  • obj::Instr{Agilent4395A}: ImpedanceAnalyzer
source

Multimeter

Keysight Multimeter

TcpInstruments.get_channel โ€” Method
get_channel(obj::Instr{<:KeysightMultimeter})

Indicates which input terminals are selected on the front panel Front/Rear switch. This switch is not programmable; this query reports the position of the switch, but cannot change it.

Do not toggle the Front/Rear switch with active signals on the terminals. This switch is not intended to be used in this way and may be damaged by high voltages or currents, possibly compromising the instrument's safety features.

Returns

  • "FRON" or "REAR"
source
TcpInstruments.get_current โ€” Method
get_current(obj::Instr{<:KeysightMultimeter}; type="DC")

Returns current

Arguments

  • obj::Instr{<:KeysightMultimeter}}: Multimeter

Keywords

  • type: "DC" | "AC" (Default DC)
source
TcpInstruments.get_resistance โ€” Method
get_resistance(multimeter; wire=2)
get_resistance(multimeter; wire=4)

Returns resistance

Arguments

  • obj::Instr{<:KeysightMultimeter}}: Multimeter

Keywords

  • wire: 2 | 4 (Required)
source
TcpInstruments.get_tc_temperature โ€” Method
get_tc_temperature(obj::Instr{<:KeysightMultimeter})

Perform take a measurement with the probe mode set to thermocouple

Arguments

  • obj::Instr{<:KeysightMultimeter}}: Multimeter

Returns

  • Float64: tc temperature
source
TcpInstruments.get_temp_unit โ€” Method
get_temp_unit(multimeter)

Returns set temperature unit

Arguments

  • obj::Instr{<:KeysightMultimeter}}: Multimeter

Returns

  • u: C, F or K
source
TcpInstruments.set_tc_type โ€” Method
set_tc_type(multimeter; type="K")

Sets TC Type

Arguments

  • obj::Instr{<:KeysightMultimeter}}: Multimeter

Keywords

  • type: Can be E, J, K, N, R, T (Defaults to K)
source

Oscilloscope

TcpInstruments.AgilentDSOX1204G โ€” Type
source
TcpInstruments.AgilentDSOX4024A โ€” Type
source
TcpInstruments.AgilentDSOX4034A โ€” Type
source
TcpInstruments.AgilentScope โ€” Type
source

Agilent Oscilloscope

TcpInstruments.get_acquisition_type โ€” Method
get_acquisition_type(scope::Instr{<:AgilentScope})

Gets acquisition type

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope

Returns

  • String: acquisition type
source
TcpInstruments.get_coupling โ€” Method
get_coupling(instr::Instr{<:AgilentScope}; chan=1)

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope

Keywords

  • chan=1: specific channel

Returns

  • String: "AC" or "DC"
source
TcpInstruments.get_data โ€” Method
get_data(instr::Instr{<:AgilentScope}, ch_vec::Vector{Int}; check_channels=true)
get_data(instr::Instr{<:AgilentScope}, ch::Integer)
get_data(instr::Instr{<:AgilentScope})

Grab data from the specified channel(s). If no channels are specified, data will be grabbed from all available channels

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope
  • ch::Integer: channel number
  • ch_vec::Vector{Int}: vector of channels

Keywords

  • check_channels=true: checks channels

Returns

  • []: data from scope

Throws

  • "Channel is offline, data cannot be read": if channel is offline
source
TcpInstruments.get_data_transfer_format โ€” Method
get_data_transfer_format(instr::Instr{<:AgilentScope})

Gets data transfer format

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope

Returns

  • String: data transfer format
source
TcpInstruments.get_edge_type โ€” Method

getedgetype(scope::Instrument{<:AgilentScope})

Gets edge type

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope

Returns

  • String: POSITIVE, NEGATIVE, EITHER, ALTERNATE
source
TcpInstruments.get_impedance โ€” Method
get_impedance(instr::Instr{<:AgilentScope}; chan::Integer=1)

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope

Keywords

  • chan::Integer=1: specific channel

Returns

  • "FIFT": 50โ„ฆ
  • "ONEM": 1Mโ„ฆ
source
TcpInstruments.get_lpf_state โ€” Method
get_lpf_state(instr::Instr{<:AgilentScope}; chan=1)

See state the internal low-pass filter:

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope

Keywords

  • chan=1: specific channel

Returns

  • String: "0" or "1"
source
TcpInstruments.get_mode โ€” Method
get_mode(scope::Instr{<:AgilentScope})

Get scope mode

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope

Returns

  • String: "NORM" or "AUTO"
source
TcpInstruments.get_time_axis โ€” Method
get_time_axis(scope::Instr{<:AgilentScope})

Gets the horizontal scale or units per divison for the main window

Arguments

  • scope::Instr{<:AgilentScope}: AgilentScope

Returns

  • NamedTuple: With the fields timeperdiv time_offset
source
TcpInstruments.get_trigger โ€” Method
get_trigger(scope::Instrument{<:AgilentScope})

Gets trigger parameters

Arguments

  • scope::Instr{<:AgilentScope}: AgilentScope

Returns

  • `TriggerInfo': Struct of scope mode , trigger level, edge type
source
TcpInstruments.get_trigger_level โ€” Method
get_trigger_level(scope::Instr{<:AgilentScope})

Gets trigger level

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope

Returns

  • Voltage: trigger level
source
TcpInstruments.get_trigger_mode โ€” Method
get_trigger_mode(scope::Instr{<:AgilentScope})

Gets trigger mode

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope

Returns

  • String: "EDGE", "GLITCH", "PATTERN", "TV", "DELAY", "EBURST"
source
TcpInstruments.get_voltage_axis โ€” Method
get_voltage_axis(scope::Instr{<:AgilentScope}, ch_vec::Vector{Int})
get_voltage_axis(scope::Instr{<:AgilentScope}, ch::Int)
get_voltage_axis(scope::Instr{<:AgilentScope})

Gets the vertical scale setting from the specified channel(s). If no channels are specified, vertical scale setting for all channels will be returned

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope
  • channels::Vector{Int}: vector of channel numbers
  • channel::Int: channel number

Returns

  • NamedTuple: per channel with the fields channel scale (Voltage per division) offset (Voltage offset)

Throws

  • "Channel is offline, voltage scale cannot be read": if channel is offline
source
TcpInstruments.get_waveform_info โ€” Method
get_waveform_info(instr::Instr{<:AgilentScope}, ch::Integer)

Grab channel information and return it in a ScopeInfo(@ref) struct

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope
  • ch::Integer: channel

Returns

  • ScopeInfo: Struct of scope information
source
TcpInstruments.lpf_off โ€” Method
lpf_off(instr::Instr{<:AgilentScope}; chan=1)

Turn off an internal low-pass filter.

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope

Keywords

  • chan=1: specific channel
source
TcpInstruments.lpf_on โ€” Method
lpf_on(instr::Instr{<:AgilentScope}; chan=1)

Turn on an internal low-pass filter. When the filter is on, the bandwidth of the specified channel is limited to approximately 25 MHz.

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope

Keywords

  • chan=1: specific channel
source
TcpInstruments.set_acquisition_type โ€” Method
set_acquisition_type(scope::Instr{<:AgilentScope, type::Symbol})

Sets acquisition type to either normal, average, high_res, or peak.

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope
  • type::Symbol: The acquisition type. Must be either :normal, :average, :high_res, or peak.
source
TcpInstruments.set_edge_type โ€” Method
set_edge_type(scope::Instr{<:AgilentScope, edge_type::Symbol})

Sets edge type (slop) to either POSITIVE, NEGATIVE, EITH (either), Alt(alternate)

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope
  • edge_type::String: The edge type. Must be either "POSITIVE", "NEGATIVE", "EITHER", "ALTERNATE",
source
TcpInstruments.set_impedance_1Mohm โ€” Method
set_impedance_1Mohm(instr::Instr{<:AgilentScope}; chan=1)

Set impedance to 1Mโ„ฆ

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope

Keywords

  • chan=1: specific channel
source
TcpInstruments.set_impedance_50ohm โ€” Method
set_impedance_50ohm(instr::Instr{<:AgilentScope}; chan=1)

Set impedance to 50โ„ฆ

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope

Keywords

  • chan=1: specific channel
source
TcpInstruments.set_mode โ€” Method
set_mode(scope::Instrument{<:AgilentScope}, mode::String)

Set scope mode

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope
  • mode::String: "AUTO" or "NORM"
source
TcpInstruments.set_speed_mode โ€” Method

setspeedmode(instr::Instr{<:AgilentScope}, speed::Integer)

Adjust the tradeoff between speed and resolution. This is a wrapper function around the three functions:

  • set_data_transfer_format_16bit(@ref)
  • set_data_transfer_format_8bit(@ref)
  • set_waveform_points_mode(@ref)

Inputs: instr: handle to the connected Agilenst oscilloscope speed: integer of value 1,3,5, or 6, where 1 is slowest and 6 is fastest.

  • 1: 16bit, RAW mode
  • 3: 16bit, NORMAL mode
  • 5: 8bit, RAW mode
  • 6: 8bit, NORMAL mode

Speed 6 corresponds to the Agilent scope normal setting when booting.

source
TcpInstruments.set_time_axis โ€” Method
set_time_axis(scope::Instr{<:AgilentScope}; time_per_div::Unitful.Time, time_offset::Unitful.Time)

Set the horizontal scale or units per division for the main window by setting the time per div and/or time offset

Arguments

  • scope::Instr{<:AgilentScope}: AgilentScope
  • time_per_div::Unitful.Time: Time per division [optional]
  • time_offset::Unitful.Time: Offset time [optional]
source
TcpInstruments.set_trigger โ€” Method
set_trigger(scope::Instrument{<:AgilentScope}; level::Voltage, mode::Symbol, edge::Symbol=:pos)

Set trigger parameters

Arguments

  • scope::Instr{<:AgilentScope}: AgilentScope
  • mode::String: scope mode "NORM" or "AUTO"
  • level::Voltage: voltage to set trigger to

Keywords

  • edge::String: Default value of "POS"
source
TcpInstruments.set_trigger_level โ€” Method
set_trigger_level(scope::Instrument{<:AgilentScope}, level::Voltage)

Sets trigger level

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope
  • 'level::Voltage' : voltage to set trigger level to
source
TcpInstruments.set_trigger_mode โ€” Method
set_trigger_mode(scope::Instr{<:AgilentScope, mode::Symbol})

Sets trigger mode to either EDGE, GLITCH, PATTERN, TV, DELAY, EBURST

Arguments

  • instr::Instr{<:AgilentScope}: AgilentScope
  • mode::String: The trigger mode. Must be either "EDGE", "GLITCH", "PATTERN", "TV", "EBURST". PROGRAMMING GUIDE p. 1308
source
TcpInstruments.set_waveform_num_points โ€” Method
set_waveform_num_points(instr::Instr{<:AgilentScope}, num_points::Integer)

Sets the number of sample points in the voltage trace returned by the scope when using get_data(@ref).

Arguments

  • num_points::Integer: number of sample points.
source
TcpInstruments.set_waveform_points_mode โ€” Method
set_waveform_points_mode(scope, mode)

Set which data to transfer when using get_data(@ref)

Inputs: scope: handle to the connected oscilloscope mode:

  • :NORMAL: transfer the measurement data
  • :RAW: transfer the raw acquisition data
source

Power Supply

TcpInstruments.VersatilePowerSupply โ€” Type

Supported models

  • Versatile2005XRLXI (single channel)
  • Versatile10010XRLXI (single channel)

Supported functions

This instrument has a remote mode and a local mode. Some commands do not work while the device is in local mode, therefore remote_mode is called automatically upon initialization. By default, the device is always in remote mode.

These functions should not be directly needed but if for some reason you need to switch modes while using the device you can use local_mode to turn the device back to local mode.

source

Agilent Power Supply

TcpInstruments.disable_output โ€” Method
disable_output(obj::Instr{<:AgilentPowerSupply})

This will disable an output on a device.

If the device has multiple channels it will disable the device for the currently selected channel. To see the channel that will effected use the get_channel function.

If you want to disable a different channel, first use set_channel to choose the channel. Running this function subsequently will disable that channel

Arguments

  • obj::Instr{<:AgilentPowerSupply}: power supply instrument
source
TcpInstruments.enable_output โ€” Method
enable_output(obj::Instr{<:AgilentPowerSupply})

This will enable an output on a device.

If the device has multiple channels it will enable the device for the currently selected channel. To see the channel that will effected use the get_channel function.

If you want to enable a different channel, first use set_channel to choose the channel. Running this function subsequently will enable that channel

Arguments

  • obj::Instr{<:AgilentPowerSupply}: power supply instrument
source
TcpInstruments.get_channel โ€” Method
get_channel(obj::Instr{<:AgilentPowerSupply}; v=false)

This will return the global or default channel of a device.

Allows you to see what the global channel is set to at the moment

Parameters:

  • obj
    • must be a Power Supply Instrument
  • chan
    • This can be a string or int: 1, 2, 3 .. to n
    where n is the total number of channels
  • v
    • optional boolean flag argument that is set to false
    • setting to true will print the verbose channel name

Supported Instruments:

  • Power supply

Returns: String - {"1"|"2"|...} - when v == true: "P6V", .. etc

source
TcpInstruments.get_current_limit โ€” Method
get_current_limit(obj::Instr{<:AgilentPowerSupply}; chan=0)

This will return the current limit of a device.

Arguments

-obj::Instr{<:AgilentPowerSupply}: Power Supply Instrument

Keywords

  • chan=0: If not provided it will use the default channel (see set_channel) Otherwise this can be a string or int: 1, 2, 3 .. to n where n is the total number of channels

Returns

  • Current Limit
source
TcpInstruments.get_output_status โ€” Method
get_output_status(obj::Instr{<:AgilentPowerSupply})

This will return the state of an output on a device.

If the device has multiple channels is will display the state of the currently selected channel. To see the channel that will read use the get_channel function.

If you want to see the state of a different channel, first use set_channel to choose the channel. Running this function subsequently will disable that channel

Arguments

  • obj::Instr{<:AgilentPowerSupply}: Power Supply Instrument

Returns:

  • String: {"OFF"|"ON"}
source
TcpInstruments.get_voltage โ€” Method
get_voltage(obj::Instr{<:AgilentPowerSupply}; chan=0)

This will return the voltage of a device's channel.

Arguments

  • obj::Instr{<:AgilentPowerSupply}: Power Supply Instrument

Keywords

  • chan=0: If not provided it will use the default channel (see set_channel) Otherwise this can be a string or int: 1, 2, 3 .. to n where n is the total number of channels

Returns:

  • Voltage
source
TcpInstruments.set_channel โ€” Method
set_channel(obj::Instr{<:AgilentPowerSupply}, chan)

This will set the global channel on a device.

Any commands like set_voltage that affect the device with respect to a specific channel will be impacted by this command.

By setting the channel on a device, all subsequent commands will operate on that channel unless they allow for an optional channel argument.

Parameters:

  • obj
    • must be a Power Supply Instrument
  • chan
    • This can be a string or int: 1, 2, 3 .. to n
    where n is the total number of channels

Supported Instruments:

  • Power supply

Returns: Nothing

source
TcpInstruments.set_current_limit โ€” Method
set_current_limit(obj::Instr{<:AgilentPowerSupply}, num::Current; chan=0)

This will change the current limit of a device on a given channel

Arguments

  • obj::Instr{<:AgilentPowerSupply}: Power Supply Instrument
  • num::Current: Desired current limit of type Unitful Amps: 1.0u"A"

Keywords

  • chan=0: If not provided it will use the default channel (see set_channel) Otherwise this can be a string or int: 1, 2, 3 .. to n where n is the total number of channels
source
TcpInstruments.set_voltage โ€” Method
set_voltage(obj::Instr{<:AgilentPowerSupply}, num::Voltage; chan=0)

This will change the voltage output voltage of a device.

Arguments

  • obj::Instr{<:AgilentPowerSupply}: Power Supply Instrument
  • num::Voltage: integer or decimal of the desired voltage

Keywords

  • chan=0: If not provided it will use the default channel (see set_channel) Otherwise this can be a string or int: 1, 2, 3 .. to n where n is the total number of channels
source

SRS Power Supply

This device needs a gpib adapter

As of right now the prologix adapter interface is the only supported adapter.

Connect your power supply to a prologix adapter then initialize using the GPIB_ID keyword argument.

If you do not know the GPIB Channel ID you can initialize your device without that flag. Then run scan_prologix on your device. This will tell you what channel is connected then manually you can use the set_prologix function to set the channel.

TcpInstruments.disable_output โ€” Method
disable_output(obj::Instr{<:SRSPowerSupply})

This will disable an output on a device.

Arguments

  • obj::Instr{<:SRSPowerSupply}: Power Supply Instrument
source
TcpInstruments.enable_output โ€” Method
enable_output(obj::Instr{<:SRSPowerSupply})

This will enable an output on a device.

Arguments

  • obj::Instr{<:SRSPowerSupply}: Power Supply Instrument
source
TcpInstruments.get_current_limit โ€” Method
get_current_limit(obj::Instr{<:SRSPowerSupply})

This will return the current limit of a device.

Arguments

  • obj::Instr{<:SRSPowerSupply}: Power Supply Instrument

Returns

  • Current Limit
source
TcpInstruments.get_output_status โ€” Method
get_output_status(obj::Instr{<:SRSPowerSupply})

This will get and return whether the output from SRSPS310 is enabled.

Arguments

  • obj::Instr{<:SRSPowerSupply}: Power Supply Instrument

Returns

  • String: "ON" if High Voltage Output is On "OFF" if High Voltage Output is Off
source
TcpInstruments.get_voltage โ€” Method
get_voltage(obj::Instr{<:SRSPowerSupply})

This will return the voltage of a device

Voltage Limit: 1250V

Arguments

  • obj::Instr{<:SRSPowerSupply}: Power Supply Instrument

Returns

  • Voltage
source
TcpInstruments.get_voltage_limit โ€” Method
get_voltage_limit(obj::Instr{<:SRSPowerSupply})

This will return the voltage limit of a device

Voltage Limit: 1250V

Arguments

  • obj::Instr{<:SRSPowerSupply}: Power Supply Instrument

Returns

  • Voltage
source
TcpInstruments.set_current_limit โ€” Method
set_current_limit(obj::Instr{<:SRSPowerSupply}, num::Current)

This will change the current limit of a device

MIN Value: 0 Max Value: { 2.1e-3 | 0.021 } (21mA)

Arguments

  • obj::Instr{<:SRSPowerSupply}: Power Supply Instrument
source
TcpInstruments.set_voltage โ€” Method
set_voltage(obj::Instr{<:SRSPowerSupply}, volt::Voltage; [delta_volt::Voltage, delta_time::Time, verbose::Bool])

Sets the output voltage output of a SRSPS310 power supply.

Arguments

  • obj::Instr{<:SRSPowerSupply}: Power Supply Instrument
  • v_end::Voltage: voltage

Keywords

  • delta_volt::Voltage=Inf*u"V": sets the maximum of each voltage step can be used to set the ramping speed when setting a new voltage.
  • delta_time::Time=100u"ms": sets the minimum time between each voltage update can be used to set the ramping speed when setting a new voltage.
  • verbose::Bool=false: when true prints info on ramping speed and steps

Units are handled by the package Unitful.

Currently set voltage limits can read using get_voltage_limit().

Examples:

julia> psu_h = initialize(SRSPS310)
julia> set_voltage(psu_h, 11.1u"V")
julia> set_voltage(psu_h, 1100"mV")
julia> set_voltage(psu_h, 100"V", delta_volt = 2u"V", delta_time=100u"ms", verbose=true)
source
TcpInstruments.set_voltage_limit โ€” Method
set_voltage_limit(::SRSPS310, voltage_limit)

This will change the voltage limit of a device.

Max Voltage Limit: 1250V

Arguments

  • obj::Instr{<:SRSPowerSupply}: Power Supply Instrument
  • num::Voltage: voltage limit
source

Versatile Power Supply

TcpInstruments.disable_output โ€” Method
disable_output(obj::Instr{<:VersatilePowerSupply})

This will disable an output on a device.

Arguments

  • obj::Instr{<:VersatilePowerSupply}: Power Supply Instrument
source
TcpInstruments.enable_output โ€” Method
enable_output(obj::Instr{<:VersatilePowerSupply})

This will enable an output on a device.

Arguments

  • obj::Instr{<:VersatilePowerSupply}: VersatilePowerSupply
source
TcpInstruments.get_current_limit โ€” Method
get_current_limit(obj::Instr{<:VersatilePowerSupply})

This will return the current limit of a device.

Supported Instruments:

  • Power supply

Returns

Current Limit

source
TcpInstruments.get_output_status โ€” Method
get_output_status(obj::Instr{<:VersatilePowerSupply})

This will return the state of an output on a device.

Arguments

  • obj::Instr{<:VersatilePowerSupply}: Power supply instrument

Returns

  • String: {"OFF"|"ON"}
source
TcpInstruments.get_voltage โ€” Method
get_voltage(obj::Instr{<:VersatilePowerSupply})

This will return the voltage of a device

Supported Instruments:

  • Power supply

Returns

Voltage

source
TcpInstruments.set_current_limit โ€” Method
set_current_limit(obj::Instr{<:VersatilePowerSupply}, num::Current)

This will change the current limit of a device

Arguments

  • `obj::Instr{<:VersatilePowerSupply}: Power supply
  • num::Current: current limit
source
TcpInstruments.set_voltage โ€” Method
set_voltage(obj::Instr{<:VersatilePowerSupply}, num::Voltage)

This will change the voltage output of a device.

Supported Instruments:

  • Power supply

Returns

Nothing

source

Waveform Generator

TcpInstruments.Keysight33612A โ€” Type

Supported functions

Not yet implemented

  • get_time_offset
  • set_time_offset

Example for creating a sin wave:

wg = initialize(Keysight33612A, [ip_address])
set_mode_cw(wg)
set_function(wg, "SIN")
set_frequency(wg, 1u"kHz")
set_amplitude(wg, 0.1u"V")
set_voltage_offset(wg, 0u"V")
set_output_on(wg)
source
TcpInstruments.KeysightWaveGen โ€” Type

Supported functions

Not yet implemented

  • get_time_offset
  • set_time_offset

Example for creating a sin wave:

wg = initialize(Keysight33612A, [ip_address])
set_mode_cw(wg)
set_function(wg, "SIN")
set_frequency(wg, 1u"kHz")
set_amplitude(wg, 0.1u"V")
set_voltage_offset(wg, 0u"V")
set_output_on(wg)
source

Keysight Waveform Generator

TcpInstruments.get_amplitude โ€” Method
get_amplitude(wave_gen; chan=1)

Returns the peak to peak voltage for the channel [Vpp]

Arguments

  • obj::Instr{<:KeysightWaveGen}: WaveformGenerator

Keywords

  • chan=1: specific channel
source
TcpInstruments.get_burst_mode โ€” Method
get_burst_mode(instr)
get_burst_mode(instr; chan=1)

Returns the burst mode of a device: "TRIG" ~ If the device is in Triggered Mode "GAT" ~ If the device is in Gated Mode

source
TcpInstruments.get_burst_num_cycles โ€” Method
get_burst_num_cycles(instr)
get_burst_num_cycles(instr; chan=2)

Arguments

  • obj::Instr{<:KeysightWaveGen}: KeysightWaveGen

Keywords

  • chan=1: specific channel

Returns

  • Float64: number of cycles burst mode is set to
source
TcpInstruments.get_burst_period โ€” Method
get_burst_period(instr; chan=1)

Get burst period

Arguments

  • obj::Instr{<:KeysightWaveGen}: KeysightWaveGen

Keywords

  • chan::Integer=1: specific channel

Returns

  • Float64: time between bursts [s]
source
TcpInstruments.get_frequency โ€” Method
get_frequency(wave_gen; chan=1)

Returns the signal frequency for the channel [Hz]

Arguments

  • obj::Instr{<:KeysightWaveGen}: KeysightWaveGen

Returns

  • Float64: signal frequency for the channel [Hz]
source
TcpInstruments.get_function โ€” Method
get_function(instr)
get_function(instr; chan=2)

Keywords

  • chan: Specify channel: Default is 1

Returns

  • String: Will return one of these shortened forms:

{SINusoid|SQUare|TRIangle|RAMP|PULSe|PRBS|NOISe|ARB|DC}

source
TcpInstruments.get_mode โ€” Method
get_mode(instr)
get_mode(instr; chan=1)

Gets mode of KeysightWaveGen instrument

Arguments

  • obj::Instr{<:KeysightWaveGen}: WaveformGenerator

Keywords

  • chan=1: specific chanel

Returns

  • CW: if device is in continous wavefrom mode
  • BURST: if device is in BURST mode
source
TcpInstruments.get_voltage_offset โ€” Method
get_voltage_offset(wave_gen; chan=1)

Returns the voltage offset for the channel [V]

Arguments

  • obj::Instr{<:KeysightWaveGen}: WaveformGenerator

Keywords

  • chan=1: specific channel
source
TcpInstruments.set_amplitude โ€” Method
set_amplitude(wave_gen; chan=1)

Set the peak to peak voltage for the channel [Vpp]

Arguments

  • obj::Instr{<:KeysightWaveGen}: WaveformGenerator
  • num::Voltage: peak voltage for the channel

Keywords

  • chan=1: specific channel
source
TcpInstruments.set_burst_num_cycles โ€” Method
set_burst_num_cycles(instr, cycles)
set_burst_num_cycles(instr, cycles; chan=2)

Sets the number of cycles for burst mode

Arguments

  • obj::Instr{<:KeysightWaveGen}: KeysightWaveGen
  • num: number of cycles for burst mode

Keywords

  • chan=1: specific channel
source
TcpInstruments.set_burst_period โ€” Method
set_burst_period(obj, duration; chan=1)

Sets burst period for KeysightWaveGen instrument

Arguments

  • obj::Instr{<:KeysightWaveGen}: KeysightWaveGen
  • duration: The number of seconds (This value can also be "MIN" or "MAX")

Keywords

  • chan::Integer=1: specific channel
source
TcpInstruments.set_frequency โ€” Method
set_frequency(wave_gen; chan=1)

Set the signal frequency for the channel [Hz]

Arguments

  • obj::Instr{<:KeysightWaveGen}: WaveformGenerator
  • num::Frequency: signal frequency for the channel

Keywords

  • chan=1: specific channel
source
TcpInstruments.set_function โ€” Method
set_function(instr, func; chan=1)

Arguments

  • func::String: Acceptable inputs:

{SINusoid|SQUare|TRIangle|RAMP|PULSe|PRBS|NOISe|ARB|DC}

Keywords

  • chan: Specify channel: Default is 1
source
TcpInstruments.set_mode_burst โ€” Method
    set_mode_burst(obj::Instr{<:KeysightWaveGen})

Changes Waveform Generator mode from continous waveform to burst

By default it sets the type of burst mode to triggered mode. Gated mode can also be set by using the optional flag:

    set_mode_burst(instr; mode=:gated)

The optional trig_src flag sets the trigger source for burst triggered mode. Right now the default is Timer. To implement more trigger sources see page 130 of the manual for 33612A

Arguments

  • obj::Instr{<:KeysightWaveGen}: WaveformGenerator
source
TcpInstruments.set_mode_cw โ€” Method
set_mode_cw(instr)
set_mode_cw(instr; chan=1)

Puts the device in continuous waveform/turns off burst mode

Arguments

  • obj::Instr{<:KeysightWaveGen}: KeysightWaveGen

Keywords

  • chan=1: Specify channel
source
TcpInstruments.set_output_off โ€” Method
set_output_off(wave_gen; chan=1)

Deactivate the front panel output connector

Arguments

  • obj::Instr{<:KeysightWaveGen}: KeysightWaveGen

Keywords

  • chan=1: specific channel
source
TcpInstruments.set_output_on โ€” Method
set_output_on(wave_gen; chan=1)

Activate the front panel output connector

Arguments

  • obj::Instr{<:KeysightWaveGen}: KeysightWaveGen
source
TcpInstruments.set_voltage_offset โ€” Method
set_voltage_offset(wave_gen; chan=1)

Set the voltage offset for the channel [V]

Arguments

  • obj::Instr{<:KeysightWaveGen}: WaveformGenerator
  • num::Voltage: voltage offset

Keywords

  • chan: Specify channel: Default is 1
source

SourceMeasureUnit

Agilent SourceMeasureUnit

TcpInstruments.disable_autorange โ€” Method
disable_autorange(obj::Instr{<:AgilentSourceMeasureUnit}; source="voltage", channel::Integer=1)

This will disable an output channel's automatic ranging. If automatic ranging disabled, the source output is performed using the range set [SOURce]:<CURRent|VOLTage>:RANGe command.

Arguments

  • obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • source::String="voltage": source output
  • channel::Integer=1: specific channel
source
TcpInstruments.disable_output โ€” Method
disable_output(obj::Instr{<:AgilentSourceMeasureUnit}; channel::Integer=1)

This will disable an output channel of a device.

Arguments

  • (obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • channel::Integer=1: specific channel
source
TcpInstruments.enable_autorange โ€” Method
enable_autorange(obj::Instr{<:AgilentSourceMeasureUnit}; source="voltage", channel::Integer=1)

This will enable an output channel's automatic ranging.

Arguments

  • obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • source::String="voltage": source output
  • channel::Integer=1: specific channel
source
TcpInstruments.enable_output โ€” Method
enable_output(obj::Instr{<:AgilentSourceMeasureUnit}; channel::Integer=1)

This will enable an output channel of a device.

Arguments

  • (obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • channel::Integer=1: specific channel
source
TcpInstruments.get_measurement โ€” Method
get_measurement(obj::Instr{<:AgilentSourceMeasureUnit}; channel::Integer=1)

Get measurement stored by start_measurement(). Returns voltage, current, resistance, and time.

Arguments

  • obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • channel::Integer=1: specific channel

Returns

  • SourceMeasureUnitData: measurement data from AgilentSourceMeasureUnit
source
TcpInstruments.get_source โ€” Method
get_source_mode(obj::Instr{<:AgilentSourceMeasureUnit}; channel::Integer=1)

This will get the selected channel's source output mode.

Arguments

  • (obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

=- channel::Integer=1: specific channel

source
TcpInstruments.get_source_mode โ€” Method
get_source_mode(obj::Instr{<:AgilentSourceMeasureUnit}; source::String="voltage", channel::Integer=1)

This will get a source channel mode.

Arguments

  • obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • source::String="voltage": source
  • channel::Integer=1: specfic channel

Returns

  • Source Mode
source
TcpInstruments.set_current_limit โ€” Function
set_current_limit(obj::Instr{<:AgilentSourceMeasureUnit}, current="default"; channel::Integer=1)

This will set the selected channel's output current limit. The limit is applied to both positive and negative current.

Arguments

  • (obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • current="default": current limit
  • channel::Integer=1: specific channel
source
TcpInstruments.set_current_output โ€” Function
set_current_output(obj::Instr{<:AgilentSourceMeasureUnit}, current="default"; channel::Integer=1)

This will set the selected channel's output current.

Arguments

  • (obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • current="default": current limit
  • channel::Integer=1: specific channel
source
TcpInstruments.set_current_sweep_parameters โ€” Method
set_current_sweep_parameters(obj::Instr{<:AgilentSourceMeasureUnit};
start="default",
stop="default",
step="default",
channel::Integer=1)

This will set a channel's current source start, stop, step, and trigger point value for sweep output. points = span/step + 1 (where step is not 0) span = stop - start

Arguments

  • obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • start="default": channel's current court start
  • stop="default": channel's current court stop
  • step="default": channel's current court step
  • channel::Integer=1: specific channel
source
TcpInstruments.set_measurement_duration โ€” Method
set_measurement_duration(obj::Instr{<:AgilentSourceMeasureUnit}; aperture="default", channel::Integer=1)

This will set an output channel's integration time for one point measurement. Measurement type is not important since time value is common for voltage, current, and resistance. If value set is less than MIN or greater than MAX, time is automatically set to MIN or MAX.

Arguments

  • obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • aperture="default": measurement type
  • channel::Integer=1: specific channel
source
TcpInstruments.set_measurement_mode โ€” Method
set_measurement_mode(obj::Instr{<:AgilentSourceMeasureUnit};
chan= 1, current=false, voltage=false, resistance=false
)

This will enable the selected channel's specified measurement functions. Enabling resistance will enable voltage and current measurement modes as well.

Arguments

  • obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • voltage=false: does not enable channel's specified functions
  • current=false: does not enable channel's specified functions
  • resistance=false: does not enable channel's specified functions
  • channel::Integer=1: specfic channel
source
TcpInstruments.set_measurement_range โ€” Method
set_measurement_range(obj::Instr{<:AgilentSourceMeasureUnit}, range; channel::Integer=1)

This will set an output channel's measurement range.

Arguments

  • obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit
  • range: range for channel's measurement

Keywords

  • channel::Integer=1: specific channel
source
TcpInstruments.set_measurement_range โ€” Method
set_measurement_range(obj::Instr{<:AgilentSourceMeasureUnit}; measurement::String="voltage", range="default", channel::Integer=1)

This will set an output channel's measurement range.

Arguments

  • obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • measurement::String="voltage": measurement type
  • range::String="default"`: range for channel's measurement
  • channel::Integer=1: specific channel
source
TcpInstruments.set_source โ€” Method
set_source(obj::Instr{<:AgilentSourceMeasureUnit}; source="voltage", channel::Integer=1)

This will set the selected channel's source output mode.

Arguments

  • (obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • source::String="voltage"": channel's output mode
  • channel::Integer=1: specific channel
source
TcpInstruments.set_source_mode โ€” Method
set_source_mode(obj::Instr{<:AgilentSourceMeasureUnit}; source::String="voltage", mode="fixed", channel::Integer=1)

This will set a source channel mode.

Arguments

  • obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • source::String="voltage": source
  • mode::String="fixed": mode
  • channel::Integer=1: specific channel
source
TcpInstruments.set_voltage_limit โ€” Function
set_voltage_limit(obj::Instr{<:AgilentSourceMeasureUnit}, voltage="default"; channel::Integer=1)

This will set the selected channel's output current limit. The limit is applied to both positive and negative voltage.

Arguments

  • (obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • voltage="default": voltage limit
  • channel::Integer=1: specific channel
source
TcpInstruments.set_voltage_output โ€” Function
set_voltage_output(obj::Instr{<:AgilentSourceMeasureUnit}, voltage="default"; channel::Integer=1)

This will set the selected channel's output voltage.

Arguments

  • (obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • voltage="default": channel's output voltage
  • channel::Integer=1: specific channel
source
TcpInstruments.set_voltage_sweep_parameters โ€” Method
set_voltage_sweep_parameters(obj::Instr{<:AgilentSourceMeasureUnit};
start="default",
stop="default",
step="default",
channel::Integer=1)

This will set a channel's voltage source start, stop, step, and trigger point value for sweep output. points = span/step + 1 (where step is not 0) span = stop - start

Arguments

  • obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit
source
TcpInstruments.spot_measurement โ€” Method
spot_measurement(obj::Instr{<:AgilentSourceMeasureUnit}, measurement::String="voltage"; channel::Integer=1)

Executes a spot (one-shot) measurement and returns the measurement result data.

Arguments

  • obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • measurement::String: measurement
  • channel::Integer=1: specific channel

Returns

  • attach_unit!: measurement result data
source
TcpInstruments.spot_measurement โ€” Method
spot_measurement(obj::Instr{<:AgilentSourceMeasureUnit}; channel::Integer=1)

Executes a spot (one-shot) measurement and returns valid voltage, current, and resistance if type is not specified.

Arguments

  • obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • channel::Integer=1: specific channel

Returns

  • Array: valid voltage, current, and resistance if type is not specified
source
TcpInstruments.start_measurement โ€” Method
start_measurement(obj::Instr{<:AgilentSourceMeasureUnit}; channel::Integer=1)

Initiates the specified device action for the specified channel. Trigger status is changed from idle to initiated. Adjust voltage and current limit if necessary.

Arguments

  • obj::Instr{<:AgilentSourceMeasureUnit}: AgilentSourceMeasureUnit

Keywords

  • channel::Integer=1: specific channel
source