This is the base instrument class from which all others are derived from. It provides the basic implementation for all communication related tasks. In addition, it also contains several class methods for opening connections via the supported hardware channels.

binblockread(data_width, fmt=None)¶

” Read a binary data block from attached instrument. This requires that the instrument respond in a particular manner as EOL terminators naturally can not be used in binary transfers.

The format is as follows: #{number of following digits:1-9}{num of bytes to be read}{data bytes}

Parameters:	data_width (int) – Specify the number of bytes wide each data point is. One of [1,2,4]. fmt (str) – Format string as specified by the struct module, or None to choose a format automatically based on the data width. Typically you can just specify data_width and leave this default.

classmethod open_file(filename)¶

Given a file, treats that file as a character device file that can be read from and written to in order to communicate with the instrument. This may be the case, for instance, if the instrument is connected by the Linux usbtmc kernel driver.

Parameters:	filename (str) – Name of the character device to open.
Return type:	Instrument
Returns:	Object representing the connected instrument.

classmethod open_from_uri(uri)¶

Given an instrument URI, opens the instrument named by that URI. Instrument URIs are formatted with a scheme, such as serial://, followed by a location that is interpreted differently for each scheme. The following examples URIs demonstrate the currently supported schemes and location formats:

serial://COM3
serial:///dev/ttyACM0
tcpip://192.168.0.10:4100
gpib+usb://COM3/15
gpib+serial://COM3/15
gpib+serial:///dev/ttyACM0/15 # Currently non-functional.
visa://USB::0x0699::0x0401::C0000001::0::INSTR
usbtmc://USB::0x0699::0x0401::C0000001::0::INSTR

For the serial URI scheme, baud rates may be explicitly specified using the query parameter baud=, as in the example serial://COM9?baud=115200. If not specified, the baud rate is assumed to be 115200.

Parameters:	uri (str) – URI for the instrument to be loaded.
Return type:	Instrument

See also

PySerial documentation for serial port URI format

classmethod open_gpibethernet(host, port, gpib_address)¶

Warning

The GPIB-Ethernet adapter that this connection would use does not actually exist, and thus this class method should not be used.

classmethod open_gpibusb(port, gpib_address, timeout=3, write_timeout=3)¶

Opens an instrument, connecting via a Galvant Industries GPIB-USB adapter.

Parameters:	port (str) – Name of the the port or device file to open a connection on. Note that because the GI GPIB-USB adapter identifies as a serial port to the operating system, this should be the name of a serial port. gpib_address (int) – Address on the connected GPIB bus assigned to the instrument. timeout (float) – Number of seconds to wait when reading from the instrument before timing out. write_timeout (float) – Number of seconds to wait when writing to the instrument before timing out.
Return type:	Instrument
Returns:	Object representing the connected instrument.

See also

Serial for description of port and timeouts.

classmethod open_serial(port, baud, timeout=3, write_timeout=3)¶

Opens an instrument, connecting via a physical or emulated serial port. Note that many instruments which connect via USB are exposed to the operating system as serial ports, so this method will very commonly be used for connecting instruments via USB.

Parameters:	port (str) – Name of the the port or device file to open a connection on. For example, "COM10" on Windows or "/dev/ttyUSB0" on Linux. baud (int) – The baud rate at which instrument communicates. timeout (float) – Number of seconds to wait when reading from the instrument before timing out. write_timeout (float) – Number of seconds to wait when writing to the instrument before timing out.
Return type:	Instrument
Returns:	Object representing the connected instrument.

See also

Serial for description of port, baud rates and timeouts.

classmethod open_tcpip(host, port)¶

Opens an instrument, connecting via TCP/IP to a given host and TCP port.

Parameters:	host (str) – Name or IP address of the instrument. port (int) – TCP port on which the insturment is listening.
Return type:	Instrument
Returns:	Object representing the connected instrument.

See also

connect for description of host and port parameters in the TCP/IP address family.

classmethod open_test(stdin=None, stdout=None)¶

Opens an instrument using a loopback communicator for a test connection. The primary use case of this is to instantiate a specific instrument class without requiring an actual physical connection of any kind. This is also very useful for creating unit tests through the parameters of this class method.

Parameters:	stdin (io.BytesIO or None) – The stream of data coming from the instrument stdout (io.BytesIO or None) – Empty data stream that will hold data sent from the Python class to the loopback communicator. This can then be checked for the contents.
Returns:	Object representing the virtually-connected instrument

classmethod open_usb(vid, pid)¶

Opens an instrument, connecting via a raw USB stream.

Note

Note that raw USB a very uncommon of connecting to instruments, even for those that are connected by USB. Most will identify as either serial ports (in which case, open_serial should be used), or as USB-TMC devices. On Linux, USB-TMC devices can be connected using open_file, provided that the usbtmc kernel module is loaded. On Windows, some such devices can be opened using the VISA library and the open_visa method.

Parameters:	vid (str) – Vendor ID of the USB device to open. pid (int) – Product ID of the USB device to open.
Return type:	Instrument
Returns:	Object representing the connected instrument.

classmethod open_usbtmc(*args, **kwargs)¶

Opens an instrument, connecting to a USB-TMC device using the Python usbtmc library.

Warning

The operational status of this is unknown. It is suggested that you connect via the other provided class methods. For Linux, if you have the usbtmc kernel module, the open_file class method will work. On Windows, using the open_visa class method along with having the VISA libraries installed will work.

Returns:	Object representing the connected instrument

classmethod open_visa(resource_name)¶

Opens an instrument, connecting using the VISA library. Note that PyVISA and a VISA implementation must both be present and installed for this method to function.

Parameters:	resource_name (str) – Name of a VISA resource representing the given instrument.
Return type:	Instrument
Returns:	Object representing the connected instrument.

See also

National Instruments help page on VISA resource names.

classmethod open_vxi11(*args, **kwargs)¶

Opens a vxi11 enabled instrument, connecting using the python library python-vxi11. This package must be present and installed for this method to function.

Return type:	Instrument
Returns:	Object representing the connected instrument.

query(cmd, size=-1)¶

Executes the given query.

Parameters:	cmd (str) – String containing the query to execute. size (int) – Number of bytes to be read. Default is read until termination character is found.
Returns:	The result of the query as returned by the connected instrument.
Return type:	str

read(size=-1)¶

Read the last line.

Parameters:	size (int) – Number of bytes to be read. Default is read until termination character is found.
Returns:	The result of the read as returned by the connected instrument.
Return type:	str

sendcmd(cmd)¶

Sends a command without waiting for a response.

Parameters:	cmd (str) – String containing the command to be sent.

write(msg)¶

Write data string to the connected instrument. This will call the write method for the attached filelike object. This will typically bypass attaching any termination characters or other communication channel related work.

See also

Instrument.sendcmd if you wish to send a string to the

instrument, while still having InstrumentKit handle termination characters and other communication channel related work.

Parameters:	msg (str) – String that will be written to the filelike object (Instrument._file) attached to this instrument.

URI_SCHEMES = [u'serial', u'tcpip', u'gpib+usb', u'gpib+serial', u'visa', u'file', u'usbtmc', u'vxi11']¶

address¶

Gets/sets the target communication of the instrument.

This is useful for situations when running straight from a Python shell and your instrument has enumerated with a different address. An example when this can happen is if you are using a USB to Serial adapter and you disconnect/reconnect it.

Type:	int for GPIB address, str for other

prompt¶

Gets/sets the prompt used for communication.

The prompt refers to a character that is sent back from the instrument after it has finished processing your last command. Typically this is used to indicate to an end-user that the device is ready for input when connected to a serial-terminal interface.

In IK, the prompt is specified that that it (and its associated termination character) are read in. The value read in from the device is also checked against the stored prompt value to make sure that everything is still in sync.

Type:	str

terminator¶

Gets/sets the terminator used for communication.

For communication options where this is applicable, the value corresponds to the ASCII character used for termination in decimal format. Example: 10 sets the character to NEWLINE.

Type:	int, or str for GPIB adapters.

timeout¶

Gets/sets the communication timeout for this instrument. Note that setting this value after opening the connection is not supported for all connection types.

Type:	int

Abstract base class for multimeter instruments.

All applicable concrete instruments should inherit from this ABC to provide a consistent interface to the user.

measure(mode)¶

Perform a measurement as specified by mode parameter.

input_range¶

Gets/sets the current input range setting of the multimeter. This is an abstract method.

Type:	Quantity or Enum

mode¶

Gets/sets the measurement mode for the multimeter. This is an abstract method.

Type:	Enum

relative¶

Gets/sets the status of relative measuring mode for the multimeter. This is an abstract method.

Type:	bool

trigger_mode¶

Gets/sets the trigger mode for the multimeter. This is an abstract method.

Type:	Enum

Abstract base class for function generator instruments.

All applicable concrete instruments should inherit from this ABC to provide a consistent interface to the user.

class Function¶

Enum containg valid output function modes for many function generators

arbitrary = <Function.arbitrary: 'ARB'>¶

noise = <Function.noise: 'NOIS'>¶

ramp = <Function.ramp: 'RAMP'>¶

sinusoid = <Function.sinusoid: 'SIN'>¶

square = <Function.square: 'SQU'>¶

triangle = <Function.triangle: 'TRI'>¶

class FunctionGenerator.VoltageMode¶

Enum containing valid voltage modes for many function generators

dBm = <VoltageMode.dBm: 'DBM'>¶

peak_to_peak = <VoltageMode.peak_to_peak: 'VPP'>¶

rms = <VoltageMode.rms: 'VRMS'>¶

FunctionGenerator.amplitude¶

Gets/sets the output amplitude of the function generator.

If set with units of \(\text{dBm}\), then no voltage mode can be passed.

If set with units of \(\text{V}\) as a Quantity or a float without a voltage mode, then the voltage mode is assumed to be peak-to-peak.

Units:	As specified, or assumed to be \(\text{V}\) if not specified.
Type:	Either a tuple of a Quantity and a FunctionGenerator.VoltageMode, or a Quantity if no voltage mode applies.

FunctionGenerator.frequency¶

