auspex.instruments package

Submodules

auspex.instruments.agilent module

class auspex.instruments.agilent.Agilent33220A(resource_name=None, *args, **kwargs)

Agilent 33220A Function Generator

FUNCTION_MAP = {'DC': 'DC', 'Noise': 'NOIS', 'Pulse': 'PULS', 'Ramp': 'RAMP', 'Sine': 'SIN', 'Square': 'SQU', 'User': 'USER'}

property amplitude

property auto_range

property burst_cycles

property burst_mode

property burst_state

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

property dc_offset

property frequency

property function

get_amplitude(**kwargs)

get_auto_range(**kwargs)

get_burst_cycles(**kwargs)

get_burst_mode(**kwargs)

get_burst_state(**kwargs)

get_dc_offset(**kwargs)

get_frequency(**kwargs)

get_function(**kwargs)

get_high_voltage(**kwargs)

get_load_resistance(**kwargs)

get_low_voltage(**kwargs)

get_output(**kwargs)

get_output_sync(**kwargs)

get_output_units(**kwargs)

get_polarity(**kwargs)

get_pulse_dcyc(**kwargs)

get_pulse_edge(**kwargs)

get_pulse_period(**kwargs)

get_pulse_width(**kwargs)

get_ramp_symmetry(**kwargs)

get_trigger_slope(**kwargs)

get_trigger_source(**kwargs)

property high_voltage

property load_resistance

property low_voltage

property output

property output_sync

property output_units

property polarity

property pulse_dcyc

property pulse_edge

property pulse_period

property pulse_width

property ramp_symmetry

set_amplitude(val, **kwargs)

set_auto_range(val, **kwargs)

set_burst_cycles(val, **kwargs)

set_burst_mode(val, **kwargs)

set_burst_state(val, **kwargs)

set_dc_offset(val, **kwargs)

set_frequency(val, **kwargs)

set_function(val, **kwargs)

set_high_voltage(val, **kwargs)

set_load_resistance(val, **kwargs)

set_low_voltage(val, **kwargs)

set_output(val, **kwargs)

set_output_sync(val, **kwargs)

set_output_units(val, **kwargs)

set_polarity(val, **kwargs)

set_pulse_dcyc(val, **kwargs)

set_pulse_edge(val, **kwargs)

set_pulse_period(val, **kwargs)

set_pulse_width(val, **kwargs)

set_ramp_symmetry(val, **kwargs)

set_trigger_slope(val, **kwargs)

set_trigger_source(val, **kwargs)

trigger()

property trigger_slope

property trigger_source

class auspex.instruments.agilent.Agilent33500B(resource_name=None, *args, **kwargs)

Agilent/Keysight 33500 series 2-channel Arbitrary Waveform Generator

Replacement model for 33220 series with some changes and additional sequencing functionality

FUNCTION_MAP = {'DC': 'DC', 'Noise': 'NOIS', 'PRBS': 'PRBS', 'Pulse': 'PULS', 'Ramp': 'RAMP', 'Sine': 'SIN', 'Square': 'SQU', 'Triangle': 'TRI', 'User': 'ARB'}

class Segment(name, data=[], dac=True, control='once', repeat=0, mkr_mode='maintain', mkr_pts=4)

self_check()

update(**kwargs)

class Sequence(name)

add_segment(segment, **kwargs): Create a copy of the segment, update its values, then add to the sequence. The copy and update are to allow reuse of the same segment with different configurations. For safety, avoid reuse, but add different segment objects to the sequence.

get_descriptor(): Return block descriptor to upload to the instrument

abort()

amplitude = <auspex.instruments.instrument.FloatCommand object>

arb_advance = <auspex.instruments.instrument.StringCommand object>

arb_amplitude = <auspex.instruments.instrument.FloatCommand object>

arb_frequency = <auspex.instruments.instrument.FloatCommand object>

arb_sample = <auspex.instruments.instrument.FloatCommand object>

arb_sync(): Restart the sequences and synchronize them

arb_waveform = <auspex.instruments.instrument.StringCommand object>

auto_range = <auspex.instruments.instrument.Command object>

burst_cycles = <auspex.instruments.instrument.FloatCommand object>

burst_mode = <auspex.instruments.instrument.StringCommand object>

burst_state = <auspex.instruments.instrument.Command object>

clear_waveform(channel=1): Clear all waveforms loaded in the memory

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

dc_offset = <auspex.instruments.instrument.FloatCommand object>

frequency = <auspex.instruments.instrument.FloatCommand object>

function = <auspex.instruments.instrument.StringCommand object>

get_amplitude(**kwargs)

get_arb_advance(**kwargs): Advance mode to the next point: ‘Trigger’ or ‘Srate’ (Sample Rate)

get_arb_amplitude(**kwargs)

get_arb_frequency(**kwargs)

get_arb_sample(**kwargs): Sample Rate

get_arb_waveform(**kwargs)

get_auto_range(**kwargs)

get_burst_cycles(**kwargs)

get_burst_mode(**kwargs)

get_burst_state(**kwargs)

get_dc_offset(**kwargs)

get_frequency(**kwargs)

get_function(**kwargs)

get_high_voltage(**kwargs)

get_load(**kwargs): Expected load resistance, 1-10k

get_low_voltage(**kwargs)

get_output(**kwargs)

get_output_gated(**kwargs)

get_output_sync(**kwargs)

get_output_trigger(**kwargs)

get_output_trigger_slope(**kwargs)

get_output_trigger_source(**kwargs)

get_output_units(**kwargs)

get_polarity(**kwargs)

get_pulse_dcyc(**kwargs)

get_pulse_edge(**kwargs)

get_pulse_period(**kwargs)

get_pulse_width(**kwargs)

get_ramp_symmetry(**kwargs)

get_sequence(**kwargs)

get_sync_mode(**kwargs)

get_sync_polarity(**kwargs)

get_sync_source(**kwargs)

get_trigger_slope(**kwargs)

get_trigger_source(**kwargs)

high_voltage = <auspex.instruments.instrument.FloatCommand object>

load = <auspex.instruments.instrument.FloatCommand object>

low_voltage = <auspex.instruments.instrument.FloatCommand object>

output = <auspex.instruments.instrument.Command object>

output_gated = <auspex.instruments.instrument.Command object>

output_sync = <auspex.instruments.instrument.Command object>

property output_trigger

property output_trigger_slope

property output_trigger_source

output_units = <auspex.instruments.instrument.Command object>

polarity = <auspex.instruments.instrument.Command object>

pulse_dcyc = <auspex.instruments.instrument.IntCommand object>

pulse_edge = <auspex.instruments.instrument.FloatCommand object>

pulse_period = <auspex.instruments.instrument.FloatCommand object>

pulse_width = <auspex.instruments.instrument.FloatCommand object>

property ramp_symmetry

sequence = <auspex.instruments.instrument.StringCommand object>

set_amplitude(val, **kwargs)

set_arb_advance(val, **kwargs): Advance mode to the next point: ‘Trigger’ or ‘Srate’ (Sample Rate)

set_arb_amplitude(val, **kwargs)

set_arb_frequency(val, **kwargs)

set_arb_sample(val, **kwargs): Sample Rate

set_arb_waveform(val, **kwargs)

set_auto_range(val, **kwargs)

set_burst_cycles(val, **kwargs)

set_burst_mode(val, **kwargs)

set_burst_state(val, **kwargs)

set_dc_offset(val, **kwargs)

set_frequency(val, **kwargs)

set_function(val, **kwargs)

set_high_voltage(val, **kwargs)

set_infinite_load(channel=1)

set_load(val, **kwargs): Expected load resistance, 1-10k

set_low_voltage(val, **kwargs)

set_output(val, **kwargs)

set_output_gated(val, **kwargs)

set_output_sync(val, **kwargs)

