def output(self):
"""
Gets the specified output port.
:type: :class:`SRSDG645.Output`
"""
return ProxyList(self, self.Output, self.Outputs)
def measurement(self):
"""
Gets a specific oscilloscope measurement object. The desired channel is
specified like one would access a list.
:rtype: `_TDS5xxMeasurement`
"""
return ProxyList(self, _TekTDS5xxMeasurement, xrange(3))
def math(self):
"""
Gets a data source object corresponding to the MATH channel.
:rtype: `_TekTDS5xxDataSource`
"""
return ProxyList(
self,
lambda s, idx: _TekTDS5xxDataSource(s, "MATH{}".format(idx + 1)),
xrange(3))
def channel(self):
"""
Gets a channel object for the function generator. This should use
`~instruments.util_fns.ProxyList` to achieve this.
The number of channels accessable depends on the value
of FunctionGenerator._channel_count
:rtype: `FunctionGenerator.Channel`
"""
return ProxyList(self, self.Channel, range(self._channel_count))
def sensor(self):
"""
Gets a specific sensor object. The desired sensor is specified like
one would access a list.
For instance, this would query the temperature of the first sensor::
>>> itc = ik.other.OxfordITC503.open_gpibusb('/dev/ttyUSB0', 1)
>>> print itc.sensor[0].temperature
"""
return ProxyList(self, OxfordITC503.Sensor, xrange(3))
def test_ProxyList_invalid_idx():
class ProxyChild(object):
def __init__(self, parent, name):
self._parent = parent
self._name = name
parent = object()
proxy_list = ProxyList(parent, ProxyChild, range(5))
_ = proxy_list[10] # Should raise IndexError
def channel(self):
'''
Gets a specific channel object. The desired channel is specified like
one would access a list.
:rtype: `_HP6624aChannel`
.. seealso::
`HP6624a` for example using this property.
'''
return ProxyList(self, _HP6624aChannel, xrange(self.channel_count))
def test_ProxyList_length():
class ProxyChild(object):
def __init__(self, parent, name):
self._parent = parent
self._name = name
parent = object()
proxy_list = ProxyList(parent, ProxyChild, range(10))
eq_(len(proxy_list), 10)
def sensor(self):
"""
Gets a specific sensor object. The desired sensor is specified like
one would access a list.
:rtype: `~PicowattAVS47.Sensor`
.. seealso::
`PicowattAVS47` for an example using this property.
"""
return ProxyList(self, PicowattAVS47.Sensor, xrange(8))
def channel(self):
"""
Gets a specific channel object. The desired channel is specified like
one would access a list.
:rtype: `EpqisDemoInstrument.Channel`
.. seealso::
`EpqisDemoInstrument` for example using this property.
"""
return ProxyList(self, EpqisDemoInstrument.Channel,
range(self._channel_count))
def channel(self):
"""
Gets a specific channel object.
For example, the following would set the coupling of channel 1:
>>>> counter = ik.keithley.Keithley775A.open_gpibusb("/dev/ttyUSB0", 10)
>>>> counter.channel[0].coupling = counter.Coupling.DC
:rtype: `Keithley775A.Channel`
"""
return ProxyList(self, Keithley775A.Channel, range(2))
def channel(self):
"""
Gets an iterator or list for easy Pythonic access to the various
channel objects on the oscilloscope instrument.
Example:
>>> import instruments as ik
>>> import instruments.units as u
>>> inst = ik.teledyne.MAUI.open_visa("TCPIP0::192.168.0.10::INSTR")
>>> channel = inst.channel[0] # get first channel
"""
return ProxyList(self, self.Channel, range(self.number_channels))
def math(self):
"""
Gets an iterator or list for easy Pythonic access to the various
math data sources objects on the oscilloscope instrument.
Example:
>>> import instruments as ik
>>> import instruments.units as u
>>> inst = ik.teledyne.MAUI.open_visa("TCPIP0::192.168.0.10::INSTR")
>>> math = inst.math[0] # get first math function
"""
return ProxyList(self, self.Math, range(self.number_functions))
def channel(self):
"""
Gets the specific channel object.
This channel is accessed as a list in the following manner::
>>> import instruments as ik
>>> osa = ik.yokogawa.Yokogawa6370.open_gpibusb('/dev/ttyUSB0')
>>> dat = osa.channel["A"].data # Gets the data of channel 0
:rtype: `list`[`~Yokogawa6370.Channel`]
"""
return ProxyList(self, Yokogawa6370.Channel, Yokogawa6370.Traces)
def channel(self):
"""
Gets a specific oscilloscope channel object. The desired channel is
specified like one would access a list.
For instance, this would transfer the waveform from the first channel::
>>> tek = ik.tektronix.TekTDS5xx.open_tcpip('192.168.0.2', 8888)
>>> [x, y] = tek.channel[0].read_waveform()
:rtype: `_TekTDS5xxChannel`
"""
return ProxyList(self, _TekTDS5xxChannel, xrange(4))
def measurement(self):
"""
Gets an iterator or list for easy Pythonic access to the various
measurement data sources objects on the oscilloscope instrument.
Example:
>>> import instruments as ik
>>> import instruments.units as u
>>> inst = ik.teledyne.MAUI.open_visa("TCPIP0::192.168.0.10::INSTR")
>>> msr = inst.measurement[0] # get first measurement parameter
"""
return ProxyList(self, self.Measurement,
range(self.number_measurements))
def test_ProxyList_basics():
class ProxyChild(object):
def __init__(self, parent, name):
self._parent = parent
self._name = name
parent = object()
proxy_list = ProxyList(parent, ProxyChild, range(10))
child = proxy_list[0]
assert child._parent is parent
assert child._name == 0
def channel(self):
"""
Gets a specific channel object. The desired channel is specified like
one would access a list.
For instance, this would print the counts of the first channel::
>>> cc = ik.qubitekk.CC1.open_serial('COM8', 19200, timeout=1)
>>> print(cc.channel[0].count)
:rtype: `CC1.Channel`
"""
return ProxyList(self, CC1.Channel, range(self._channel_count))
def test_ProxyList_iterator():
class ProxyChild(object):
def __init__(self, parent, name):
self._parent = parent
self._name = name
parent = object()
proxy_list = ProxyList(parent, ProxyChild, range(10))
i = 0
for item in proxy_list:
eq_(item._name, i)
i = i + 1
def channel(self):
'''
Gets a specific channel object.
The desired channel is accessed by passing an EnumValue from
`~SRSDG645.Channels`. For example, to access channel A:
>>> inst.channel[inst.Channels.A]
See the example in `SRSDG645` for a more complete example.
:rtype: `_SRSDG645Channel`
'''
return ProxyList(self, _SRSDG645Channel, SRSDG645.Channels)
def channel(self):
"""
Gets the specific power supply channel object. Since the Yokogawa7651
is only equiped with a single channel, a list with a single element
will be returned.
This (single) channel is accessed as a list in the following manner::
>>> yoko = ik.other.Yokogawa7651.open_gpibusb('/dev/ttyUSB0', 10)
>>> yoko.channel[0].voltage = 1 # Sets output voltage to 1V
:rtype: `~Yokogawa7651.Channel`
"""
return ProxyList(self, Yokogawa7651.Channel, [0])
def channel(self):
"""
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()
:rtype: `Keithley2182.Channel`
"""
return ProxyList(self, Keithley2182.Channel, range(2))
def channel(self):
"""
Gets a specific channel on the AWG2000. The desired channel is accessed
like one would access a list.
Example usage:
>>> import instruments as ik
>>> inst = ik.tektronix.TekAWG2000.open_gpibusb("/dev/ttyUSB0", 1)
>>> print(inst.channel[0].frequency)
:return: A channel object for the AWG2000
:rtype: `TekAWG2000.Channel`
"""
return ProxyList(self, self.Channel, range(2))
def laser(self):
"""
Gets a specific Topmode laser object. The desired laser is
specified like one would access a list.
For example, the following would print the wavelength from laser 1:
>>> import instruments as ik
>>> import instruments.units as u
>>> tm = ik.toptica.TopMode.open_serial('/dev/ttyUSB0', 115200)
>>> print(tm.laser[0].wavelength)
:rtype: `~TopMode.Laser`
"""
return ProxyList(self, self.Laser, range(2))
def channel(self):
"""
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)
:return: A channel object for the HS9000
:rtype: `~HS9000.Channel`
"""
return ProxyList(self, self.Channel, self._channel_idxs())
def channel(self):
"""
Gets a specific channel object. The desired channel is specified like
one would access a list.
For instance, this would print the counts of the first channel::
>>> import instruments as ik
>>> mhs = ik.minghe.MHS5200.open_serial(vid=1027, pid=24577,
baud=19200, timeout=1)
>>> print(mhs.channel[0].frequency)
:rtype: `list`[`MHS5200.Channel`]
"""
return ProxyList(self, MHS5200.Channel, range(self._channel_count))
def sensor(self):
"""
Gets a specific sensor object. The desired sensor is specified like
one would access a list.
For instance, this would query the temperature of the first sensor::
>>> bridge = Lakeshore340.open_serial("COM5")
>>> print(bridge.sensor[0].temperature)
The Lakeshore 340 supports up to 2 sensors (index 0-1).
:rtype: `~Lakeshore340.Sensor`
"""
return ProxyList(self, Lakeshore340.Sensor, range(2))
def test_ProxyList_invalid_idx_enum():
class ProxyChild(object):
def __init__(self, parent, name):
self._parent = parent
self._name = name
class MockEnum(Enum):
a = "aa"
b = "bb"
parent = object()
proxy_list = ProxyList(parent, ProxyChild, MockEnum)
_ = proxy_list['c'] # Should raise IndexError
def channel(self):
"""
Gets a specific channel object. The desired channel is specified like
one would access a list.
For instance, this would query the resistance of the first channel::
>>> import instruments as ik
>>> bridge = ik.lakeshore.Lakeshore370.open_serial("COM5")
>>> print bridge.channel[0].resistance
The Lakeshore 370 supports up to 16 channels (index 0-15).
:rtype: `~Lakeshore370.Channel`
"""
return ProxyList(self, Lakeshore370.Channel, xrange(16))
def ref(self):
"""
Gets a specific oscilloscope reference channel object. The desired
channel is specified like one would access a list.
For instance, this would transfer the waveform from the first channel::
>>> tek = ik.tektronix.TekTDS5xx.open_tcpip('192.168.0.2', 8888)
>>> [x, y] = tek.ref[0].read_waveform()
:rtype: `_TekTDS5xxDataSource`
"""
return ProxyList(
self,
lambda s, idx: _TekTDS5xxDataSource(s, "REF{}".format(idx + 1)),
xrange(4))