Gets/sets the the output frequency of the function generator. This is an abstract property.

Type:	Quantity

FunctionGenerator.function¶

Gets/sets the output function mode of the function generator. This is an abstract property.

Type:	Enum

FunctionGenerator.offset¶

Gets/sets the output offset voltage of the function generator. This is an abstract property.

Type:	Quantity

FunctionGenerator.phase¶

Gets/sets the output phase of the function generator. This is an abstract property.

Type:	Quantity

Python abstract base class for signal generators (eg microwave sources).

This ABC is not for function generators, which have their own separate ABC.

channel¶

Gets a specific channel object for the SignalGenerator.

Return type:	A class inherited from SGChannel

Class for representing a Signal Generator that only has a single output channel. The sole property in this class allows for the user to use the API for SGs with multiple channels and a more compact form since it only has one output.

For example, both of the following calls would work the same:

>>> print sg.channel[0].freq # Multi-channel style
>>> print sg.freq # Compact style

channel¶

Python abstract base class representing a single channel for a signal generator.

frequency¶

Gets/sets the output frequency of the signal generator channel

Type:	Quantity

output¶

Gets/sets the output status of the signal generator channel

Type:	bool

phase¶

Gets/sets the output phase of the signal generator channel

Type:	Quantity

power¶

Gets/sets the output power of the signal generator channel

Type:	Quantity

Base class for all SCPI-compliant instruments. Inherits from from Instrument.

This class does not implement any instrument-specific communication commands. What it does add is several of the generic SCPI star commands. This includes commands such as *IDN?, *OPC?, and *RST.

Example usage:

>>> import instruments as ik
>>> inst = ik.generic_scpi.SCPIInstrument.open_tcpip('192.168.0.2', 8888)
>>> print(inst.name)

class ErrorCodes¶

Enumeration describing error codes as defined by SCPI 1999.0. Error codes that are equal to 0 mod 100 are defined to be generic.

block_data_error = <ErrorCodes.block_data_error: -160>¶

block_data_not_allowed = <ErrorCodes.block_data_not_allowed: -168>¶

character_data_error = <ErrorCodes.character_data_error: -140>¶

character_data_not_allowed = <ErrorCodes.character_data_not_allowed: -148>¶

character_data_too_long = <ErrorCodes.character_data_too_long: -144>¶

command_error = <ErrorCodes.command_error: -100>¶

command_header_error = <ErrorCodes.command_header_error: -110>¶

data_type_error = <ErrorCodes.data_type_error: -104>¶

exponent_too_large = <ErrorCodes.exponent_too_large: -123>¶

expression_error = <ErrorCodes.expression_error: -170>¶

expression_not_allowed = <ErrorCodes.expression_not_allowed: -178>¶

get_not_allowed = <ErrorCodes.get_not_allowed: -105>¶

header_separator_error = <ErrorCodes.header_separator_error: -111>¶

header_suffix_out_of_range = <ErrorCodes.header_suffix_out_of_range: -114>¶

invalid_block_data = <ErrorCodes.invalid_block_data: -161>¶

invalid_character = <ErrorCodes.invalid_character: -101>¶

invalid_character_data = <ErrorCodes.invalid_character_data: -141>¶

invalid_character_in_number = <ErrorCodes.invalid_character_in_number: -121>¶

invalid_expression = <ErrorCodes.invalid_expression: -171>¶

invalid_inside_macro_definition = <ErrorCodes.invalid_inside_macro_definition: -183>¶

invalid_outside_macro_definition = <ErrorCodes.invalid_outside_macro_definition: -181>¶

invalid_separator = <ErrorCodes.invalid_separator: -103>¶

invalid_string_data = <ErrorCodes.invalid_string_data: -151>¶

invalid_suffix = <ErrorCodes.invalid_suffix: -131>¶

macro_error = <ErrorCodes.macro_error: -180>¶

macro_parameter_error = <ErrorCodes.macro_parameter_error: -184>¶

missing_parameter = <ErrorCodes.missing_parameter: -109>¶

no_error = <ErrorCodes.no_error: 0>¶

numeric_data_error = <ErrorCodes.numeric_data_error: -120>¶

numeric_data_not_allowed = <ErrorCodes.numeric_data_not_allowed: -128>¶

operation_complete = <ErrorCodes.operation_complete: -800>¶

parameter_not_allowed = <ErrorCodes.parameter_not_allowed: -108>¶

power_on = <ErrorCodes.power_on: -500>¶

program_mnemonic_too_long = <ErrorCodes.program_mnemonic_too_long: -112>¶

request_control_event = <ErrorCodes.request_control_event: -700>¶

string_data_error = <ErrorCodes.string_data_error: -150>¶

string_data_not_allowed = <ErrorCodes.string_data_not_allowed: -158>¶

suffix_error = <ErrorCodes.suffix_error: -130>¶

suffix_not_allowed = <ErrorCodes.suffix_not_allowed: -138>¶

suffix_too_long = <ErrorCodes.suffix_too_long: -134>¶

syntax_error = <ErrorCodes.syntax_error: -102>¶

too_many_digits = <ErrorCodes.too_many_digits: -124>¶

undefined_header = <ErrorCodes.undefined_header: -113>¶

unexpected_number_of_parameters = <ErrorCodes.unexpected_number_of_parameters: -115>¶

user_request_event = <ErrorCodes.user_request_event: -600>¶

SCPIInstrument.check_error_queue()¶

Checks and clears the error queue for this device, returning a list of SCPIInstrument.ErrorCodes or int elements for each error reported by the connected instrument.

SCPIInstrument.clear()¶

Clear instrument. Consult manual for specifics related to that instrument.

SCPIInstrument.reset()¶

Reset instrument. On many instruments this is a factory reset and will revert all settings to default.

SCPIInstrument.trigger()¶

Send a software trigger event to the instrument. On most instruments this will cause some sort of hardware event to start. For example, a multimeter might take a measurement.

This software trigger usually performs the same action as a hardware trigger to your instrument.

SCPIInstrument.wait_to_continue()¶

Instruct the instrument to wait until it has completed all received commands before continuing.

SCPIInstrument.display_brightness¶

Brightness of the display on the connected instrument, represented as a float ranging from 0 (dark) to 1 (full brightness).

Type:	float

SCPIInstrument.display_contrast¶

Contrast of the display on the connected instrument, represented as a float ranging from 0 (no contrast) to 1 (full contrast).

Type:	float

SCPIInstrument.line_frequency¶

Gets/sets the power line frequency setting for the instrument.

Returns:	The power line frequency
Units:	Hertz
Type:	Quantity

SCPIInstrument.name¶

The name of the connected instrument, as reported by the standard SCPI command *IDN?.

Return type:	str

SCPIInstrument.op_complete¶

Check if all operations sent to the instrument have been completed.

Return type:	bool

SCPIInstrument.power_on_status¶

Gets/sets the power on status for the instrument.

Type:	bool

SCPIInstrument.scpi_version¶

Returns the version of the SCPI protocol supported by this instrument, as specified by the SYST:VERS? command described in section 21.21 of the SCPI 1999 standard.

SCPIInstrument.self_test_ok¶

Gets the results of the instrument’s self test. This lets you check if the self test was sucessful or not.

Return type:	bool

This class is used for communicating with generic SCPI-compliant multimeters.

Example usage:

>>> import instruments as ik
>>> inst = ik.generic_scpi.SCPIMultimeter.open_tcpip("192.168.1.1")
>>> print(inst.measure(inst.Mode.resistance))

class InputRange¶

Valid device range parameters outside of directly specifying the range.

automatic = <InputRange.automatic: 'AUTO'>¶

default = <InputRange.default: 'DEF'>¶

maximum = <InputRange.maximum: 'MAX'>¶

minimum = <InputRange.minimum: 'MIN'>¶

class SCPIMultimeter.Mode¶

Enum of valid measurement modes for (most) SCPI compliant multimeters

capacitance = <Mode.capacitance: 'CAP'>¶

continuity = <Mode.continuity: 'CONT'>¶

current_ac = <Mode.current_ac: 'CURR:AC'>¶

current_dc = <Mode.current_dc: 'CURR:DC'>¶

diode = <Mode.diode: 'DIOD'>¶

fourpt_resistance = <Mode.fourpt_resistance: 'FRES'>¶

frequency = <Mode.frequency: 'FREQ'>¶

period = <Mode.period: 'PER'>¶

resistance = <Mode.resistance: 'RES'>¶

temperature = <Mode.temperature: 'TEMP'>¶

voltage_ac = <Mode.voltage_ac: 'VOLT:AC'>¶

voltage_dc = <Mode.voltage_dc: 'VOLT:DC'>¶

class SCPIMultimeter.Resolution¶

Valid measurement resolution parameters outside of directly the resolution.

default = <Resolution.default: 'DEF'>¶

maximum = <Resolution.maximum: 'MAX'>¶

minimum = <Resolution.minimum: 'MIN'>¶

class SCPIMultimeter.SampleCount¶

Valid sample count parameters outside of directly the value.

default = <SampleCount.default: 'DEF'>¶

maximum = <SampleCount.maximum: 'MAX'>¶

minimum = <SampleCount.minimum: 'MIN'>¶

class SCPIMultimeter.SampleSource¶

Valid sample source parameters.

1. “immediate”: The trigger delay time is inserted between successive

   samples. After the first measurement is completed, the instrument waits the time specified by the trigger delay and then performs the next sample.

2. “timer”: Successive samples start one sample interval after the

   START of the previous sample.

immediate = <SampleSource.immediate: 'IMM'>¶

timer = <SampleSource.timer: 'TIM'>¶

class SCPIMultimeter.TriggerCount¶

Valid trigger count parameters outside of directly the value.

default = <TriggerCount.default: 'DEF'>¶

infinity = <TriggerCount.infinity: 'INF'>¶

maximum = <TriggerCount.maximum: 'MAX'>¶

minimum = <TriggerCount.minimum: 'MIN'>¶

class SCPIMultimeter.TriggerMode¶

Valid trigger sources for most SCPI Multimeters.