set_output_trigger(val, **kwargs)

set_output_trigger_slope(val, **kwargs)

set_output_trigger_source(val, **kwargs)

set_output_units(val, **kwargs)

set_polarity(val, **kwargs)

set_pulse_dcyc(val, **kwargs)

set_pulse_edge(val, **kwargs)

set_pulse_period(val, **kwargs)

set_pulse_width(val, **kwargs)

set_ramp_symmetry(val, **kwargs)

set_sequence(val, **kwargs)

set_sync_mode(val, **kwargs)

set_sync_polarity(val, **kwargs)

set_sync_source(val, **kwargs)

set_trigger_slope(val, **kwargs)

set_trigger_source(val, **kwargs)

sync_mode = <auspex.instruments.instrument.StringCommand object>

sync_polarity = <auspex.instruments.instrument.Command object>

property sync_source

trigger(channel=1)

property trigger_slope

property trigger_source

upload_sequence(sequence, channel=1, binary=False): Upload a sequence to the instrument

upload_waveform(data, channel=1, name='mywaveform', dac=True)

Load string-converted data into a waveform memory

dac: True if values are converted to integer already

upload_waveform_binary(data, channel=1, name='mywaveform', dac=True)

NOT YET WORKING - DO NOT USE Load binary data into a waveform memory

dac: True if values are converted to integer already

class auspex.instruments.agilent.Agilent34970A(resource_name=None, *args, **kwargs)

Agilent 34970A MUX

ADVSOUR_VALUES = ['EXT', 'BUS', 'IMM']

CONFIG_LIST = []

ONOFF_VALUES = ['ON', 'OFF']

PLC_VALUES = [0.02, 0.2, 1, 10, 20, 100, 200]

RES_VALUES = ['AUTO', 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0]

TRIGSOUR_VALUES = ['BUS', 'IMM', 'EXT', 'TIM']

property advance_source

ch_to_str(ch_list)

property channel_delay

property configlist

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

property dmm

get_advance_source(**kwargs)

get_dmm(**kwargs)

get_trigger_count(**kwargs)

get_trigger_source(**kwargs)

get_trigger_timer(**kwargs)

r_lists()

read()

property resistance_range

property resistance_resolution

property resistance_wire

property resistance_zcomp

scan()

property scanlist

set_advance_source(val, **kwargs)

set_dmm(val, **kwargs)

set_trigger_count(val, **kwargs)

set_trigger_source(val, **kwargs)

set_trigger_timer(val, **kwargs)

property trigger_count

property trigger_source

property trigger_timer

class auspex.instruments.agilent.AgilentE8363C(resource_name=None, *args, **kwargs)

Agilent E8363C 2-port 40GHz VNA.

data_query_raw = False

ports = (1, 2)

class auspex.instruments.agilent.AgilentN5183A(resource_name=None, *args, **kwargs)

AgilentN5183A microwave source

property alc

connect(resource_name=None, interface_type='VISA'): Either connect to the resource name specified during initialization, or specify a new resource name here.

property frequency

get_alc(**kwargs)

get_frequency(**kwargs)

get_mod(**kwargs)

get_output(**kwargs)

get_phase(**kwargs)

get_power(**kwargs)

instrument_type = 'Microwave Source'

property mod

property output

property phase

property power

property reference

set_alc(val, **kwargs)

set_all(settings)

set_frequency(val, **kwargs)

set_mod(val, **kwargs)

set_output(val, **kwargs)

set_phase(val, **kwargs)

set_power(val, **kwargs)

class auspex.instruments.agilent.AgilentN5230A(resource_name=None, *args, **kwargs)

Agilent N5230A 4-port 20GHz VNA.

data_query_raw = False

ports = (1, 2, 3, 4)

class auspex.instruments.agilent.AgilentN9010A(resource_name=None, *args, **kwargs)

Agilent N9010A SA

property averaging_count

clear_averaging()

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

property frequency_center

property frequency_span

property frequency_start

property frequency_stop

get_averaging_count(**kwargs)

get_axis()

get_frequency_center(**kwargs)

get_frequency_span(**kwargs)

get_frequency_start(**kwargs)

get_frequency_stop(**kwargs)

get_marker1_amplitude(**kwargs)

get_marker1_position(**kwargs)

get_mode(**kwargs)

get_num_sweep_points(**kwargs)

get_pn_carrier_freq(**kwargs)

get_pn_offset_start(**kwargs)

get_pn_offset_stop(**kwargs)

get_pn_trace(num=3)

get_resolution_bandwidth(**kwargs)

get_sweep_time(**kwargs)

get_trace(num=1)

get_video_auto(**kwargs)

get_video_bandwidth(**kwargs)

instrument_type = 'Spectrum Analyzer'

property marker1_amplitude

property marker1_position

property marker_X

Queries marker X-value.

Parameters:: marker (int) – Marker index (1-12).
Returns:: X axis value of selected marker.

property marker_Y

Queries marker Y-value.

Parameters:: marker (int) – Marker index (1-12).
Returns:: Trace value at selected marker.

marker_to_center(marker=1)

property mode

noise_marker(marker=1, enable=True)

Set/unset marker as a noise marker for noise figure measurements.

Parameters:

marker (int) – Index of marker, [1,12].
enable (bool) – Toggles between noise marker (True) and regular marker (False).

Returns:

None.

property num_sweep_points

peak_search(marker=1)

property pn_carrier_freq

property pn_offset_start

property pn_offset_stop

property resolution_bandwidth

restart_sweep(): Aborts current sweep and restarts.

set_averaging_count(val, **kwargs)

set_frequency_center(val, **kwargs)

set_frequency_span(val, **kwargs)

set_frequency_start(val, **kwargs)

set_frequency_stop(val, **kwargs)

set_marker1_amplitude(val, **kwargs)

set_marker1_position(val, **kwargs)

set_mode(val, **kwargs)

set_num_sweep_points(val, **kwargs)

set_pn_carrier_freq(val, **kwargs)

set_pn_offset_start(val, **kwargs)

set_pn_offset_stop(val, **kwargs)

set_resolution_bandwidth(val, **kwargs)

set_sweep_time(val, **kwargs)

set_video_auto(val, **kwargs)

set_video_bandwidth(val, **kwargs)

property sweep_time

property video_auto

property video_bandwidth

class auspex.instruments.agilent.HP33120A(resource_name=None, *args, **kwargs)

HP33120A Arb Waveform Generator

property amplitude

arb_function(name)

property burst_cycles

property burst_source

property burst_state

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

delete_waveform(name='all')

property duty_cycle

property frequency

property function

get_amplitude(**kwargs)

get_burst_cycles(**kwargs)

get_burst_source(**kwargs)

get_burst_state(**kwargs)

get_duty_cycle(**kwargs)

get_frequency(**kwargs)

get_function(**kwargs)

get_load(**kwargs)

get_offset(**kwargs)

get_voltage_unit(**kwargs)

property load

property offset

set_amplitude(val, **kwargs)

set_burst_cycles(val, **kwargs)

set_burst_source(val, **kwargs)

set_burst_state(val, **kwargs)

set_duty_cycle(val, **kwargs)

set_frequency(val, **kwargs)

set_function(val, **kwargs)

set_load(val, **kwargs)

set_offset(val, **kwargs)

set_voltage_unit(val, **kwargs)

upload_waveform(data, name='volatile')

property voltage_unit

auspex.instruments.alazar module

class auspex.instruments.alazar.AlazarATS9870(resource_name=None, name='Unlabeled Alazar', gen_fake_data=False)

Alazar ATS9870 digitizer

acquire()

add_channel(channel)

configure_with_dict(settings_dict): Accept a sdettings dictionary and attempt to set all of the instrument parameters using the key/value pairs.

connect(resource_name=None)

data_available()

disconnect()

done()

get_buffer_for_channel(channel)