“Immediate”: This is a continuous trigger. This means the trigger signal is always present.

“External”: External TTL pulse on the back of the instrument. It is active low.

“Bus”: Causes the instrument to trigger when a *TRG command is sent by software. This means calling the trigger() function.

bus = <TriggerMode.bus: 'BUS'>¶

external = <TriggerMode.external: 'EXT'>¶

immediate = <TriggerMode.immediate: 'IMM'>¶

SCPIMultimeter.measure(mode=None)¶

Instruct the multimeter to perform a one time measurement. The instrument will use default parameters for the requested measurement. The measurement will immediately take place, and the results are directly sent to the instrument’s output buffer.

Method returns a Python quantity consisting of a numpy array with the instrument value and appropriate units. If no appropriate units exist, (for example, continuity), then return type is float.

Parameters:	mode (Mode) – Desired measurement mode. If set to None, will default to the current mode.

SCPIMultimeter.input_range¶

Gets/sets the device input range for the device range for the currently set multimeter mode.

Example usages:

>>> dmm.input_range = dmm.InputRange.automatic
>>> dmm.input_range = 1 * pq.millivolt

Units:	As appropriate for the current mode setting.
Type:	Quantity, or InputRange

SCPIMultimeter.mode¶

Gets/sets the current measurement mode for the multimeter.

Example usage:

>>> dmm.mode = dmm.Mode.voltage_dc

Type:	Mode

SCPIMultimeter.relative¶

SCPIMultimeter.resolution¶

Gets/sets the measurement resolution for the multimeter. When specified as a float it is assumed that the user is providing an appropriate value.

Example usage:

>>> dmm.resolution = 3e-06
>>> dmm.resolution = dmm.Resolution.maximum

Type:	int, float or Resolution

SCPIMultimeter.sample_count¶

Gets/sets the number of readings (samples) that the multimeter will take per trigger event.

The time between each measurement is defined with the sample_timer property.

Note that if the trigger_count propery has been changed, the number of readings taken total will be a multiplication of sample count and trigger count (see property SCPIMulimeter.trigger_count).

If specified as a SampleCount value, the following options apply:

1. “minimum”: 1 sample per trigger
2. “maximum”: Maximum value as per instrument manual
3. “default”: Instrument default as per instrument manual

Note that when using triggered measurements, it is recommended that you disable autorange by either explicitly disabling it or specifying your desired range.

Type:	int or SampleCount

SCPIMultimeter.sample_source¶

Gets/sets the multimeter sample source. This determines whether the trigger delay or the sample timer is used to dtermine sample timing when the sample count is greater than 1.

In both cases, the first sample is taken one trigger delay time period after the trigger event. After that, it depends on which mode is used.

Type:	SCPIMultimeter.SampleSource

SCPIMultimeter.sample_timer¶

Gets/sets the sample interval when the sample counter is greater than one and when the sample source is set to timer (see SCPIMultimeter.sample_source).

This command does not effect the delay between the trigger occuring and the start of the first sample. This trigger delay is set with the trigger_delay property.

Units:	As specified, or assumed to be of units seconds otherwise.
Type:	Quantity

SCPIMultimeter.trigger_count¶

Gets/sets the number of triggers that the multimeter will accept before returning to an “idle” trigger state.

Note that if the sample_count propery has been changed, the number of readings taken total will be a multiplication of sample count and trigger count (see property SCPIMulimeter.sample_count).

If specified as a TriggerCount value, the following options apply:

1. “minimum”: 1 trigger

2. “maximum”: Maximum value as per instrument manual

3. “default”: Instrument default as per instrument manual

4. “infinity”: Continuous. Typically when the buffer is filled in this

   case, the older data points are overwritten.

Note that when using triggered measurements, it is recommended that you disable autorange by either explicitly disabling it or specifying your desired range.

Type:	int or TriggerCount

SCPIMultimeter.trigger_delay¶

Gets/sets the time delay which the multimeter will use following receiving a trigger event before starting the measurement.

Units:	As specified, or assumed to be of units seconds otherwise.
Type:	Quantity

SCPIMultimeter.trigger_mode¶

Gets/sets the SCPI Multimeter trigger mode.

Example usage:

>>> dmm.trigger_mode = dmm.TriggerMode.external

Type:	TriggerMode

This class is used for communicating with generic SCPI-compliant function generators.

Example usage:

>>> import instruments as ik
>>> import quantities as pq
>>> inst = ik.generic_scpi.SCPIFunctionGenerator.open_tcpip("192.168.1.1")
>>> inst.frequency = 1 * pq.kHz

frequency¶

Gets/sets the output frequency.

Units:	As specified, or assumed to be \(\text{Hz}\) otherwise.
Type:	float or Quantity

function¶

Gets/sets the output function of the function generator

Type:	SCPIFunctionGenerator.Function

offset¶

Gets/sets the offset voltage of the function generator.

Set value should be within correct bounds of instrument.

Units:	As specified (if a Quantity) or assumed to be of units volts.
Type:	Quantity with units volts.

phase¶

The Agilent/Keysight 33220a is a 20MHz function/arbitrary waveform generator. This model has been replaced by the Keysight 33500 series waveform generators. This class may or may not work with these newer models.

Example usage:

>>> import instruments as ik
>>> import quantities as pq
>>> inst = ik.agilent.Agilent33220a.open_gpibusb('/dev/ttyUSB0', 1)
>>> inst.function = inst.Function.sinusoid
>>> inst.frequency = 1 * pq.kHz
>>> inst.output = True

class Function¶

Enum containing valid functions for the Agilent/Keysight 33220a

dc = <Function.dc: 'DC'>¶

noise = <Function.noise: 'NOIS'>¶

pulse = <Function.pulse: 'PULS'>¶

ramp = <Function.ramp: 'RAMP'>¶

sinusoid = <Function.sinusoid: 'SIN'>¶

square = <Function.square: 'SQU'>¶

user = <Function.user: 'USER'>¶

class Agilent33220a.LoadResistance¶

Enum containing valid load resistance for the Agilent/Keysight 33220a

high_impedance = <LoadResistance.high_impedance: 'INF'>¶

maximum = <LoadResistance.maximum: 'MAX'>¶

minimum = <LoadResistance.minimum: 'MIN'>¶

class Agilent33220a.OutputPolarity¶

Enum containg valid output polarity modes for the Agilent/Keysight 33220a

inverted = <OutputPolarity.inverted: 'INV'>¶

normal = <OutputPolarity.normal: 'NORM'>¶

Agilent33220a.duty_cycle¶

Gets/sets the duty cycle of a square wave.

Duty cycle represents the amount of time that the square wave is at a high level.

Type:	int

Agilent33220a.frequency¶

Agilent33220a.function¶

Gets/sets the output function of the function generator

Type:	Agilent33220a.Function

Agilent33220a.load_resistance¶

Gets/sets the desired output termination load (ie, the impedance of the load attached to the front panel output connector).

The instrument has a fixed series output impedance of 50ohms. This function allows the instrument to compensate of the voltage divider and accurately report the voltage across the attached load.

Units:	As specified (if a Quantity) or assumed to be of units \(\Omega\) (ohm).
Type:	Quantity or Agilent33220a.LoadResistance

Agilent33220a.output¶

Gets/sets the output enable status of the front panel output connector.

The value True corresponds to the output being on, while False is the output being off.

Type:	bool

Agilent33220a.output_polarity¶

Gets/sets the polarity of the waveform relative to the offset voltage.

Type:	OutputPolarity

Agilent33220a.output_sync¶

Gets/sets the enabled status of the front panel sync connector.

Type:	bool

Agilent33220a.phase¶

Agilent33220a.ramp_symmetry¶

Gets/sets the ramp symmetry for ramp waves.

Symmetry represents the amount of time per cycle that the ramp wave is rising (unless polarity is inverted).

Type:	int

The Agilent 34410a is a very popular 6.5 digit DMM. This class should also cover the Agilent 34401a, 34411a, as well as the backwards compatability mode in the newer Agilent/Keysight 34460a/34461a. You can find the full specifications for these instruments on the Keysight website.

Example usage:

>>> import instruments as ik
>>> import quantities as pq
>>> dmm = ik.agilent.Agilent34410a.open_gpibusb('/dev/ttyUSB0', 1)
>>> print(dmm.measure(dmm.Mode.resistance))

abort()¶

Abort all measurements currently in progress.

clear_memory()¶

Clears the non-volatile memory of the Agilent 34410a.

fetch()¶

Transfer readings from instrument memory to the output buffer, and thus to the computer. If currently taking a reading, the instrument will wait until it is complete before executing this command. Readings are NOT erased from memory when using fetch. Use the R? command to read and erase data. Note that the data is transfered as ASCII, and thus it is not recommended to transfer a large number of data points using this method.

Return type:	list of Quantity elements

init()¶

Switch device from “idle” state to “wait-for-trigger state”. Measurements will begin when specified triggering conditions are met, following the receipt of the INIT command.

Note that this command will also clear the previous set of readings from memory.

r(count)¶

Have the multimeter perform a specified number of measurements and then transfer them using a binary transfer method. Data will be cleared from instrument memory after transfer is complete. Data is transfered from the instrument in 64-bit double floating point precision format.

Parameters:	count (int) – Number of samples to take.
Return type:	Quantity with numpy.array

read_data(sample_count)¶

Transfer specified number of data points from reading memory (RGD_STORE) to output buffer. First data point sent to output buffer is the oldest. Data is erased after being sent to output buffer.

Parameters:	sample_count (int) – Number of data points to be transfered to output buffer. If set to -1, all points in memory will be transfered.
Return type:	list of Quantity elements

read_data_nvmem()¶

Returns all readings in non-volatile memory (NVMEM).

Return type:	list of Quantity elements

read_last_data()¶

Retrieve the last measurement taken. This can be executed at any time, including when the instrument is currently taking measurements. If there are no data points available, the value 9.91000000E+37 is returned.

Units:	As specified by the data returned by the instrument.
Return type:	Quantity

read_meter()¶

Switch device from “idle” state to “wait-for-trigger” state. Immediately after the trigger conditions are met, the data will be sent to the output buffer of the instrument.

This is similar to calling init and then immediately following fetch.

Return type:	Quantity

data_point_count¶

Gets the total number of readings that are located in reading memory (RGD_STORE).

Return type:	int

Communicates with a Holzworth HS-9000 series multi-channel frequency synthesizer.

class Channel(hs, idx_chan)¶

Class representing a physical channel on the Holzworth HS9000

Warning

This class should NOT be manually created by the user. It

is designed to be initialized by the HS9000 class.

query(cmd)¶

Function used to send a command to the instrument while wrapping the command with the neccessary identifier for the channel.

Parameters:	cmd (str) – Command that will be sent to the instrument after being prefixed with the channel identifier
Returns:	The result from the query
Return type:	str

recall_state()¶

Recalls the state of the specified channel from memory.

Example usage: >>> import instruments as ik >>> hs = ik.holzworth.HS9000.open_tcpip(“192.168.0.2”, 8080) >>> hs.channel[0].recall_state()

reset()¶

Resets the setting of the specified channel

Example usage: >>> import instruments as ik >>> hs = ik.holzworth.HS9000.open_tcpip(“192.168.0.2”, 8080) >>> hs.channel[0].reset()

save_state()¶

Saves the current state of the specified channel.

Example usage: >>> import instruments as ik >>> hs = ik.holzworth.HS9000.open_tcpip(“192.168.0.2”, 8080) >>> hs.channel[0].save_state()

sendcmd(cmd)¶

Function used to send a command to the instrument while wrapping the command with the neccessary identifier for the channel.

Parameters:	cmd (str) – Command that will be sent to the instrument after being prefixed with the channel identifier

frequency¶

Gets/sets the frequency of the specified channel. When setting, values are bounded between what is returned by frequency_min and frequency_max.

Example usage: >>> import instruments as ik >>> hs = ik.holzworth.HS9000.open_tcpip(“192.168.0.2”, 8080) >>> print(hs.channel[0].frequency) >>> print(hs.channel[0].frequency_min) >>> print(hs.channel[0].frequency_max)

Type:	Quantity
Units:	As specified or assumed to be of units GHz

frequency_max¶

frequency_min¶

output¶

Gets/sets the output status of the channel. Setting to True will turn the channel’s output stage on, while a value of False will turn it off.

Example usage: >>> import instruments as ik >>> hs = ik.holzworth.HS9000.open_tcpip(“192.168.0.2”, 8080) >>> print(hs.channel[0].output) >>> hs.channel[0].output = True

Type:	bool

phase¶

Gets/sets the output phase of the specified channel. When setting, values are bounded between what is returned by phase_min and phase_max.

Example usage: >>> import instruments as ik >>> hs = ik.holzworth.HS9000.open_tcpip(“192.168.0.2”, 8080) >>> print(hs.channel[0].phase) >>> print(hs.channel[0].phase_min) >>> print(hs.channel[0].phase_max)

Type:	Quantity
Units:	As specified or assumed to be of units degrees

phase_max¶

phase_min¶

power¶

Gets/sets the output power of the specified channel. When setting, values are bounded between what is returned by power_min and power_max.

Example usage: >>> import instruments as ik >>> hs = ik.holzworth.HS9000.open_tcpip(“192.168.0.2”, 8080) >>> print(hs.channel[0].power) >>> print(hs.channel[0].power_min) >>> print(hs.channel[0].power_max)

Type:	Quantity
Units:	instruments.units.dBm

power_max¶

power_min¶

temperature¶

Gets the current temperature of the specified channel.

Units:	As specified by the instrument.
Return type:	Quantity

HS9000.channel¶

Gets a specific channel on the HS9000. The desired channel is accessed like one would access a list.

Example usage:

>>> import instruments as ik
>>> hs = ik.holzworth.HS9000.open_tcpip("192.168.0.2", 8080)
>>> print(hs.channel[0].frequency)

Returns:	A channel object for the HS9000
Return type:	Channel

HS9000.name¶

Gets identification string of the HS9000

Returns:	The string as usually returned by *IDN? on SCPI instruments
Return type:	str

HS9000.ready¶

Gets the ready status of the HS9000.

Returns:	If the instrument is ready for operation
Return type:	bool

The HP3456a is a 6 1/2 digit bench multimeter.

It supports DCV, ACV, ACV + DCV, 2 wire Ohms, 4 wire Ohms, DCV/DCV Ratio, ACV/DCV Ratio, Offset compensated 2 wire Ohms and Offset compensated 4 wire Ohms measurements.

Measurements can be further extended using a system math mode that allows for pass/fail, statistics, dB/dBm, null, scale and percentage readings.

HP3456a is a HPIB / pre-448.2 instrument.

class MathMode¶

Enum with the supported math modes

db = <MathMode.db: 9>¶

dbm = <MathMode.dbm: 4>¶

null = <MathMode.null: 3>¶

off = <MathMode.off: 0>¶

pass_fail = <MathMode.pass_fail: 1>¶

percent = <MathMode.percent: 8>¶

scale = <MathMode.scale: 7>¶

statistic = <MathMode.statistic: 2>¶

thermistor_c = <MathMode.thermistor_c: 6>¶

thermistor_f = <MathMode.thermistor_f: 5>¶

class HP3456a.Mode¶

Enum containing the supported mode codes

acv = <Mode.acv: 'S0F2'>¶

acvdcv = <Mode.acvdcv: 'S0F3'>¶

dcv = <Mode.dcv: 'S0F1'>¶

oc_resistence_2wire = <Mode.oc_resistence_2wire: 'S1F4'>¶

oc_resistence_4wire = <Mode.oc_resistence_4wire: 'S1F5'>¶

ratio_acv_dcv = <Mode.ratio_acv_dcv: 'S1F2'>¶

ratio_acvdcv_dcv = <Mode.ratio_acvdcv_dcv: 'S1F3'>¶

ratio_dcv_dcv = <Mode.ratio_dcv_dcv: 'S1F1'>¶

resistance_2wire = <Mode.resistance_2wire: 'S0F4'>¶

resistance_4wire = <Mode.resistance_4wire: 'S0F5'>¶

class HP3456a.Register¶

Enum with the register names for all HP3456a internal registers.

count = <Register.count: 'C'>¶

delay = <Register.delay: 'D'>¶

lower = <Register.lower: 'L'>¶

mean = <Register.mean: 'M'>¶

nplc = <Register.nplc: 'I'>¶

number_of_digits = <Register.number_of_digits: 'G'>¶

number_of_readings = <Register.number_of_readings: 'N'>¶

r = <Register.r: 'R'>¶

upper = <Register.upper: 'U'>¶

variance = <Register.variance: 'V'>¶

y = <Register.y: 'Y'>¶

z = <Register.z: 'Z'>¶

class HP3456a.TriggerMode¶

Enum with valid trigger modes.

external = <TriggerMode.external: 2>¶

hold = <TriggerMode.hold: 4>¶

internal = <TriggerMode.internal: 1>¶

single = <TriggerMode.single: 3>¶

class HP3456a.ValidRange¶

Enum with the valid ranges for voltage, resistance, and number of powerline cycles to integrate over.

nplc = <ValidRange.nplc: (0.1, 1.0, 10.0, 100.0)>¶

resistance = <ValidRange.resistance: (100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0)>¶

voltage = <ValidRange.voltage: (0.1, 1.0, 10.0, 100.0, 1000.0)>¶

HP3456a.auto_range()¶

Set input range to auto. The HP3456a should upscale when a reading is at 120% and downscale when it below 11% full scale. Note that auto ranging can increase the measurement time.

HP3456a.fetch(mode=None)¶

Retrieve n measurements after the HP3456a has been instructed to perform a series of similar measurements. Typically the mode, range, nplc, analog filter, autozero is set along with the number of measurements to take. The series is then started at the trigger command.

Example usage:

>>> dmm.number_of_digits = 6
>>> dmm.auto_range()
>>> dmm.nplc = 1
>>> dmm.mode = dmm.Mode.resistance_2wire
>>> n = 100
>>> dmm.number_of_readings = n
>>> dmm.trigger()
>>> time.sleep(n * 0.04)
>>> v = dmm.fetch(dmm.Mode.resistance_2wire)
>>> print len(v)
10

Parameters:	mode (HP3456a.Mode) – Desired measurement mode. If not specified, the previous set mode will be used, but no measurement unit will be returned.
Returns:	A series of measurements from the multimeter.
Return type:	Quantity

HP3456a.measure(mode=None)¶

Instruct the HP3456a to perform a one time measurement. The measurement will use the current set registers for the measurement (number_of_readings, number_of_digits, nplc, delay, mean, lower, upper, y and z) and will immediately take place.

Note that using HP3456a.measure() will override the trigger_mode to HP3456a.TriggerMode.single

Example usage:

>>> dmm = ik.hp.HP3456a.open_gpibusb("/dev/ttyUSB0", 22)
>>> dmm.number_of_digits = 6
>>> dmm.nplc = 1
>>> print dmm.measure(dmm.Mode.resistance_2wire)

Parameters:	mode (HP3456a.Mode) – Desired measurement mode. If not specified, the previous set mode will be used, but no measurement unit will be returned.
Returns:	A measurement from the multimeter.
Return type:	Quantity

HP3456a.trigger()¶

Signal a single manual trigger event to the HP3456a.

HP3456a.autozero¶

Set the autozero mode.

This is used to compensate for offsets in the dc input amplifier circuit of the multimeter. If set, the amplifier”s input circuit is shorted to ground prior to actual measurement in order to take an offset reading. This offset is then used to compensate for drift in the next measurement. When disabled, one offset reading is taken immediately and stored into memory to be used for all successive measurements onwards. Disabling autozero increases the HP3456a“s measurement speed, and also makes the instrument more suitable for high impendance measurements since no input switching is done.

HP3456a.count¶

Get the number of measurements taken from HP3456a.Register.count when in HP3456a.MathMode.statistic.

Return type:	int

HP3456a.delay¶

Get/set the delay that is waited after a trigger for the input to settle using HP3456a.Register.delay.