get_socket(channel)

instrument_type = 'Digitizer'

receive_data(channel, oc, exit, ready, run)

spew_fake_data(counter, ideal_data, random_mag=0.1, random_seed=12345)

Generate fake data on the stream. For unittest usage. ideal_data: array or list giving means of the expected signal for each segment

Returns the total number of fake data points, so that we can keep track of how many we expect to receive, when we’re doing the test with fake data

stop()

wait_for_acquisition(dig_run, timeout=5, ocs=None, progressbars=None)

class auspex.instruments.alazar.AlazarChannel(receiver_channel=None)

phys_channel = None

set_all(settings_dict)

set_by_receiver(receiver)

auspex.instruments.ami module

class auspex.instruments.ami.AMI430(resource_name, *args, **kwargs)

AMI430 Power Supply Programmer

RAMPING_STATES = ['RAMPING to target field/current', 'HOLDING at the target field/current', 'PAUSED', 'Ramping in MANUAL UP mode', 'Ramping in MANUAL DOWN mode', 'ZEROING CURRENT (in progress)', 'Quench detected', 'At ZERO current', 'Heating persistent switch', 'Cooling persistent switch']

SUPPLY_TYPES = ['AMI 12100PS', 'AMI 12200PS', 'AMI 4Q05100PS', 'AMI 4Q06125PS', 'AMI 4Q06250PS', 'AMI 4Q12125PS', 'AMI 10100PS', 'AMI 10200PS', 'HP 6260B', 'Kepco BOP 20-5M', 'Kepco BOP 20-10M', 'Xantrex XFR 7.5-140', 'Custom', 'AMI Model 05100PS-430-601', 'AMI Model 05200PS-430-601', 'AMI Model 05300PS-430-601', 'AMI Model 05400PS-430-601', 'AMI Model 05500PS-430-601']

property absorber

property coil_const

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

property current_limit

property current_magnet

property current_max

property current_min

property current_rating

property current_supply

property current_target

property field

property field_target

property field_units

get_absorber(**kwargs)

get_coil_const(**kwargs)

get_current_limit(**kwargs)

get_current_magnet(**kwargs)

get_current_max(**kwargs)

get_current_min(**kwargs)

get_current_rating(**kwargs)

get_current_supply(**kwargs)

get_current_target(**kwargs)

get_field(**kwargs)

get_field_target(**kwargs)

get_field_units(**kwargs)

get_inductance(**kwargs)

get_persistent_switch(**kwargs)

get_ramp_num_segments(**kwargs)

get_ramp_rate_units(**kwargs)

get_ramping_state(**kwargs)

get_stability(**kwargs)

get_supply_type(**kwargs)

get_voltage(**kwargs)

get_voltage_limit(**kwargs)

get_voltage_max(**kwargs)

get_voltage_min(**kwargs)

property inductance

instrument_type = 'Magnet'

pause(): Pauses the Model 430 Programmer at the present operating field/current.

property persistent_switch

ramp(): Places the Model 430 Programmer in automatic ramping mode. The Model 430 will continue to ramp at the configured ramp rate(s) until the target field/current is achieved.

ramp_down(): Places the Model 430 Programmer in the MANUAL DOWN ramping mode. Ramping continues at the ramp rate until the Current Limit is achieved (or zero current is achieved for unipolar power supplies).

property ramp_num_segments

property ramp_rate_units

ramp_up(): Places the Model 430 Programmer in the MANUAL UP ramping mode. Ramping continues at the ramp rate until the Current Limit is achieved.

property ramping_state

set_absorber(val, **kwargs)

set_coil_const(val, **kwargs)

set_current_limit(val, **kwargs)

set_current_rating(val, **kwargs)

set_current_target(val, **kwargs)

set_field(val): Blocking field setter

set_field_target(val, **kwargs)

set_field_units(val, **kwargs)

set_persistent_switch(val, **kwargs)

set_ramp_num_segments(val, **kwargs)

set_ramp_rate_units(val, **kwargs)

set_stability(val, **kwargs)

set_voltage_limit(val, **kwargs)

property stability

property supply_type

property voltage

property voltage_limit

property voltage_max

property voltage_min

zero(): Places the Model 430 Programmer in ZEROING CURRENT mode. Ramping automatically initiates and continues at the ramp rate until the power supply output current is less than 0.1% of Imax, at which point the AT ZERO status becomes active.

auspex.instruments.bbn module

class auspex.instruments.bbn.APS(resource_name=None, name='Unlabled APS')

BBN APSI or DACII

configure_with_proxy(proxy_obj)

connect(resource_name=None)

disconnect()

get_mixer_correction_matrix()

get_repeat_mode()

get_run_mode()

get_sampling_rate()

get_sequence_file()

get_trigger_interval()

get_trigger_source()

get_waveform_frequency()

instrument_type = 'AWG'

load_waveform(channel, data)

load_waveform_from_file(channel, filename)

property mixer_correction_matrix

property repeat_mode

property run_mode

property sampling_rate

property sequence_file

set_amplitude(chs, value)

set_mixer_amplitude_imbalance(chs, amp)

set_mixer_correction_matrix = None

set_mixer_phase_skew(chs, phase, SSB=0.0)

set_offset(chs, value)

set_repeat_mode(mode)

set_run_mode(mode)

set_sampling_rate(freq)

set_sequence_file(filename)

set_trigger_interval(value)

set_trigger_source(source)

set_waveform_frequency = None

trigger()

property trigger_interval

property trigger_source

property waveform_frequency

class auspex.instruments.bbn.APS2(resource_name=None, name='Unlabeled APS2')

BBN APS2

property amp_factor

configure_with_proxy(proxy_obj)

connect(resource_name=None)

disconnect()

property fpga_temperature

get_amp_factor()

get_fpga_temperature()

get_mixer_correction_matrix()

get_phase_skew()

get_run_mode()

get_sampling_rate()

get_sequence_file()

get_trigger_interval()

get_trigger_source()

get_waveform_frequency()

instrument_type = 'AWG'

load_waveform(channel, data)

property mixer_correction_matrix

property phase_skew

property run_mode

property sampling_rate

property sequence_file

set_amp_factor(amp)

set_amplitude(chs, value)

set_fpga_temperature = None

set_mixer_correction_matrix(matrix)

set_offset(chs, value)

set_phase_skew(skew)

set_run_mode(mode)

set_sampling_rate(value)

set_sequence_file(filename)

set_trigger_interval(value)

set_trigger_source(source)

set_waveform_frequency(freq)

trigger()

property trigger_interval

property trigger_source

property waveform_frequency

class auspex.instruments.bbn.DigitalAttenuator(resource_name=None, name='Unlabeled Digital Attenuator')

BBN 3 Channel Instrument

NUM_CHANNELS = 3

property ch1_attenuation

property ch2_attenuation

property ch3_attenuation

classmethod channel_check(chan): Assert the channel requested is feasbile

configure_with_proxy(proxy)

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

get_attenuation(chan)

instrument_type = 'Attenuator'

set_attenuation(chan, val)

class auspex.instruments.bbn.SpectrumAnalyzer(resource_name=None, *args, **kwargs)

BBN USB Spectrum Analyzer

IF_FREQ = 10700000.0

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

get_voltage()

instrument_type = 'Spectrum analyzer'

peak_amplitude()

property voltage

class auspex.instruments.bbn.TDM(resource_name=None, name='Unlabeled APS2')

BBN TDM

configure_with_proxy(proxy_obj)

instrument_type = 'AWG'

auspex.instruments.binutils module

class auspex.instruments.binutils.BitField(width): Bit field in a bit field union

class auspex.instruments.binutils.BitFieldUnion(**kwargs)

Painless bit packing

packed = 0

class auspex.instruments.binutils.BitFieldUnionMeta(name, bases, dct): Metaclass for injecting bitfield descriptors