Type:	As specified, assumed to be s otherwise
Return type:	s

HP3456a.filter¶

Set the analog filter mode.

The HP3456a has a 3 pole active filter with greater than 60dB attenuation at frequencies of 50Hz and higher. The filter is applied between the input terminals and input amplifier. When in ACV or ACV+DCV functions the filter is applied to the output of the ac converter and input amplifier. In these modes select the filter for measurements below 400Hz.

HP3456a.input_range¶

Set the input range to be used.

The HP3456a has separate ranges for ohm and for volt. The range value sent to the instrument depends on the unit set on the input range value. auto selects auto ranging.

Type:	Quantity

HP3456a.lower¶

Get/set the value in HP3456a.Register.lower, which indicates the lowest value measurement made while in HP3456a.MathMode.statistic, or the lowest value preset for HP3456a.MathMode.pass_fail.

Type:	float

HP3456a.math_mode¶

Set the math mode.

The HP3456a has a number of different math modes that can change measurement output, or can provide additional statistics. Interaction with these modes is done via the HP3456a.Register.

Type:	HP3456a.MathMode

HP3456a.mean¶

Get the mean over HP3456a.Register.count measurements from HP3456a.Register.mean when in HP3456a.MathMode.statistic.

Return type:	float

HP3456a.mode¶

Set the measurement mode.

Type:	HP3456a.Mode

HP3456a.nplc¶

Get/set the number of powerline cycles to integrate per measurement using HP3456a.Register.nplc.

Setting higher values increases accuracy at the cost of a longer measurement time. The implicit assumption is that the input reading is stable over the number of powerline cycles to integrate.

Type:	int

HP3456a.number_of_digits¶

Get/set the number of digits used in measurements using HP3456a.Register.number_of_digits.

Set to higher values to increase accuracy at the cost of measurement speed.

Type:	int

HP3456a.number_of_readings¶

Get/set the number of readings done per trigger/measurement cycle using HP3456a.Register.number_of_readings.

Type:	float
Return type:	float

HP3456a.r¶

Get/set the value in HP3456a.Register.r, which indicates the resistor value used while in HP3456a.MathMode.dbm or the number of recalled readings in reading storage mode.

Type:	float
Return type:	float

HP3456a.relative¶

Enable or disable HP3456a.MathMode.Null on the instrument.

Type:	bool

HP3456a.trigger_mode¶

Set the trigger mode.

Note that using HP3456a.measure() will override the trigger_mode to HP3456a.TriggerMode.single.

Type:	HP3456a.TriggerMode

HP3456a.upper¶

Get/set the value in HP3456a.Register.upper, which indicates the highest value measurement made while in HP3456a.MathMode.statistic, or the highest value preset for HP3456a.MathMode.pass_fail.

Type:	float
Return type:	float

HP3456a.variance¶

Get the variance over HP3456a.Register.count measurements from HP3456a.Register.variance when in HP3456a.MathMode.statistic.

Return type:	float

HP3456a.y¶

Get/set the value in HP3456a.Register.y to be used in calculations when in HP3456a.MathMode.scale or HP3456a.MathMode.percent.

Type:	float
Return type:	float

HP3456a.z¶

Get/set the value in HP3456a.Register.z to be used in calculations when in HP3456a.MathMode.scale or the first reading when in HP3456a.MathMode.statistic.

Type:	float
Return type:	float

The HP6624a is a multi-output power supply.

This class can also be used for HP662xa, where x=1,2,3,4,7. Note that some models have less channels then the HP6624 and it is up to the user to take this into account. This can be changed with the channel_count property.

Example usage:

>>> import instruments as ik
>>> psu = ik.hp.HP6624a.open_gpibusb('/dev/ttyUSB0', 1)
>>> psu.channel[0].voltage = 10 # Sets channel 1 voltage to 10V.

class Channel(hp, idx)¶

Class representing a power output channel on the HP6624a.

Warning

This class should NOT be manually created by the user. It is designed to be initialized by the HP6624a class.

query(cmd)¶

Function used to send a command to the instrument while wrapping the command with the neccessary identifier for the channel.

Parameters:	cmd (str) – Command that will be sent to the instrument after being prefixed with the channel identifier
Returns:	The result from the query
Return type:	str

reset()¶

Reset overvoltage and overcurrent errors to resume operation.

sendcmd(cmd)¶

Function used to send a command to the instrument while wrapping the command with the neccessary identifier for the channel.

Parameters:	cmd (str) – Command that will be sent to the instrument after being prefixed with the channel identifier

current¶

Gets/sets the current of the specified channel. If the device is in constant voltage mode, this sets the current limit.

Note there is no bounds checking on the value specified.

Units:	As specified, or assumed to be \(\text{A}\) otherwise.
Type:	float or Quantity

current_sense¶

Gets the actual output current as measured by the instrument for the specified channel.

Units:	\(\text{A}\) (amps)
Return type:	Quantity

mode¶

Gets/sets the mode for the specified channel.

output¶

Gets/sets the outputting status of the specified channel.

This is a toggle setting. True will turn on the channel output while False will turn it off.

Type:	bool

overcurrent¶

Gets/sets the overcurrent protection setting for the specified channel.

This is a toggle setting. It is either on or off.

Type:	bool

overvoltage¶

Gets/sets the overvoltage protection setting for the specified channel.

Note there is no bounds checking on the value specified.

Units:	As specified, or assumed to be \(\text{V}\) otherwise.
Type:	float or Quantity

voltage¶

Gets/sets the voltage of the specified channel. If the device is in constant current mode, this sets the voltage limit.

Note there is no bounds checking on the value specified.

Units:	As specified, or assumed to be \(\text{V}\) otherwise.
Type:	float or Quantity

voltage_sense¶

Gets the actual voltage as measured by the sense wires for the specified channel.

Units:	\(\text{V}\) (volts)
Return type:	Quantity

class HP6624a.Mode¶

Enum holding typical valid output modes for a power supply.

However, for the HP6624a I believe that it is only capable of constant-voltage output, so this class current does not do anything and is just a placeholder.

current = <Mode.current: 0>¶

voltage = <Mode.current: 0>¶

HP6624a.clear()¶

Taken from the manual:

Return the power supply to its power-on state and all parameters are returned to their initial power-on values except the following:

1. The store/recall registers are not cleared.
2. The power supply remains addressed to listen.
3. The PON bit in the serial poll register is cleared.

HP6624a.channel¶

Gets a specific channel object. The desired channel is specified like one would access a list.

Return type:	HP6624a.Channel

See also

HP6624a for example using this property.

HP6624a.channel_count¶

Gets/sets the number of output channels available for the connected power supply.

Type:	int

HP6624a.current¶

Gets/sets the current for all four channels.

Units:	As specified (if a Quantity) or assumed to be of units Amps.
Type:	list of Quantity with units Amp

HP6624a.current_sense¶

Gets the actual current as measured by the instrument for all channels.

Units:	\(\text{A}\) (amps)
Return type:	tuple of Quantity

HP6624a.voltage¶

Gets/sets the voltage for all four channels.

Units:	As specified (if a Quantity) or assumed to be of units Volts.
Type:	list of Quantity with units Volt

HP6624a.voltage_sense¶

Gets the actual voltage as measured by the sense wires for all channels.

Units:	\(\text{V}\) (volts)
Return type:	tuple of Quantity

The HP6632b is a system dc power supply with an output rating of 0-20V/0-5A, precision low current measurement and low output noise.

According to the manual this class MIGHT be usable for any HP power supply with a model number

• HP663Xb with X in {1, 2, 3, 4},
• HP661Xc with X in {1,2, 3, 4} and
• HP663X2A for X in {1, 3}, without the additional measurement capabilities.

HOWEVER, it has only been tested by the author with HP6632b supplies.

Example usage:

>>> import instruments as ik
>>> psu = ik.hp.HP6632b.open_gpibusb('/dev/ttyUSB0', 6)
>>> psu.voltage = 10             # Sets voltage to 10V.
>>> psu.output = True            # Enable output
>>> psu.voltage
array(10.0) * V
>>> psu.voltage_trigger = 20     # Set transient trigger voltage
>>> psu.init_output_trigger()    # Prime instrument to initiated state, ready for trigger
>>> psu.trigger()                # Send trigger
>>> psu.voltage
array(10.0) * V

class ALCBandwidth¶

Enum containing valid ALC bandwidth modes for the hp6632b

fast = <ALCBandwidth.fast: 60000>¶

normal = <ALCBandwidth.normal: 15000>¶

class HP6632b.DFISource¶

Enum containing valid DFI sources for the hp6632b

event_status_bit = <DFISource.event_status_bit: 'ESB'>¶

off = <DFISource.off: 'OFF'>¶

operation = <DFISource.operation: 'OPER'>¶

questionable = <DFISource.questionable: 'QUES'>¶

request_service_bit = <DFISource.request_service_bit: 'RQS'>¶

class HP6632b.DigitalFunction¶

Enum containing valid digital function modes for the hp6632b

data = <DigitalFunction.data: 'DIG'>¶

remote_inhibit = <DigitalFunction.remote_inhibit: 'RIDF'>¶

class HP6632b.ErrorCodes¶

Enum containing generic-SCPI error codes along with codes specific to the HP6632b.

block_data_error = <ErrorCodes.block_data_error: -160>¶

block_data_not_allowed = <ErrorCodes.block_data_not_allowed: -168>¶

cal_not_enabled = <ErrorCodes.cal_not_enabled: 403>¶

cal_password_incorrect = <ErrorCodes.cal_password_incorrect: 402>¶

cal_switch_prevents_cal = <ErrorCodes.cal_switch_prevents_cal: 401>¶

character_data_error = <ErrorCodes.character_data_error: -140>¶

character_data_not_allowed = <ErrorCodes.character_data_not_allowed: -148>¶

character_data_too_long = <ErrorCodes.character_data_too_long: -144>¶

command_error = <ErrorCodes.command_error: -100>¶

command_header_error = <ErrorCodes.command_header_error: -110>¶

command_only_applic_rs232 = <ErrorCodes.command_only_applic_rs232: 602>¶