auspex.instruments.bnc module

class auspex.instruments.bnc.BNC845(resource_name=None, *args, **kwargs)

SCPI instrument driver for Berkely Nucleonics BNC845-M RF Signal Generator.

Properties:: frequency: Set the RF generator frequency, in Hz. 0.01-20 GHz. power: Set the RF generator output power, in dBm. No effect, BNC845M output is always +16dBm. output: Toggle RF signal output on/off. pulse: Toggle RF pulsed mode on/off. alc: Toggle source Auto Leveling on/off. mod: Toggle amplitude modulation on/off. pulse_source: Set pulse trigger to INTERNAL or EXTERNAL. freq_source: Set frequency source to INTERNAL or EXTERNAL.

property alc

connect(resource_name=None, interface_type='VISA')

Connect to the RF source via a specified physical interface. Defaults to the IP address given at instatiation and the VISA interface if these arguments are not given.

Parameters:

resource_name – IP address of BNC. Defaults to None.
interface_type – Physical interface for communication. Default is None, indicating use of PyVISA.

Returns:

None.

property freq_source

property frequency

get_alc(**kwargs)

get_freq_source(**kwargs)

get_frequency(**kwargs)

get_mod(**kwargs)

get_output(**kwargs)

get_power(**kwargs)

get_pulse(**kwargs)

get_pulse_source(**kwargs)

instrument_type = 'Microwave Source'

property mod

property output

property power

property pulse

property pulse_source

reference = '10MHz'

set_alc(val, **kwargs)

set_freq_source(val, **kwargs)

set_frequency(val, **kwargs)

set_mod(val, **kwargs)

set_output(val, **kwargs)

set_power(val, **kwargs)

set_pulse(val, **kwargs)

set_pulse_source(val, **kwargs)

auspex.instruments.hall_probe module

class auspex.instruments.hall_probe.HallProbe(calibration_file, supply_voltage_method, readout_voltage_method)

Simple wrapper for converting Hall probe voltage measurements to actual fields values.

property field

get_field()

auspex.instruments.holzworth module

class auspex.instruments.holzworth.HolzworthHS9000(*args, **kwargs)

auspex.instruments.instrument module

class auspex.instruments.instrument.Instrument

configure_with_dict(settings_dict): Accept a sdettings dictionary and attempt to set all of the instrument parameters using the key/value pairs.

configure_with_proxy(proxy)

connect(resource_name=None)

disconnect()

auspex.instruments.interface module

class auspex.instruments.interface.Interface

Currently just a dummy interface for testing.

close()

query(value)

values(query)

write(value)

class auspex.instruments.interface.PrologixInterface(resource_name): Prologix-Ethernet interface for communicating with remote GPIB instruments.

class auspex.instruments.interface.VisaInterface(resource_name)

PyVISA interface for communicating with instruments.

CLS()

ESE()

ESR()

IDN()

OPC()

RST()

SRE()

STB()

TST()

WAI()

close()

query(query_string)

query_ascii_values(query_string, **kwargs)

query_binary_values(query_string, container=<built-in function array>, datatype='h', is_big_endian=False)

read()

read_bytes(count, chunk_size=None, break_on_termchar=False)

read_raw(size=None)

value(query_string)

values(query_string)

write(write_string)

write_binary_values(query_string, values, **kwargs)

write_raw(raw_string)

auspex.instruments.keithley module

class auspex.instruments.keithley.Keithley2400(resource_name, *args, **kwargs)

Keithley2400 Sourcemeter

MODE_VALS = ['SWE', 'LIST', 'FIX']

SENSE_VALS = ['VOLT', 'CURR', 'RES']

SOUR_VALS = ['VOLT', 'CURR']

SWEEP_ABOR = ['NEV', 'EARL', 'LATE']

SWEEP_DIR = ['UP', 'DOWN']

SWEEP_RANG = ['BEST', 'AUTO', 'FIX']

SWEEP_SPACE = ['LIN', 'LOG']

beep(freq, dur)

property compliance

property concurrent

conf_meas_res(NPLC=1, res_range=1000.0, auto_range=True)

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

property current

get_concurrent(**kwargs)

get_current(**kwargs)

get_output(**kwargs)

get_resistance(**kwargs)

get_sense(**kwargs)

get_source(**kwargs)

get_sweep_abort(**kwargs)

get_sweep_direction(**kwargs)

get_sweep_points(**kwargs)

get_sweep_range(**kwargs)

get_sweep_space(**kwargs)

get_voltage(**kwargs)

property level

property mode

property output

property resistance

property sense

property sense_range

set_concurrent(val, **kwargs)

set_output(val, **kwargs)

set_sense(val, **kwargs)

set_source(val, **kwargs)

set_sweep_abort(val, **kwargs)

set_sweep_direction(val, **kwargs)

set_sweep_points(val, **kwargs)

set_sweep_range(val, **kwargs)

set_sweep_space(val, **kwargs)

property source

property source_range

sweep()

property sweep_abort

property sweep_direction

property sweep_points

property sweep_range

property sweep_space

property sweep_start

property sweep_step

property sweep_stop

triad(freq=440, duration=0.2, minor=False, down=False)

property voltage

auspex.instruments.kepco module

class auspex.instruments.kepco.BOP2020M(name, resource_name, mode='current', **kwargs)

For controlling the BOP2020M power supply via GPIB interface card

property current

get_current(**kwargs)

get_mode(**kwargs)

get_output(**kwargs)

get_voltage(**kwargs)

property mode

property output

set_current(val, **kwargs)

set_mode(val, **kwargs)

set_output(val, **kwargs)

set_voltage(val, **kwargs)

shutdown()

property voltage

auspex.instruments.keysight module

class auspex.instruments.keysight.KeysightM8190A(resource_name, *args, **kwargs)

Keysight M8190A arbitrary waveform generator

abort(): Abort/stop signal generation on a channel

advance(channel=1)

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

property continuous_mode

property coupled

static create_binary_wf_data(wf, sync_mkr=0, samp_mkr=0, vertical_resolution=12): Given numpy arrays of waveform and marker data convert to binary format. Assumes waveform data is np.float in range -1 to 1 and marker data can be cast to bool Binary format is waveform in MSB and and markers in LSB waveform sync_mkr samp_mkr 15 downto 4/2 1 0

define_waveform(length, segment_id=None, channel=1)

delete_all_waveforms(channel=1)

delete_waveform(segment_id, channel=1)

property gate_mode

get_continuous_mode(**kwargs)

get_coupled(**kwargs)

get_gate_mode(**kwargs)

get_marker_level_high(**kwargs)

get_marker_level_low(**kwargs)

get_output(**kwargs)

get_output_complement(**kwargs)

get_output_route(**kwargs)

get_ref_source(**kwargs)

get_ref_source_available(source): Checks whether reference source is available

get_ref_source_freq(**kwargs)

get_sample_freq(**kwargs)

get_sample_freq_ext(**kwargs)

get_sample_freq_source(**kwargs)

get_scenario_advance_mode(**kwargs)

get_scenario_loop_ct(**kwargs)

get_scenario_start_index(**kwargs)

get_sequence_mode(**kwargs)

get_trigger_frequency(**kwargs)

get_voltage_amplitude(**kwargs)

get_voltage_offset(**kwargs)

get_waveform_output_mode(**kwargs)

initiate(channel=1)

marker_level_high = <auspex.instruments.instrument.FloatCommand object>

marker_level_low = <auspex.instruments.instrument.FloatCommand object>

output = <auspex.instruments.instrument.StringCommand object>

output_complement = <auspex.instruments.instrument.StringCommand object>

output_route = <auspex.instruments.instrument.StringCommand object>

property ref_source

property ref_source_freq

reset_sequence_table(channel=1)

property sample_freq

property sample_freq_ext