computed_prog_cal_constants_incorrect = <ErrorCodes.computed_prog_cal_constants_incorrect: 405>¶

computed_readback_cal_const_incorrect = <ErrorCodes.computed_readback_cal_const_incorrect: 404>¶

curr_or_volt_fetch_incompat_with_last_acq = <ErrorCodes.curr_or_volt_fetch_incompat_with_last_acq: 603>¶

cv_or_cc_status_incorrect = <ErrorCodes.cv_or_cc_status_incorrect: 407>¶

data_out_of_range = <ErrorCodes.data_out_of_range: -222>¶

data_type_error = <ErrorCodes.data_type_error: -104>¶

digital_io_selftest = <ErrorCodes.digital_io_selftest: 80>¶

execution_error = <ErrorCodes.execution_error: -200>¶

exponent_too_large = <ErrorCodes.exponent_too_large: -123>¶

expression_error = <ErrorCodes.expression_error: -170>¶

expression_not_allowed = <ErrorCodes.expression_not_allowed: -178>¶

front_panel_uart_buffer_overrun = <ErrorCodes.front_panel_uart_buffer_overrun: 223>¶

front_panel_uart_framing = <ErrorCodes.front_panel_uart_framing: 221>¶

front_panel_uart_overrun = <ErrorCodes.front_panel_uart_overrun: 220>¶

front_panel_uart_parity = <ErrorCodes.front_panel_uart_parity: 222>¶

front_panel_uart_timeout = <ErrorCodes.front_panel_uart_timeout: 224>¶

get_not_allowed = <ErrorCodes.get_not_allowed: -105>¶

header_separator_error = <ErrorCodes.header_separator_error: -111>¶

header_suffix_out_of_range = <ErrorCodes.header_suffix_out_of_range: -114>¶

illegal_macro_label = <ErrorCodes.illegal_macro_label: -273>¶

illegal_parameter_value = <ErrorCodes.illegal_parameter_value: -224>¶

incorrect_seq_cal_commands = <ErrorCodes.incorrect_seq_cal_commands: 406>¶

ingrd_recv_buffer_overrun = <ErrorCodes.ingrd_recv_buffer_overrun: 213>¶

invalid_block_data = <ErrorCodes.invalid_block_data: -161>¶

invalid_character = <ErrorCodes.invalid_character: -101>¶

invalid_character_data = <ErrorCodes.invalid_character_data: -141>¶

invalid_character_in_number = <ErrorCodes.invalid_character_in_number: -121>¶

invalid_expression = <ErrorCodes.invalid_expression: -171>¶

invalid_inside_macro_definition = <ErrorCodes.invalid_inside_macro_definition: -183>¶

invalid_outside_macro_definition = <ErrorCodes.invalid_outside_macro_definition: -181>¶

invalid_separator = <ErrorCodes.invalid_separator: -103>¶

invalid_string_data = <ErrorCodes.invalid_string_data: -151>¶

invalid_suffix = <ErrorCodes.invalid_suffix: -131>¶

macro_error_180 = <ErrorCodes.macro_error_180: -180>¶

macro_error_270 = <ErrorCodes.macro_error_270: -270>¶

macro_execution_error = <ErrorCodes.macro_execution_error: -272>¶

macro_parameter_error = <ErrorCodes.macro_parameter_error: -184>¶

macro_recursion_error = <ErrorCodes.macro_recursion_error: -276>¶

macro_redefinition_not_allowed = <ErrorCodes.macro_redefinition_not_allowed: -277>¶

measurement_overrange = <ErrorCodes.measurement_overrange: 604>¶

missing_parameter = <ErrorCodes.missing_parameter: -109>¶

no_error = <ErrorCodes.no_error: 0>¶

numeric_data_error = <ErrorCodes.numeric_data_error: -120>¶

numeric_data_not_allowed = <ErrorCodes.numeric_data_not_allowed: -128>¶

operation_complete = <ErrorCodes.operation_complete: -800>¶

out_of_memory = <ErrorCodes.out_of_memory: -225>¶

output_mode_must_be_normal = <ErrorCodes.output_mode_must_be_normal: 408>¶

ovdac_selftest = <ErrorCodes.ovdac_selftest: 15>¶

parameter_not_allowed = <ErrorCodes.parameter_not_allowed: -108>¶

power_on = <ErrorCodes.power_on: -500>¶

program_mnemonic_too_long = <ErrorCodes.program_mnemonic_too_long: -112>¶

query_deadlocked = <ErrorCodes.query_deadlocked: -430>¶

query_error = <ErrorCodes.query_error: -400>¶

query_interrupted = <ErrorCodes.query_interrupted: -410>¶

query_unterminated = <ErrorCodes.query_unterminated: -420>¶

query_unterminated_after_indefinite_response = <ErrorCodes.query_unterminated_after_indefinite_response: -440>¶

ram_cal_checksum_failed = <ErrorCodes.ram_cal_checksum_failed: 3>¶

ram_config_checksum_failed = <ErrorCodes.ram_config_checksum_failed: 2>¶

ram_rd0_checksum_failed = <ErrorCodes.ram_rd0_checksum_failed: 1>¶

ram_rst_checksum_failed = <ErrorCodes.ram_rst_checksum_failed: 5>¶

ram_selftest = <ErrorCodes.ram_selftest: 10>¶

ram_state_checksum_failed = <ErrorCodes.ram_state_checksum_failed: 4>¶

request_control_event = <ErrorCodes.request_control_event: -700>¶

rs232_recv_framing_error = <ErrorCodes.rs232_recv_framing_error: 216>¶

rs232_recv_overrun_error = <ErrorCodes.rs232_recv_overrun_error: 218>¶

rs232_recv_parity_error = <ErrorCodes.rs232_recv_parity_error: 217>¶

string_data_error = <ErrorCodes.string_data_error: -150>¶

string_data_not_allowed = <ErrorCodes.string_data_not_allowed: -158>¶

suffix_error = <ErrorCodes.suffix_error: -130>¶

suffix_not_allowed = <ErrorCodes.suffix_not_allowed: -138>¶

suffix_too_long = <ErrorCodes.suffix_too_long: -134>¶

syntax_error = <ErrorCodes.syntax_error: -102>¶

system_error = <ErrorCodes.system_error: -310>¶

too_many_digits = <ErrorCodes.too_many_digits: -124>¶

too_many_errors = <ErrorCodes.too_many_errors: -350>¶

too_many_sweep_points = <ErrorCodes.too_many_sweep_points: 601>¶

too_much_data = <ErrorCodes.too_much_data: -223>¶

undefined_header = <ErrorCodes.undefined_header: -113>¶

unexpected_number_of_parameters = <ErrorCodes.unexpected_number_of_parameters: -115>¶

user_request_event = <ErrorCodes.user_request_event: -600>¶

vdac_idac_selftest1 = <ErrorCodes.vdac_idac_selftest1: 11>¶

vdac_idac_selftest2 = <ErrorCodes.vdac_idac_selftest2: 12>¶

vdac_idac_selftest3 = <ErrorCodes.vdac_idac_selftest3: 13>¶

vdac_idac_selftest4 = <ErrorCodes.vdac_idac_selftest4: 14>¶

class HP6632b.RemoteInhibit¶

Enum containing vlaid remote inhibit modes for the hp6632b.

latching = <RemoteInhibit.latching: 'LATC'>¶

live = <RemoteInhibit.live: 'LIVE'>¶

off = <RemoteInhibit.off: 'OFF'>¶

class HP6632b.SenseWindow¶

Enum containing valid sense window modes for the hp6632b.

hanning = <SenseWindow.hanning: 'HANN'>¶

rectangular = <SenseWindow.rectangular: 'RECT'>¶

HP6632b.abort_output_trigger()¶

Set the output trigger system to the idle state.

HP6632b.check_error_queue()¶

Checks and clears the error queue for this device, returning a list of ErrorCodes or int elements for each error reported by the connected instrument.

HP6632b.init_output_trigger()¶

Set the output trigger system to the initiated state. In this state, the power supply will respond to the next output trigger command.

HP6632b.current_sense_range¶

Get/set the sense current range by the current max value.

A current of 20mA or less selects the low-current range, a current value higher than that selects the high-current range. The low current range increases the low current measurement sensitivity and accuracy.

Units:	As specified, or assumed to be \(\text{A}\) otherwise.
Type:	float or Quantity

HP6632b.current_trigger¶

Gets/sets the pending triggered output current.

Note there is no bounds checking on the value specified.

Units:	As specified, or assumed to be \(\text{A}\) otherwise.
Type:	float or Quantity

HP6632b.digital_data¶

Get/set digital in+out port to data. Data can be an integer from 0-7.

Type:	int

HP6632b.digital_function¶

Get/set the inhibit+fault port to digital in+out or vice-versa.

Type:	DigitalFunction

HP6632b.display_brightness¶

HP6632b.display_contrast¶

HP6632b.init_output_continuous¶

Get/set the continuous output trigger. In this state, the power supply will remain in the initiated state, and respond continuously on new incoming triggers by applying the set voltage and current trigger levels.

Type:	bool

HP6632b.line_frequency¶

HP6632b.output_dfi¶

Get/set the discrete fault indicator (DFI) output from the dc source. The DFI is an open-collector logic signal connected to the read panel FLT connection, that can be used to signal external devices when a fault is detected.

Type:	bool

HP6632b.output_dfi_source¶

Get/set the source for discrete fault indicator (DFI) events.

Type:	DFISource

HP6632b.output_protection_delay¶

Get/set the time between programming of an output change that produces a constant current condition and the recording of that condigition in the Operation Status Condition register. This command also delays over current protection, but not overvoltage protection.

Units:	As specified, or assumed to be \(\text{s}\) otherwise.
Type:	float or Quantity

HP6632b.output_remote_inhibit¶

Get/set the remote inhibit signal. Remote inhibit is an external, chassis-referenced logic signal routed through the rear panel INH connection, which allows an external device to signal a fault.

Type:	RemoteInhibit

HP6632b.sense_sweep_interval¶

Get/set the digitizer sample spacing. Can be set from 15.6 us to 31200 seconds, the interval will be rounded to the nearest 15.6 us increment.

Units:	As specified, or assumed to be \(\text{s}\) otherwise.
Type:	float or Quantity

HP6632b.sense_sweep_points¶

Get/set the number of points in a measurement sweep.

Type:	int

HP6632b.sense_window¶

Get/set the measurement window function.

Type:	SenseWindow

HP6632b.voltage_alc_bandwidth¶

Get the “automatic level control bandwidth” which for the HP66332A and HP6631-6634 determines if the output capacitor is in circuit. Normal denotes that it is, and Fast denotes that it is not.

Type:	ALCBandwidth

HP6632b.voltage_trigger¶

Gets/sets the pending triggered output voltage.

Note there is no bounds checking on the value specified.

Units:	As specified, or assumed to be \(\text{V}\) otherwise.
Type:	float or Quantity

The HP6652a is a single output power supply.

Because it is a single channel output, this object inherits from both PowerSupply and PowerSupplyChannel.

According to the manual, this class MIGHT be usable for any HP power supply with a model number HP66XYA, where X is in {4,5,7,8,9} and Y is a digit(?). (e.g. HP6652A and HP6671A)

HOWEVER, it has only been tested by the author with an HP6652A power supply.

Example usage:

>>> import time
>>> import instruments as ik
>>> psu = ik.hp.HP6652a.open_serial('/dev/ttyUSB0', 57600)
>>> psu.voltage = 3 # Sets output voltage to 3V.
>>> psu.output = True
>>> psu.voltage
array(3.0) * V
>>> psu.voltage_sense < 5
True
>>> psu.output = False
>>> psu.voltage_sense < 1
True
>>> psu.display_textmode=True
>>> psu.display_text("test GOOD")
'TEST GOOD'
>>> time.sleep(5)
>>> psu.display_textmode=False

display_text(text_to_display)¶

Sends up to 12 (uppercase) alphanumerics to be sent to the front-panel LCD display. Some punctuation is allowed, and can affect the number of characters allowed. See the programming manual for the HP6652A for more details.

Because the maximum valid number of possible characters is 15 (counting the possible use of punctuation), the text will be truncated to 15 characters before the command is sent to the instrument.

If an invalid string is sent, the command will fail silently. Any lowercase letters in the text_to_display will be converted to uppercase before the command is sent to the instrument.

No attempt to validate punctuation is currently made.

Because the string cannot be read back from the instrument, this method returns the actual string value sent.

Parameters:	text_to_display ('str') – The text that you wish to have displayed on the front-panel LCD
Returns:	Returns the version of the provided string that will be send to the instrument. This means it will be truncated to a maximum of 15 characters and changed to all upper case.
Return type:	str

reset()¶

Reset overvoltage and overcurrent errors to resume operation.

channel¶

Return the channel (which in this case is the entire instrument, since there is only 1 channel on the HP6652a.)

Return type:	‘tuple’ of length 1 containing a reference back to the parent HP6652a object.

current¶

Gets/sets the output current.

Note there is no bounds checking on the value specified.

Units:	As specified, or assumed to be \(\text{A}\) otherwise.
Type:	float or Quantity

current_sense¶

Gets the actual output current as measured by the sense wires.

Units:	\(\text{A}\) (amps)
Return type:	Quantity

display_textmode¶

Gets/sets the display mode.

This is a toggle setting. True will allow text to be sent to the front-panel LCD with the display_text() method. False returns to the normal display mode.

See also

display_text()

Type:	bool

mode¶

Unimplemented.

name¶

The name of the connected instrument, as reported by the standard SCPI command *IDN?.

Return type:	str

output¶

Gets/sets the output status.

This is a toggle setting. True will turn on the instrument output while False will turn it off.

Type:	bool

overcurrent¶

Gets/sets the overcurrent protection setting.

This is a toggle setting. It is either on or off.

Type:	bool

overvoltage¶

Gets/sets the overvoltage protection setting in volts.

Note there is no bounds checking on the value specified.

Units:	As specified, or assumed to be \(\text{V}\) otherwise.
Type:	float or Quantity

voltage¶

Gets/sets the output voltage.

Note there is no bounds checking on the value specified.

Units:	As specified, or assumed to be \(\text{V}\) otherwise.
Type:	float or Quantity

voltage_sense¶

Gets the actual output voltage as measured by the sense wires.

Units:	\(\text{V}\) (volts)
Return type:	Quantity

The Keithley 195 is a 5 1/2 digit auto-ranging digital multimeter. You can find the full specifications list in the Keithley 195 user’s guide.

Example usage:

>>> import instruments as ik
>>> import quantities as pq
>>> dmm = ik.keithley.Keithley195.open_gpibusb('/dev/ttyUSB0', 12)
>>> print dmm.measure(dmm.Mode.resistance)

class Mode¶

Enum containing valid measurement modes for the Keithley 195

current_ac = <Mode.current_ac: 4>¶

current_dc = <Mode.current_dc: 3>¶

resistance = <Mode.resistance: 2>¶

voltage_ac = <Mode.voltage_ac: 1>¶

voltage_dc = <Mode.voltage_dc: 0>¶

class Keithley195.TriggerMode¶

Enum containing valid trigger modes for the Keithley 195

ext_continuous = <TriggerMode.ext_continuous: 6>¶

ext_one_shot = <TriggerMode.ext_one_shot: 7>¶

get_continuous = <TriggerMode.get_continuous: 2>¶

get_one_shot = <TriggerMode.get_one_shot: 3>¶

talk_continuous = <TriggerMode.talk_continuous: 0>¶

talk_one_shot = <TriggerMode.talk_one_shot: 1>¶

x_continuous = <TriggerMode.x_continuous: 4>¶

x_one_shot = <TriggerMode.x_one_shot: 5>¶

class Keithley195.ValidRange¶

Enum containing valid range settings for the Keithley 195

current_ac = <ValidRange.current_ac: (2e-05, 0.0002, 0.002, 0.02, 0.2, 2, 2)>¶

current_dc = <ValidRange.current_dc: (2e-05, 0.0002, 0.002, 0.02, 0.2, 2)>¶

resistance = <ValidRange.resistance: (20, 200, 2000, 20000.0, 200000.0, 2000000.0, 20000000.0)>¶

voltage_ac = <ValidRange.voltage_ac: (0.02, 0.2, 2, 20, 200, 700)>¶

voltage_dc = <ValidRange.voltage_dc: (0.02, 0.2, 2, 20, 200, 1000)>¶

Keithley195.auto_range()¶

Turn on auto range for the Keithley 195.

This is the same as calling Keithley195.input_range = 'auto'

Keithley195.get_status_word()¶

Retreive the status word from the instrument. This contains information regarding the various settings of the instrument.

The function parse_status_word is designed to parse the return string from this function.

Returns:	String containing setting information of the instrument
Return type:	str

Keithley195.measure(mode=None)¶

Instruct the Keithley 195 to perform a one time measurement. The instrument will use default parameters for the requested measurement. The measurement will immediately take place, and the results are directly sent to the instrument’s output buffer.

Method returns a Python quantity consisting of a numpy array with the instrument value and appropriate units.

With the 195, it is HIGHLY recommended that you seperately set the mode and let the instrument settle into the new mode. This can sometimes take longer than the 2 second delay added in this method. In our testing the 2 seconds seems to be sufficient but we offer no guarentee.

Example usage:

>>> import instruments as ik
>>> import quantities as pq
>>> dmm = ik.keithley.Keithley195.open_gpibusb('/dev/ttyUSB0', 12)
>>> print(dmm.measure(dmm.Mode.resistance))

Parameters:	mode (Keithley195.Mode) – Desired measurement mode. This must always be specified in order to provide the correct return units.
Returns:	A measurement from the multimeter.
Return type:	Quantity

static Keithley195.parse_status_word(statusword)¶

Parse the status word returned by the function get_status_word.

Returns a dict with the following keys: {trigger,mode,range,eoi,buffer,rate,srqmode,relative,delay,multiplex, selftest,dataformat,datacontrol,filter,terminator}

Parameters:	statusword – Byte string to be unpacked and parsed
Type:	str
Returns:	A parsed version of the status word as a Python dictionary
Return type:	dict

Keithley195.trigger()¶

Tell the Keithley 195 to execute all commands that it has received.

Do note that this is different from the standard SCPI *TRG command (which is not supported by the 195 anyways).

Keithley195.input_range¶

Gets/sets the range of the Keithley 195 input terminals. The valid range settings depends on the current mode of the instrument. They are listed as follows:

1. voltage_dc = (20e-3, 200e-3, 2, 20, 200, 1000)
2. voltage_ac = (20e-3, 200e-3, 2, 20, 200, 700)
3. current_dc = (20e-6, 200e-6, 2e-3, 20e-3, 200e-3, 2)
4. current_ac = (20e-6, 200e-6, 2e-3, 20e-3, 200e-3, 2)
5. resistance = (20, 200, 2000, 20e3, 200e3, 2e6, 20e6)

All modes will also accept the string auto which will set the 195 into auto ranging mode.

Return type:	Quantity or str

Keithley195.mode¶

Gets/sets the measurement mode for the Keithley 195. The base model only has DC voltage and resistance measurements. In order to use AC voltage, DC current, and AC current measurements your unit must be equiped with option 1950.

Example use:

>>> import instruments as ik
>>> dmm = ik.keithley.Keithley195.open_gpibusb('/dev/ttyUSB0', 12)
>>> dmm.mode = dmm.Mode.resistance

Type:	Keithley195.Mode

Keithley195.relative¶

Gets/sets the zero command (relative measurement) mode of the Keithley 195.

As stated in the manual: The zero mode serves as a means for a baseline suppression. When the correct zero command is send over the bus, the instrument will enter the zero mode, as indicated by the front panel ZERO indicator light. All reading displayed or send over the bus while zero is enabled are the difference between the stored baseline adn the actual voltage level. For example, if a 100mV baseline is stored, 100mV will be subtracted from all subsequent readings as long as the zero mode is enabled. The value of the stored baseline can be as little as a few microvolts or as large as the selected range will permit.