property sample_freq_source

scenario_advance_mode = <auspex.instruments.instrument.StringCommand object>

scenario_loop_ct = <auspex.instruments.instrument.IntCommand object>

scenario_start_index = <auspex.instruments.instrument.IntCommand object>

select_waveform(segment_id, channel=1)

sequence_mode = <auspex.instruments.instrument.StringCommand object>

set_continuous_mode(val, **kwargs)

set_coupled(val, **kwargs)

set_gate_mode(val, **kwargs)

set_marker_level_high(val, **kwargs)

set_marker_level_low(val, **kwargs)

set_output(val, **kwargs)

set_output_complement(val, **kwargs)

set_output_route(val, **kwargs)

set_ref_source(val, **kwargs)

set_ref_source_freq(val, **kwargs)

set_sample_freq(val, **kwargs)

set_sample_freq_ext(val, **kwargs)

set_sample_freq_source(val, **kwargs)

set_scenario_advance_mode(val, **kwargs)

set_scenario_loop_ct(val, **kwargs)

set_scenario_start_index(val, **kwargs)

set_sequence_mode(val, **kwargs)

set_trigger_frequency(val, **kwargs)

set_voltage_amplitude(val, **kwargs)

set_voltage_offset(val, **kwargs)

set_waveform_output_mode(val, **kwargs)

trigger(channel=1)

property trigger_frequency

upload_scenario(scenario, channel=1, start_idx=0, binary=True)

upload_waveform(wf_data, segment_id, channel=1, binary=True): Uploads the waveform to the device. Technically we should split the data into multiple chunks if we exceed the 999999999 Bytes, i.e. 1GB SCPI transfer limit.

use_waveform(wf_data, segment_id=None, channel=1)

voltage_amplitude = <auspex.instruments.instrument.FloatCommand object>

voltage_offset = <auspex.instruments.instrument.FloatCommand object>

waveform_output_mode = <auspex.instruments.instrument.StringCommand object>

class auspex.instruments.keysight.Scenario

Bundle of sequences as a “scenario”

scpi_strings(start_idx=0)

table()

class auspex.instruments.keysight.Sequence(sequence_loop_ct=1)

Bundle of sequence table entries as a “sequence”

add_command()

add_idle(length, amp=0)

add_waveform(segment_id, **kwargs)

scpi_strings(): Returns a list of SCPI strings that can be pushed to instrument after formatting with index

table(): Return a 2D array of UInt32 representing the sequence

auspex.instruments.lakeshore module

class auspex.instruments.lakeshore.LakeShore335(resource_name=None, *args, **kwargs)

LakeShore 335 Temperature Controller

HTR_CTR_VALS = [0, 1, 2]

HTR_RNG_VALS = [0, 1, 2, 3]

HTR_VALS = [0, 1, 2, 3, 4, 5]

R_VALS = [0, 1, 2, 3, 4, 5, 6, 7, 8]

SENTYPE_VALS = [0, 1, 2, 3, 4]

T_VALS = ['A', 'B']

Temp(sense='A')

UNIT_VALS = [1, 2, 3]

ZO_VALS = [0, 1]

check_hconf_msg(vals)

check_htr_msg(vals)

check_pid_msg(vals)

check_range_msg(val)

check_sense_msg(vals)

property config_htr_1

property config_htr_2

property config_sense_A

property config_sense_B

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

property control_htr_1

property control_htr_2

property mout_htr_1

property mout_htr_2

property pid_htr_1

property pid_htr_2

property range_htr_1

property range_htr_2

property temp_htr_1

property temp_htr_2

class auspex.instruments.lakeshore.LakeShore370(resource_name=None, *args, **kwargs)

Lakeshore 370 AC Resistance Bridge

D_MAX = 2500

HEATER_DISPLAY_MAP = {'Current': 1, 'Power': 2}

HEATER_RANGE_MAP = {0: '0', 3.16e-05: '1', 0.0001: '2', 0.000316: '3', 0.001: '4', 0.00316: '5', 0.01: '6', 0.0316: '7', 0.1: '8'}

HEATER_RES_MAX = 100000

HEATER_RES_MIN = 1

HEATER_UNITS_MAP = {'Kelvin': 1, 'Ohms': 2}

HEATER_VALUES = [0, 3.16e-05, 0.0001, 0.000316, 0.001, 0.00316, 0.01, 0.0316, 0.1]

I_MAX = 10000

MAX_TEMP = 0.3

P_MAX = 1000

P_MIN = 0.001

RAMP_MAX = 10

RAMP_MIN = 0.001

SENS_CHAN = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]

check_channel(chan)

check_pid(P, I, D)

check_ramp_rate(rate)

check_resistance(R)

check_setp(T)

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

property control_mode

property control_setup

Get current temperature control setup. :param None.:

Returns:

(Channel, Filtered or Unfiltered, Setpoint units,: autoscan delay (seconds), display units, current limit, resistance)

Return type:

setup

get_control_mode(**kwargs)

get_heater_output(**kwargs)

get_heater_range(**kwargs)

get_heater_setting(**kwargs)

get_heater_status(**kwargs)

heater_off()

Turn off heater. :param None.:

Returns:: None.

property heater_output

property heater_range

property heater_setting

property heater_status

property pid: Get PID values. Returns tuple (P,I,D).

property ramp: Get setpoint ramp status or value. Returns 0 if ramping is off.

property ramp_state: Check if ramping to temperature setpoint.

resistance(chan)

Get Lakshore resistance reading for a specific channel.

Parameters:: chan – Channel to be queried.
Returns:: Channel resistance in Ohms.
Return type:: temp

set_control_mode(val, **kwargs)

set_control_setup(channel, limit, resistance, units='Kelvin', delay=10.0, filter=True, display='Power')

Set up the heater control parameters.

Parameters:

channel – Channel to control, 1-16.
limit – Heater output current limit.
resistance – Heater resistance.
units – Heater setpoint units. Kelvin or Ohms.
delay – Delay in seconds for setpoint change during autoscanning: 1-255 seconds.
filter – Control on filtered or unfilitered readings.
display – Heater output display. Power or Current.

Returns:

None.

set_heater_range(val, **kwargs)

set_heater_setting(val, **kwargs)

set_pid(P, I, D): Set PID parameters.

property setpoint: Get current temperature setpoint.

temp(chan)

Get Lakshore temperature reading for a specific channel.

Parameters:: chan – Channel to be queried.
Returns:: Channel temperature in Kelvin.
Return type:: temp

auspex.instruments.lecroy module

class auspex.instruments.lecroy.HDO6104(resource_name=None, name='Yet-to-be-named SCPI Instrument')

channel_enabled = <auspex.instruments.instrument.Command object>

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

fetch_waveform(channel)

get_channel_enabled(**kwargs)

get_info(channel=1)

get_sample_points(**kwargs)

get_time_div(**kwargs)

get_trig_delay(**kwargs)

get_trig_mode(**kwargs)

get_vol_div(**kwargs)

get_vol_offset(**kwargs)

property sample_points

set_channel_enabled(val, **kwargs)

set_sample_points(val, **kwargs)

set_time_div(val, **kwargs)

set_trig_delay(val, **kwargs)

set_trig_mode(val, **kwargs)

set_vol_div(val, **kwargs)

set_vol_offset(val, **kwargs)

property time_div

property trig_delay

property trig_mode

vol_div = <auspex.instruments.instrument.Command object>

vol_offset = <auspex.instruments.instrument.Command object>

auspex.instruments.magnet module

class auspex.instruments.magnet.Electromagnet(calibration_file, field_getter, current_setter, current_getter, field_averages=5)

Wrapper for electromagnet

property field

get_field()

set_field(value)

auspex.instruments.picosecond module

class auspex.instruments.picosecond.Picosecond10070A(resource_name, *args, **kwargs)

Picosecond 10070A Pulser

property amplitude

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

property delay

property duration

property frequency

get_amplitude(**kwargs)

get_delay(**kwargs)

get_duration(**kwargs)

get_frequency(**kwargs)

get_offset(**kwargs)

get_period(**kwargs)

get_trigger_level(**kwargs)

get_trigger_source(**kwargs)

property offset

property output

property period

set_amplitude(val, **kwargs)

set_delay(val, **kwargs)

set_duration(val, **kwargs)

set_frequency(val, **kwargs)

set_offset(val, **kwargs)

set_period(val, **kwargs)

set_trigger_level(val, **kwargs)

set_trigger_source(val, **kwargs)

trigger()

property trigger_level

property trigger_source

auspex.instruments.prologix module

class auspex.instruments.prologix.PrologixSocketResource(ipaddr=None, gpib=None)

A resource representing a GPIB instrument controlled through a PrologixError GPIB-ETHERNET controller. Mimics the functionality of a pyVISA resource object.

See http://prologix.biz/gpib-ethernet-controller.html for more details and a utility that will discover all prologix instruments on the network.

timeout: Timeout duration for TCP comms. Default 5s.

write_termination: Character added to each outgoing message.

read_termination: Character which denotes the end of a reponse message.

idn_string: GPIB identification command. Defaults to ‘*IDN?’

bufsize: Maximum amount of data to be received in one call, in bytes.

close(): Close the connection to the Prologix.

connect(ipaddr=None, gpib=None)

Connect to a GPIB device through a Prologix GPIB-ETHERNET controller. box.

Parameters:

ipaddr – The IP address of the Prologix GPIB-ETHERNET.
gpib – The GPIB address of the instrument to be controlled.

Returns:

None.

query(command)

Query instrument with ASCII command then read response.

Parameters:: command – Message to be sent to instrument.
Returns:: The instrument data with termination character stripped.

query_ascii_values(command, converter='f', separator=', ', container=<class 'list'>, bufsize=None)

Write a string message to device and return values as iterable.

Parameters:

command – Message to be sent to device.
values – Data to be written to device (as an interable)
converter – String format code to be used to convert values.
separator – Separator between values – data.split(separator).
container – Iterable type to use for output.
bufsize – Number of bytes to read from instrument. Defaults to resource
None. (bufsize if)

Returns:

Iterable of values converted from instrument response.

query_binary_values(command, datatype='f', container=<built-in function array>, is_big_endian=False, bufsize=None)

Write a string message to device and read binary values, which are returned as iterable. Uses a pyvisa utility function.

Parameters:

command – String command sent to instrument.
values – Data to be sent to instrument.
datatype – Format string for single element.
container – Iterable to return number of as.
is_big_endian – Bool indicating endianness.

Returns:

Iterable of data values to be retuned

read()

Read an ASCII value from the instrument.

Parameters:: None.
Returns:: The instrument data with termination character stripped.

read_raw(bufsize=None)

Read bytes from instrument.

Parameters:

bufsize – Number of bytes to read from instrument. Defaults to resource
None. (bufsize if)

Returns:

Instrument data. Nothing is stripped from response.

property timeout

write(command)

Write a string message to device in ASCII format.

Parameters:: command – The message to be sent.
Returns:: The number of bytes in the message.

write_ascii_values(command, values, converter='f', separator=',')

Write a string message to device followed by values in ASCII format.

Parameters:

command – Message to be sent to device.
values – Data to be written to device (as an iterable)
converter – String format code to be used to convert values.
separator – Separator between values – separator.join(data).

Returns:

Total number of bytes sent to instrument.

write_binary_values(command, values, datatype='f', is_big_endian=False)

Write a string message to device followed by values in binary IEEE format using a pyvisa utility function.)

Parameters:

command – String command sent to instrument.
values – Data to be sent to instrument.
datatype – Format string for single element.
is_big_endian – Bool indicating endianness.

Returns:

Number of bytes written to instrument.

write_raw(command)

Write a string message to device as raw bytes. No termination character is appended.

Parameters:: command – The message to be sent.
Returns:: The number of bytes in the message.

auspex.instruments.rfmd module

class auspex.instruments.rfmd.RFMDAttenuator(calibration_file)

Simple wrapper for using the RFMD voltage controller attenuator. Remember that the calibration values for attenuation will be referenced to a certain point in the circuit.

property attenuation

maximum_atten()

minimum_atten()

set_attenuation(value)

set_control_method(func)

set_supply_method(func)

supply_level = 3.0

auspex.instruments.stanford module

class auspex.instruments.stanford.SR830(resource_name=None, *args, **kwargs)

The SR830 lock-in amplifier.

CHANNEL1_MAP = {'Aux In 1': '3,0', 'Aux In 2': '4,0', 'R': '1,0', 'X': '0,0', 'X Noise': '2,0'}

CHANNEL1_VALUES = ['X', 'R', 'X Noise', 'Aux In 1', 'Aux In 2']

CHANNEL2_MAP = {'Aux In 3': '3,0', 'Aux In 4': '4,0', 'Theta': '1,0', 'Y': '0,0', 'Y Noise': '2,0'}

CHANNEL2_VALUES = ['Y', 'Theta', 'Y Noise', 'Aux In 3', 'Aux In 4']

EXPANSION_MAP = {0: '0', 10: '1', 100: '2'}

EXPANSION_VALUES = [0, 10, 100]

FILTER_SLOPE_MAP = {6: '0', 12: '1', 18: '2', 24: '3'}

FILTER_SLOPE_VALUES = [6, 12, 18, 24]

RESERVE_MAP = {'High Reserve': '0', 'Low Noise': '2', 'Normal': '1'}

RESERVE_VALUES = ['High Reserve', 'Normal', 'Low Noise']

SAMPLE_RATE_MAP = {'Trigger': '14', 0.0625: '0', 0.125: '1', 0.25: '2', 0.5: '3', 1: '4', 128: '11', 16: '8', 2: '5', 256: '12', 32: '9', 4: '6', 512: '13', 64: '10', 8: '7'}

SAMPLE_RATE_VALUES = [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 'Trigger']

SENSITIVITY_MAP = {2e-09: '0', 5e-09: '1', 1e-08: '2', 2e-08: '3', 5e-08: '4', 1e-07: '5', 2e-07: '6', 5e-07: '7', 1e-06: '8', 2e-06: '9', 5e-06: '10', 1e-05: '11', 2e-05: '12', 5e-05: '13', 0.0001: '14', 0.0002: '15', 0.0005: '16', 0.001: '17', 0.002: '18', 0.005: '19', 0.01: '20', 0.02: '21', 0.05: '22', 0.1: '23', 0.2: '24', 0.5: '25', 1: '26'}

SENSITIVITY_VALUES = [2e-09, 5e-09, 1e-08, 2e-08, 5e-08, 1e-07, 2e-07, 5e-07, 1e-06, 2e-06, 5e-06, 1e-05, 2e-05, 5e-05, 0.0001, 0.0002, 0.0005, 0.001, 0.002, 0.005, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1]

property TC

TIME_CONSTANT_MAP = {1e-05: '0', 3e-05: '1', 0.0001: '2', 0.0003: '3', 0.001: '4', 0.003: '5', 0.01: '6', 0.03: '7', 0.1: '8', 0.3: '9', 1: '10', 3: '13', 10: '12', 100: '14', 300: '15', 1000.0: '16', 3000.0: '17', 10000.0: '18', 30000.0: '19'}

TIME_CONSTANT_VALUES = [1e-05, 3e-05, 0.0001, 0.0003, 0.001, 0.003, 0.01, 0.03, 0.1, 0.3, 1, 3, 10, 3, 100, 300, 1000.0, 3000.0, 10000.0, 30000.0]

property ai1

property ai2

property ai3

property ai4