See the manual for more information.

Type:	bool

Keithley195.trigger_mode¶

Gets/sets the trigger mode of the Keithley 195.

There are two different trigger settings for four different sources. This means there are eight different settings for the trigger mode.

The two types are continuous and one-shot. Continuous has the instrument continuously sample the resistance. One-shot performs a single resistance measurement.

The three trigger sources are on talk, on GET, and on “X”. On talk refers to addressing the instrument to talk over GPIB. On GET is when the instrument receives the GPIB command byte for “group execute trigger”. On “X” is when one sends the ASCII character “X” to the instrument. This character is used as a general execute to confirm commands send to the instrument. In InstrumentKit, “X” is sent after each command so it is not suggested that one uses on “X” triggering. Last, is external triggering. This is the port on the rear of the instrument. Refer to the manual for electrical characteristics of this port.

Type:	Keithley195.TriggerMode

The Keithley Model 580 is a 4 1/2 digit resolution autoranging micro-ohmmeter with a +- 20,000 count LCD. It is designed for low resistance measurement requirements from 10uΩ to 200kΩ.

The device needs some processing time (manual reports 300-500ms) after a command has been transmitted.

class Drive¶

Enum containing valid drive modes for the Keithley 580

dc = <Drive.dc: 1>¶

pulsed = <Drive.pulsed: 0>¶

class Keithley580.Polarity¶

Enum containing valid polarity modes for the Keithley 580

negative = <Polarity.negative: 1>¶

positive = <Polarity.positive: 0>¶

class Keithley580.TriggerMode¶

Enum containing valid trigger modes for the Keithley 580

get_continuous = <TriggerMode.get_continuous: 2>¶

get_one_shot = <TriggerMode.get_one_shot: 3>¶

talk_continuous = <TriggerMode.talk_continuous: 0>¶

talk_one_shot = <TriggerMode.talk_one_shot: 1>¶

trigger_continuous = <TriggerMode.trigger_continuous: 4>¶

trigger_one_shot = <TriggerMode.trigger_one_shot: 5>¶

Keithley580.auto_range()¶

Turn on auto range for the Keithley 580.

This is the same as calling the Keithley580.set_resistance_range method and setting the parameter to “AUTO”.

Keithley580.get_status_word()¶

The keithley will not always respond with the statusword when asked. We use a simple heuristic here: request it up to 5 times, using a 1s delay to allow the keithley some thinking time.

Return type:	str

Keithley580.measure()¶

Perform a measurement with the Keithley 580.

The usual mode parameter is ignored for the Keithley 580 as the only valid mode is resistance.

Return type:	Quantity

static Keithley580.parse_measurement(measurement)¶

Parse the measurement string returned by the instrument.

Returns a dict with the following keys: {status,polarity,drycircuit,drive,resistance}

Parameters:	measurement – String to be unpacked and parsed
Type:	str
Return type:	dict

Keithley580.parse_status_word(statusword)¶

Parse the status word returned by the function get_status_word.

Returns a dict with the following keys: {drive,polarity,drycircuit,operate,range,relative,eoi,trigger, sqrondata,sqronerror,linefreq,terminator}

Parameters:	statusword – Byte string to be unpacked and parsed
Type:	str
Return type:	dict

Keithley580.query(msg, size=-1)¶

Keithley580.sendcmd(msg)¶

Keithley580.set_calibration_value(value)¶

Sets the calibration value. This is not currently implemented.

Parameters:	value – Calibration value to write

Keithley580.store_calibration_constants()¶

Instructs the instrument to store the calibration constants. This is not currently implemented.

Keithley580.trigger()¶

Tell the Keithley 580 to execute all commands that it has received.

Do note that this is different from the standard SCPI *TRG command (which is not supported by the 580 anyways).

Keithley580.drive¶

Gets/sets the instrument drive to either pulsed or DC.

Example use:

>>> import instruments as ik
>>> keithley = ik.keithley.Keithley580.open_gpibusb('/dev/ttyUSB0', 1)
>>> keithley.drive = keithley.Drive.pulsed

Type:	Keithley580.Drive

Keithley580.dry_circuit_test¶

Gets/sets the ‘dry circuit test’ mode of the Keithley 580.

This mode is used to minimize any physical and electrical changes in the contact junction by limiting the maximum source voltage to 20mV. By limiting the voltage, the measuring circuit will leave the resistive surface films built up on the contacts undisturbed. This allows for measurement of the resistance of these films.

See the Keithley 580 manual for more information.

Type:	bool

Keithley580.input_range¶

Gets/sets the range of the Keithley 580 input terminals. The valid ranges are one of {AUTO|2e-1|2|20|200|2000|2e4|2e5}

Type:	Quantity or str

Keithley580.operate¶

Gets/sets the operating mode of the Keithley 580. If set to true, the instrument will be in operate mode, while false sets the instruments into standby mode.

Type:	bool

Keithley580.polarity¶

Gets/sets instrument polarity.

Example use:

>>> import instruments as ik
>>> keithley = ik.keithley.Keithley580.open_gpibusb('/dev/ttyUSB0', 1)
>>> keithley.polarity = keithley.Polarity.positive

Type:	Keithley580.Polarity

Keithley580.relative¶

Gets/sets the relative measurement mode of the Keithley 580.

As stated in the manual: The relative function is used to establish a baseline reading. This reading is subtracted from all subsequent readings. The purpose of making relative measurements is to cancel test lead and offset resistances or to store an input as a reference level.

Once a relative level is established, it remains in effect until another relative level is set. The relative value is only good for the range the value was taken on and higher ranges. If a lower range is selected than that on which the relative was taken, inaccurate results may occur. Relative cannot be activated when “OL” is displayed.

See the manual for more information.

Type:	bool

Keithley580.trigger_mode¶

Gets/sets the trigger mode of the Keithley 580.

There are two different trigger settings for three different sources. This means there are six different settings for the trigger mode.

The two types are continuous and one-shot. Continuous has the instrument continuously sample the resistance. One-shot performs a single resistance measurement.

The three trigger sources are on talk, on GET, and on “X”. On talk refers to addressing the instrument to talk over GPIB. On GET is when the instrument receives the GPIB command byte for “group execute trigger”. Last, on “X” is when one sends the ASCII character “X” to the instrument. This character is used as a general execute to confirm commands send to the instrument. In InstrumentKit, “X” is sent after each command so it is not suggested that one uses on “X” triggering.

Type:	Keithley580.TriggerMode

The Keithley 2182 is a nano-voltmeter. You can find the full specifications list in the user’s guide.

Example usage:

>>> import instruments as ik
>>> meter = ik.keithley.Keithley2182.open_gpibusb("/dev/ttyUSB0", 10)
>>> print meter.measure(meter.Mode.voltage_dc)

class Channel(parent, idx)¶

Class representing a channel on the Keithley 2182 nano-voltmeter.

Warning

This class should NOT be manually created by the user. It is designed to be initialized by the Keithley2182 class.

measure(mode=None)¶

Performs a measurement of the specified channel. If no mode parameter is specified then the current mode is used.

Parameters:	mode (Keithley2182.Mode) – Mode that the measurement will be performed in
Returns:	The value of the measurement
Return type:	Quantity

input_range¶

mode¶

relative¶

trigger_mode¶

class Keithley2182.Mode¶

Enum containing valid measurement modes for the Keithley 2182

temperature = <Mode.temperature: 'TEMP'>¶

voltage_dc = <Mode.voltage_dc: 'VOLT'>¶

class Keithley2182.TriggerMode¶

Enum containing valid trigger modes for the Keithley 2182

bus = <TriggerMode.bus: 'BUS'>¶

external = <TriggerMode.external: 'EXT'>¶

immediate = <TriggerMode.immediate: 'IMM'>¶

manual = <TriggerMode.manual: 'MAN'>¶

timer = <TriggerMode.timer: 'TIM'>¶

Keithley2182.fetch()¶

Transfer readings from instrument memory to the output buffer, and thus to the computer. If currently taking a reading, the instrument will wait until it is complete before executing this command. Readings are NOT erased from memory when using fetch. Use the R? command to read and erase data. Note that the data is transfered as ASCII, and thus it is not recommended to transfer a large number of data points using GPIB.

Returns:	Measurement readings from the instrument output buffer.
Return type:	list of Quantity elements

Keithley2182.measure(mode=None)¶

Perform and transfer a measurement of the desired type.

Parameters:	mode – Desired measurement mode. If left at default the measurement will occur with the current mode.
Type:	Keithley2182.Mode
Returns:	Returns a single shot measurement of the specified mode.
Return type:	Quantity
Units:	Volts, Celsius, Kelvin, or Fahrenheit

Keithley2182.channel¶

Gets a specific Keithley 2182 channel object. The desired channel is specified like one would access a list.

Although not default, the 2182 has up to two channels.

For example, the following would print the measurement from channel 1:

>>> meter = ik.keithley.Keithley2182.open_gpibusb("/dev/ttyUSB0", 10)
>>> print meter.channel[0].measure()

Return type:	Keithley2182.Channel

Keithley2182.input_range¶

Keithley2182.relative¶

Gets/sets the relative measurement function of the Keithley 2182.

This is used to enable or disable the relative function for the currently set mode. When enabling, the current reading is used as a baseline which is subtracted from future measurements.

If relative is already on, the stored value is refreshed with the currently read value.

See the manual for more information.

Type:	bool

Keithley2182.units¶

Gets the current measurement units of the instrument.

Return type:	UnitQuantity

The Keithley 6220 is a single channel constant current supply.

Because this is a constant current supply, most features that a regular power supply have are not present on the 6220.

Example usage:

>>> import quantities as pq
>>> import instruments as ik
>>> ccs = ik.keithley.Keithley6220.open_gpibusb("/dev/ttyUSB0", 10)
>>> ccs.current = 10 * pq.milliamp # Sets current to 10mA
>>> ccs.disable() # Turns off the output and sets the current to 0A

disable()¶

Set the output current to zero and disable the output.