property amplitude

property ao1

property ao2

property ao3

property ao4

property aux_in_1

property aux_in_2

property aux_in_3

property aux_in_4

property aux_out_1

property aux_out_2

property aux_out_3

property aux_out_4

property buffer_mode

buffer_pause()

property buffer_points

buffer_reset()

buffer_start()

property buffer_trigger_mode

property ch1

property ch2

property channel_1

property channel_1_type

property channel_2

property channel_2_type

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

property filter_slope

property freq

property frequency

get_TC(**kwargs)

get_ai1(**kwargs)

get_ai2(**kwargs)

get_ai3(**kwargs)

get_ai4(**kwargs)

get_amplitude(**kwargs)

get_ao1(**kwargs)

get_ao2(**kwargs)

get_ao3(**kwargs)

get_ao4(**kwargs)

get_aux_in_1(**kwargs)

get_aux_in_2(**kwargs)

get_aux_in_3(**kwargs)

get_aux_in_4(**kwargs)

get_aux_out_1(**kwargs)

get_aux_out_2(**kwargs)

get_aux_out_3(**kwargs)

get_aux_out_4(**kwargs)

get_buffer(channel)

get_buffer_mode(**kwargs)

get_buffer_points(**kwargs)

get_buffer_trigger_mode(**kwargs)

get_ch1(**kwargs)

get_ch2(**kwargs)

get_channel_1(**kwargs)

get_channel_1_type(**kwargs)

get_channel_2(**kwargs)

get_channel_2_type(**kwargs)

get_filter_slope(**kwargs)

get_freq(**kwargs)

get_frequency(**kwargs)

get_mag(**kwargs)

get_magnitude(**kwargs)

get_phase(**kwargs)

get_r(**kwargs)

get_reserve_mode(**kwargs)

get_sample_rate(**kwargs)

get_sensitivity(**kwargs)

get_tc(**kwargs)

get_theta(**kwargs)

get_time_constant(**kwargs)

get_x(**kwargs)

get_y(**kwargs)

property mag

property magnitude

measure_delay(): Return how long we must wait for the values to have settled, based on the filter slope.

property phase

property r

property reserve_mode

property sample_rate

property sensitivity

set_TC(val, **kwargs)

set_amplitude(val, **kwargs)

set_ao1(val, **kwargs)

set_ao2(val, **kwargs)

set_ao3(val, **kwargs)

set_ao4(val, **kwargs)

set_aux_out_1(val, **kwargs)

set_aux_out_2(val, **kwargs)

set_aux_out_3(val, **kwargs)

set_aux_out_4(val, **kwargs)

set_buffer_mode(val, **kwargs)

set_buffer_trigger_mode(val, **kwargs)

set_channel_1_type(val, **kwargs)

set_channel_2_type(val, **kwargs)

set_filter_slope(val, **kwargs)

set_freq(val, **kwargs)

set_frequency(val, **kwargs)

set_phase(val, **kwargs)

set_reserve_mode(val, **kwargs)

set_sample_rate(val, **kwargs)

set_sensitivity(val, **kwargs)

set_tc(val, **kwargs)

set_time_constant(val, **kwargs)

property tc

property theta

property time_constant

trigger()

property x

property y

class auspex.instruments.stanford.SR865(resource_name=None, *args, **kwargs)

The SR865 lock-in amplifier.

CHANNEL1_MAP = {'Aux In 1': '3,0', 'Aux In 2': '4,0', 'R': '1,0', 'X': '0,0', 'X Noise': '2,0'}

CHANNEL1_VALUES = ['X', 'R', 'X Noise', 'Aux In 1', 'Aux In 2']

CHANNEL2_MAP = {'Aux In 3': '3,0', 'Aux In 4': '4,0', 'Theta': '1,0', 'Y': '0,0', 'Y Noise': '2,0'}

CHANNEL2_VALUES = ['Y', 'Theta', 'Y Noise', 'Aux In 3', 'Aux In 4']

property DC

FILTER_SLOPE_MAP = {6: '0', 12: '1', 18: '2', 24: '3'}

FILTER_SLOPE_VALUES = [6, 12, 18, 24]

SENSITIVITY_MAP = {1e-09: '27', 2e-09: '26', 5e-09: '25', 1e-08: '24', 2e-08: '23', 5e-08: '22', 1e-07: '21', 2e-07: '20', 5e-07: '19', 1e-06: '18', 2e-06: '17', 5e-06: '16', 1e-05: '15', 2e-05: '14', 5e-05: '13', 0.0001: '12', 0.0002: '11', 0.0005: '10', 0.001: '9', 0.002: '8', 0.005: '7', 0.01: '6', 0.02: '5', 0.05: '4', 0.1: '3', 0.2: '2', 0.5: '1', 1: '0'}

SENSITIVITY_VALUES = [1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01, 0.005, 0.002, 0.001, 0.0005, 0.0002, 0.0001, 5e-05, 2e-05, 1e-05, 5e-06, 2e-06, 1e-06, 5e-07, 2e-07, 1e-07, 5e-08, 2e-08, 1e-08, 5e-09, 2e-09, 1e-09]

property TC

TIME_CONSTANT_MAP = {1e-06: '0', 3e-06: '1', 1e-05: '2', 3e-05: '3', 0.0001: '4', 0.0003: '5', 0.001: '6', 0.003: '7', 0.01: '8', 0.03: '9', 0.1: '10', 0.3: '11', 1: '12', 3: '15', 10: '14', 100: '16', 300: '17', 1000.0: '18', 3000.0: '19', 10000.0: '20', 30000.0: '21'}

TIME_CONSTANT_VALUES = [1e-06, 3e-06, 1e-05, 3e-05, 0.0001, 0.0003, 0.001, 0.003, 0.01, 0.03, 0.1, 0.3, 1, 3, 10, 3, 100, 300, 1000.0, 3000.0, 10000.0, 30000.0]

property ai1

property ai2

property ai3

property ai4

property amp

property amplitude

property ao1

property ao2

property ao3

property ao4

auto_offset(channel)

capture_done()

property capture_length

property capture_quants

property capture_rate

capture_start(mode='ONE', hw_trigger=False)

capture_stop()

property ch1

property ch2

property channel_1_output

property channel_1_type

property channel_2_output

property channel_2_type

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

property dc

property filter_slope

property freq

property frequency

get_DC(**kwargs)

get_TC(**kwargs)

get_ai1(**kwargs)

get_ai2(**kwargs)

get_ai3(**kwargs)

get_ai4(**kwargs)

get_amp(**kwargs)

get_amplitude(**kwargs)

get_ao1(**kwargs)

get_ao2(**kwargs)

get_ao3(**kwargs)

get_ao4(**kwargs)

get_capture(channel)

get_capture_quants(**kwargs)

get_ch1(**kwargs)

get_ch2(**kwargs)

get_channel_1_output(**kwargs)

get_channel_1_type(**kwargs)

get_channel_2_output(**kwargs)

get_channel_2_type(**kwargs)

get_dc(**kwargs)

get_filter_slope(**kwargs)

get_freq(**kwargs)

get_frequency(**kwargs)

get_mag(**kwargs)

get_magnitude(**kwargs)

get_max_capture_rate(**kwargs)

get_offset(**kwargs)

get_phase(**kwargs)

get_r(**kwargs)

get_r_expand(**kwargs)

get_r_offset(**kwargs)

get_r_offset_enable(**kwargs)

get_sensitivity(**kwargs)

get_tc(**kwargs)

get_theta(**kwargs)

get_time_constant(**kwargs)

get_x(**kwargs)

get_x_expand(**kwargs)

get_x_offset(**kwargs)

get_x_offset_enable(**kwargs)

get_y(**kwargs)

get_y_expand(**kwargs)

get_y_offset(**kwargs)

get_y_offset_enable(**kwargs)

property mag

property magnitude

property max_capture_rate

measure_delay(): Return how long we must wait for the values to have settled, based on the filter slope.

property offset

property phase

property r

property r_expand

property r_offset

property r_offset_enable

property sensitivity

set_DC(val, **kwargs)

set_TC(val, **kwargs)

set_amp(val, **kwargs)

set_amplitude(val, **kwargs)

set_ao1(val, **kwargs)

set_ao2(val, **kwargs)

set_ao3(val, **kwargs)

set_ao4(val, **kwargs)

set_capture_quants(val, **kwargs)

set_channel_1_output(val, **kwargs)

set_channel_1_type(val, **kwargs)

set_channel_2_output(val, **kwargs)

set_channel_2_type(val, **kwargs)

set_dc(val, **kwargs)

set_filter_slope(val, **kwargs)

set_freq(val, **kwargs)

set_frequency(val, **kwargs)

set_offset(val, **kwargs)

set_phase(val, **kwargs)

set_r_expand(val, **kwargs)

set_r_offset(val, **kwargs)

set_r_offset_enable(val, **kwargs)

set_sensitivity(val, **kwargs)

set_tc(val, **kwargs)

set_time_constant(val, **kwargs)

set_x_expand(val, **kwargs)

set_x_offset(val, **kwargs)

set_x_offset_enable(val, **kwargs)

set_y_expand(val, **kwargs)

set_y_offset(val, **kwargs)

set_y_offset_enable(val, **kwargs)

property tc

property theta

property time_constant

property x

property x_expand

property x_offset

property x_offset_enable

property y

property y_expand

property y_offset

property y_offset_enable

auspex.instruments.tektronix module

class auspex.instruments.tektronix.DPO2014(resource_name, *args, **kwargs)

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

class auspex.instruments.tektronix.DPO2024(resource_name, *args, **kwargs)

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

class auspex.instruments.tektronix.DPO72004C(resource_name, *args, **kwargs)

fast_frame = <auspex.instruments.instrument.StringCommand object>

get_curve(channel=1, byte_depth=2)

num_fast_frames = <auspex.instruments.instrument.IntCommand object>

class auspex.instruments.tektronix.RSA3308A(resource_name=None, *args, **kwargs)

Tektronix RSA3308A SA

property averaging_count

clear_averaging()

connect(resource_name=None, interface_type=None): Either connect to the resource name specified during initialization, or specify a new resource name here.

property frequency_center

property frequency_span

property frequency_start

property frequency_stop

get_averaging_count(**kwargs)

get_axis()

get_frequency_center(**kwargs)

get_frequency_span(**kwargs)

get_frequency_start(**kwargs)

get_frequency_stop(**kwargs)

get_marker1_amplitude(**kwargs)

get_marker1_position(**kwargs)

get_mode(**kwargs)

get_num_sweep_points(**kwargs)

get_pn_carrier_freq(**kwargs)

get_pn_offset_start(**kwargs)

get_pn_offset_stop(**kwargs)

get_pn_trace(num=3)

get_resolution_bandwidth(**kwargs)

get_sweep_time(**kwargs)

get_trace(num=1)

instrument_type = 'Spectrum Analyzer'

property marker1_amplitude

property marker1_position

marker_to_center(marker=1)

property mode

property num_sweep_points

peak_search(marker=1)

property pn_carrier_freq

property pn_offset_start

property pn_offset_stop

property resolution_bandwidth

restart_sweep(): Aborts current sweep and restarts.

set_averaging_count(val, **kwargs)

set_frequency_center(val, **kwargs)

set_frequency_span(val, **kwargs)

set_frequency_start(val, **kwargs)

set_frequency_stop(val, **kwargs)

set_marker1_amplitude(val, **kwargs)

set_marker1_position(val, **kwargs)

set_mode(val, **kwargs)

set_num_sweep_points(val, **kwargs)

set_pn_carrier_freq(val, **kwargs)

set_pn_offset_start(val, **kwargs)

set_pn_offset_stop(val, **kwargs)

set_resolution_bandwidth(val, **kwargs)

set_sweep_time(val, **kwargs)

property sweep_time

auspex.instruments.vaunix module

class auspex.instruments.vaunix.Labbrick(resource_name=None, name='Unlabeled Lab Brick')

Vaunix Lab Brick microwave source

STATUS_DEV_CONNECTED = 1

STATUS_DEV_OPENED = 2

STATUS_FAST_PULSE_OPTION = 128

STATUS_INVALID_DEVID = 2147483648

STATUS_PLL_LOCKED = 64

STATUS_SWP_ACTIVE = 4

STATUS_SWP_BIDIRECTIONAL = 32

STATUS_SWP_REPEAT = 16

STATUS_SWP_UP = 8

connect(resource_name=None)

disconnect()

enumerate()

property frequency

get_frequency()

get_output()

get_power()

get_sweep_end_freq()

get_sweep_start_freq()

get_sweep_time()

get_use_internal_ref()

instrument_type = 'Microwave Source'

property output

property power

save_settings()

set_frequency(value)

set_output(value)

set_power(value)

set_sweep_end_freq(value)

set_sweep_start_freq(value)

set_sweep_time(value)

set_use_internal_ref(value)

start_sweep(go, dir=None, bidirectional=None)

property sweep_end_freq

property sweep_start_freq

property sweep_time

property use_internal_ref

auspex.instruments.X6 module

class auspex.instruments.X6.X6(resource_name=None, name='Unlabeled X6', gen_fake_data=False)

BBN QDSP running on the II-X6 digitizer

property acquire_mode

add_channel(channel)

channel_setup(channel)

configure_with_dict(settings_dict): Accept a sdettings dictionary and attempt to set all of the instrument parameters using the key/value pairs.

connect(resource_name=None)

data_available()

disconnect()

done()

get_buffer_for_channel(channel)

get_socket(channel)

instrument_type = 'Digitizer'

property number_averages

property number_segments

property number_waveforms

receive_data(channel, oc, exit, ready, run)

property record_length

property reference

spew_fake_data(counter, ideal_data, random_mag=0.1, random_seed=12345)

Generate fake data on the stream. For unittest usage. ideal_data: array or list giving means of the expected signal for each segment

Returns the total number of fake data points, so that we can keep track of how many we expect to receive, when we’re doing the test with fake data

wait_for_acquisition(dig_run, timeout=15, ocs=None, progressbars=None)

class auspex.instruments.X6.X6Channel(receiver_channel=None)

Channel for an X6

set_by_receiver_channel(receiver)

auspex.instruments.yokogawa module

class auspex.instruments.yokogawa.YokogawaGS200(resource_name=None, *args, **kwargs)

YokogawaGS200 Current source

property averaging_nplc

connect(resource_name=None, interface_type='VISA'): Either connect to the resource name specified during initialization, or specify a new resource name here.

get_averaging_nplc(**kwargs)

get_level(**kwargs)

get_mode(**kwargs)

get_output(**kwargs)

get_output_range(**kwargs)

get_protection_current(**kwargs)

get_protection_volts(**kwargs)

get_ramp(**kwargs)

get_sense(**kwargs)

get_sense_value(**kwargs)

get_value(**kwargs)

instrument_type = 'Current source'

property level

property mode

property output

property output_range

property protection_current

property protection_volts

property ramp

property sense

property sense_value

set_averaging_nplc(val, **kwargs)

set_level(val, **kwargs)

set_mode(val, **kwargs)

set_output(val, **kwargs)

set_output_range(val, **kwargs)

set_protection_current(val, **kwargs)

set_protection_volts(val, **kwargs)

set_ramp(val, **kwargs)

set_sense(val, **kwargs)

set_value(val, **kwargs)

property value

Module contents

auspex.instruments.enumerate_visa_instruments()

auspex.instruments.probe_instrument_ids()