def __init__(self):
self.measurement_strategy = None
self.len_total = None
self.len_step = None
self.num_of_mea = None
self.time_step = None
self.frequency = None
self.temperature = None
self.humidity = None
self.access_sensor_times = None
self.directory = None
self.sensor_comp = None
self.motor_comp = None
self.network_analysis_resource = None
self.auto_find_comp = True
self.sensor_ser = None
self.motor_ser = None
self.visa_rm = ResourceManager()
self.motor = None
self.sensor = None
self.NA = None
self.NA_identifier = None
self.na_state = None
self.na_average_factor = None
self.multi_measure = None
def test_lock():
register_resources(instruments.resources)
rc = ResourceManager(visa_library="@mock")
res: Resource = rc.open_resource("MOCK0::mock1::INSTR")
res.lock_excl(timeout=0)
res.unlock()
def __init__(self, address=None, logger=None):
"""Instantiate driver class.
:address: Address of the device, e.g. 'ASRL3::INSTR'
Can be read out by using
rm = pyvisa.ResourceManager()
rm.list_resources()
:logger: An instance of a LogClient.
"""
# Instantiate log
self.log = LogHandler(logger=logger)
self.addr = address
self.rm = ResourceManager()
try:
self.device = self.rm.open_resource(self.addr)
self.log.info(f"Successfully connected to {self.device}.")
# Configure device grammar
self.device.write_termination = ';'
except VisaIOError:
self.log.error(f"Connection to {self.addr} failed.")
raise
def __init__(self):
super(lifetimeMeasurement, self).__init__()
self.load_ui()
self.connectAll()
self.rm = ResourceManager()
self.listResources()
# self.laser_controller = self.rm.open_resource(self.comboBox_laserController.currentText())
# self.oscilloscope = self.rm.open_resource(self.comboBox_oscilloscope.currentText())
# self.laserController = None
# self.oscilloscope = None
self.widget_currentDecay.setBackground('w')
self.widget_averagedDecay.setBackground('w')
self.widget_fitting.setBackground('w')
self.widget_currentDecay.setFrameShape(QFrame.Box)
self.widget_averagedDecay.setFrameShape(QFrame.Box)
self.widget_fitting.setFrameShape(QFrame.Box)
self.on_list = []
self.off_list = []
self.averagedDecay = []
self.xaxis = []
self.current_list = []
self.power_list = []
self.timerCountdown = None
self.timeLeft = None
self.dataLoadedX = None
self.dataLoadedY = None
self.yFitted = None
self.xFitReal = None
self.scanCurrent = 0.
def __init__(self):
try:
# Initialize VISA resource manager, connect to Matisse and wavemeter, clear any errors.
self._instrument = ResourceManager().open_resource(
cfg.get(cfg.MATISSE_DEVICE_ID))
self.target_wavelength = None
self._stabilization_thread = None
self._lock_correction_thread = None
self._plotting_processes = []
self.exit_flag = False
self._scan_attempts = 0
self._force_large_scan = True
self._restart_set_wavelength = False
self.is_setting_wavelength = False
self.is_scanning_bifi = False
self.is_scanning_thin_etalon = False
self.stabilization_auto_corrections = 0
self.query('ERROR:CLEAR') # start with a clean slate
self.query('MOTORBIREFRINGENT:CLEAR')
self.query('MOTORTHINETALON:CLEAR')
self._wavemeter = WaveMaster(cfg.get(cfg.WAVEMETER_PORT))
except VisaIOError as ioerr:
raise IOError(
"Can't reach Matisse. Make sure it's on and connected via USB."
) from ioerr
def __init__(self, gpib_address, logger):
"""Instantiate driver class.
:gpib_address: GPIB-address of the scope, e.g. 'GPIB0::12::INSTR'
Can be read out by using
rm = pyvisa.ResourceManager()
rm.list_resources()
:logger: And instance of a LogClient.
"""
# Instantiate log.
self.log = LogHandler(logger=logger)
self.rm = ResourceManager()
try:
self.device = self.rm.open_resource(gpib_address)
device_id = self.device.query('*IDN?')
self.log.info(f"Successfully connected to {device_id}.")
except VisaIOError:
self.log.error(f"Connection to {gpib_address} failed.")
# We set a more forgiving timeout of 10s (default: 2s).
self.device.timeout = 10000
# Reset to factory settings.
self.reset()
# Set all attenuations to 1x.
for channel in CHANNEL_LIST:
self.set_channel_attenuation(channel, 1)
def setup_method(self):
"""Create a resource using the address matching the type."""
name = RESOURCE_ADDRESSES[self.RESOURCE_TYPE]
self.rname = ResourceName.from_string(name)
self.rm = ResourceManager()
self.instr = self.rm.open_resource(name)
self.instr.clear()
def test_lock_timeout():
register_resources(instruments.resources)
rc = ResourceManager(visa_library="@mock")
res: Resource = rc.open_resource("MOCK0::mock1::INSTR")
res.write(":INSTR:CHANNEL1:VOLT 2.3")
res.write(":INSTR:CHANNEL1:VOLT 2.3")
def blocking_thread(res: Resource, event: Event):
with res.lock_context():
event.wait()
block_release: Event = Event()
blocker: Thread = Thread(
target=blocking_thread,
args=[res, block_release],
)
try:
blocker.start()
with raises(VisaIOError) as e:
with res.lock_context(timeout=0):
res.query(":INSTR:CHANNEL1:VOLT?")
assert e.value.error_code == StatusCode.error_timeout
finally:
block_release.set()
blocker.join()
reply = res.query(":INSTR:CHANNEL1:VOLT?")
assert reply == '2.3'
def test_hislip_shared_lock(hislip_example, resource_manager: pyvisa.ResourceManager):
inst1 = resource_manager.open_resource(hislip_example)
inst2 = resource_manager.open_resource(hislip_example)
inst3 = resource_manager.open_resource(hislip_example)
# Lock
inst1.lock(requested_key="foo", timeout=0)
inst2.lock(requested_key="foo", timeout=1000000000)
# Timeout
t1 = time()
with pytest.raises(pyvisa.VisaIOError) as excinfo:
inst3.lock(1000, requested_key="bar")
dt = time() - t1
print(f"Timeout took {dt}s")
assert dt > 1.0, "Timeout occured too fast"
inst1.unlock()
inst2.unlock()
# inst3 may lock
inst3.lock(1000, requested_key="bar")
inst1.close()
inst2.close()
inst3.close()
class GPIBBase(AbstractContextManager, metaclass=MetaInstrument):
"""
Base class for GPIB instruments. It wraps PyVisa's ResourceManager with open resources.
``GPIBBase`` also supports context managemenent (``with`` statement).
Parameters
----------
addr : str
Instrument address, e.g. 'GPIB::15'.
kwargs
Keyword arguments are passed to the pyvisa.ResourceManager.open_resource method.
"""
def __init__(self, addr, **kwargs):
self._rm = ResourceManager()
self._instrument = self._rm.open_resource(resource_name=addr, **kwargs)
def __exit__(self, *exc):
self.clear()
self.close()
super().__exit__(*exc)
def clear(self):
return self._instrument.clear()
def close(self):
self._instrument.close()
self._rm.close()
def write(self, *args, **kwargs):
return self._instrument.write(*args, **kwargs)
def read(self, *args, **kwargs):
return self._instrument.read(*args, **kwargs)
def query(self, *args, **kwargs):
return self._instrument.query(*args, **kwargs)
write.__doc__ = GPIBInstrument.write.__doc__
read.__doc__ = GPIBInstrument.read.__doc__
query.__doc__ = GPIBInstrument.query.__doc__
def wait_for_srq(self, timeout=25000):
"""
Wait for a serial request (SRQ) or the timeout to expire.
Parameters
----------
timeout : int or None, optional
The maximum waiting time in milliseconds.
None means waiting forever if necessary.
Raises
------
pyvisa.error.VisaIOError: if timeout has expired
"""
return self._instrument.wait_for_srq(timeout)
def test_lock_context():
register_resources(instruments.resources)
rc = ResourceManager(visa_library="@mock")
res: Resource = rc.open_resource("MOCK0::mock1::INSTR")
res.write(":INSTR:CHANNEL1:VOLT 2.3")
with res.lock_context():
reply = res.query(":INSTR:CHANNEL1:VOLT?")
assert reply == '2.3'
def test_resource_manager_unicity(self):
"""Test the resource manager is unique per backend as expected.
"""
new_rm = ResourceManager()
self.assertIs(self.rm, new_rm)
self.assertEqual(self.rm.session, new_rm.session)
def __init__(self):
resource_manager = ResourceManager('@py')
try:
self.inst = resource_manager.open_resource(
resource_manager.list_resources()[0])
except:
print("Could not find")
self.test = True
return
if "ok" in self.inst.query("$BD:0,CMD:MON,PAR:BDNAME").lower():
print("Successfully connected to CAEN psu")
else:
sys.exit(ERROR_BOARD_NOT_FOUND)
def test_read_stb(vxi11_example, resource_manager: pyvisa.ResourceManager):
inst = resource_manager.open_resource(vxi11_example)
status = inst.read_stb()
assert status == 0
inst.close()
def find_visa():
# Return the first VISA address which maps to a Rigol DS1000Z.
RIGOL_IDN_REGEX = "^RIGOL TECHNOLOGIES,DS1[01][057]4Z(-S)?( Plus)?,.+$"
visa_manager = ResourceManager()
for visa_name in visa_manager.list_resources():
try:
visa_resource = visa_manager.open_resource(visa_name)
match = search(RIGOL_IDN_REGEX, visa_resource.query("*IDN?"))
if match:
return visa_name
except VisaIOError:
pass
finally:
visa_resource.close()
def test_hislip_exclusive_lock(hislip_example, resource_manager: pyvisa.ResourceManager):
inst = resource_manager.open_resource(hislip_example)
# Lock and unlock
inst.lock_excl(25.0)
inst.unlock()
inst.close()
def test_query(vxi11_example, resource_manager: pyvisa.ResourceManager):
inst = resource_manager.open_resource(vxi11_example)
inst.read_termination = ''
inst.write_termination = ''
resp = inst.query("*IDN?").strip()
assert resp == "Cyberdyne systems,T800 Model 101,A9012.C,V2.4"
inst.close()
def __init__(self,
address,
timeout=None,
resource_manager=None,
close_on_exit=True):
self.rm = resource_manager or ResourceManager()
self.device = self.rm.open_resource(address)
self.device.timeout = timeout
self.close_on_exit = close_on_exit
class Driver():
"""Driver class"""
def reset(self):
""" Create factory reset"""
self.device.write('*RST')
self.log.info("Reset to factory settings successfull.")
def __init__(self, gpib_address, logger):
"""Instantiate driver class
:gpib_address: GPIB-address of spectrum analyzer, e.g. 'GPIB0::12::INSTR'
Can be read out by using
rm = pyvisa.ResourceManager()
rm.list_resources()
:logger: And instance of a LogClient
"""
# Instantiate log
self.log = LogHandler(logger=logger)
self.rm = ResourceManager()
try:
self.device = self.rm.open_resource(gpib_address)
device_id = self.device.query('*IDN?')
self.log.info(f"Successfully connected to {device_id}.")
except VisaIOError:
self.log.error(f"Connection to {gpib_address} failed.")
# reset to factory settings
self.reset()
def turn_laser_off(self):
""" Power off display """
self.device.write('OUTPut1:STATe 0') # temp control
self.device.write('OUTPut2:STATe 0') # diode
self.log.info("Laser off.")
def turn_laser_on(self):
""" Power on display """
self.device.write('OUTPut2:STATe 1') # temp control
self.device.write('OUTPut1:STATe 1') # diode
self.log.info("Laser on.")
def set_current(self, amps):
""" Sets current setpoint in mA
:amps:
"""
if not 0 <= amps <= 60:
self.log.error(
f'Invalid current ({amps}mA). Attenuation must be between 0A and 60mA'
)
self.device.write(f'SOURce1:CURRent:LEVel:AMPLitude {amps*1e-3}')
self.log.info(f'Current setpoint set to {amps}mA.')
def show_setting_port():
"""open Dialog window to set ports manually"""
def verify_sensor():
sensor_com = ui_setting_port.com_senser.text()
try:
ui_setting_port.textBrowser.setText(f'传感器串口： {sensor_com}')
ser = Serial(sensor_com, 9600, timeout=2)
temp_sensor = Sensor(ser)
ui_setting_port.textBrowser.append(str(temp_sensor.current_t_rh))
ser.close()
input_parameters.sensor_comp = sensor_com
except Exception as e:
ui_setting_port.textBrowser.append(str(e))
def verify_motor():
motor_com = ui_setting_port.com_motor.text()
try:
ui_setting_port.textBrowser.setText(f'步进电机串口： {motor_com}')
ser = Serial(motor_com, 9600, timeout=0.2)
temp_sensor = StepMotor(ser)
temp_sensor.move_forward()
ser.close()
input_parameters.motor_comp = motor_com
except Exception as e:
ui_setting_port.textBrowser.append(str(e))
def verify_network_analyzer():
na_identifier = ui_setting_port.com_na.text()
try:
ui_setting_port.textBrowser.setText(f'网分： {na_identifier}')
ser = input_parameters.visa_rm.open_resource(na_identifier)
NetworkAnalyzer(ser)
ui_setting_port.textBrowser.append('没毛病嗷\n┗|｀O′|┛ 嗷~~')
ser.close()
input_parameters.NA_identifier = na_identifier
except Exception as e:
ui_setting_port.textBrowser.append(str(e))
setting_port = QDialog()
ui_setting_port = PortSetting.Ui_Dialog()
ui_setting_port.setupUi(setting_port)
ports = list(list_ports.comports())
text = ' 当前已连接串口：\n'
for p in ports:
text += f'{p[1]}\n'
text += ' 仪器\n'
for p in ResourceManager().list_resources():
text += f'{p}\n'
ui_setting_port.current_comports.setText(text)
ui_setting_port.com_motor.setText(input_parameters.motor_comp)
ui_setting_port.com_senser.setText(input_parameters.sensor_comp)
ui_setting_port.com_na.setText(input_parameters.NA_identifier)
ui_setting_port.apply_sensor.clicked.connect(verify_sensor)
ui_setting_port.apply_motor.clicked.connect(verify_motor)
ui_setting_port.apply_NA.clicked.connect(verify_network_analyzer)
setting_port.exec_()
def refresh_resources(n):
list_of_resources = ResourceManager().list_resources()
default_resource = [s for s in list_of_resources if 'GPIB0' in s]
default_resource = None if len(
default_resource) == 0 else default_resource[0]
return default_resource, [{
'label': name,
'value': name
} for name in list_of_resources]
def test_non_blocking_read():
"""
Make sure the the non blocking read is fast.
"""
register_resources(instruments.resources)
rc = ResourceManager(visa_library="@mock")
res: MockResource = rc.open_resource("MOCK0::mock5::INSTR")
meas_time = Mocker5.meas_time
start_time = time.time()
res.write(":instr:channel1:volt 12")
end_time = time.time()
elapsted = end_time - start_time
assert elapsted < meas_time/2
# clear the STB reg
voltage = res.write("*CLS")
# kick off reading
start_time = time.time()
res.write(":inStrument:channel1:MEAS")
end_time = time.time()
elapsted = end_time - start_time
assert elapsted < meas_time/2
# Make sure time out happens
with pytest.raises(VisaIOError) as e:
res.wait_for_srq(0)
assert e.value.error_code == StatusCode.error_timeout
# Wait for event interrupt
start_time = time.time()
res.wait_for_srq()
end_time = time.time()
elapsted = end_time - start_time
assert elapsted > meas_time/2
start_time = time.time()
voltage = res.query(":inStrument:channel1:REAd?")
end_time = time.time()
elapsted = end_time - start_time
assert elapsted < meas_time/2
assert voltage == "12.0"
class TestFilter2(BaseTestCase):
def setUp(self):
"""Create a ResourceManager with the default backend library.
"""
self.rm = ResourceManager()
def tearDown(self):
"""Close the ResourceManager.
"""
self.rm.close()
def _test_filter2(self, expr, *correct):
resources = self.rm.list_resources(expr.split("{")[0])
ok = tuple(resources[n] for n in correct)
filtered = rname.filter2(
resources, expr, lambda rsc: self.rm.open_resource(rsc)
)
self.assertSequenceEqual(filtered, ok)
def test_filter2_optional_clause_with_connection(self):
self._test_filter2(
"?*::INSTR{VI_ATTR_TERMCHAR_EN == 1 && VI_ATTR_TERMCHAR == 0}"
)
# Linefeed \n is 10
self._test_filter2("TCPIP::?*::INSTR{VI_ATTR_TERMCHAR == 10}")
# test handling error in the evaluation of the attribute
def broken_get_visa_attribute(self, name):
raise Exception()
old = Resource.get_visa_attribute
Resource.get_visa_attribute = broken_get_visa_attribute
# Using any other log level will cause the test to fail for no apparent
# good reason
with self.assertLogs(level=logging.DEBUG, logger=logger):
try:
self._test_filter2("TCPIP::?*::INSTR{VI_ATTR_TERMCHAR == 10}")
finally:
Resource.get_visa_attribute = old
def __init__(self, gpib_address, logger):
""" Instantiate driver class, connects to device
:param gpib_address: GPIB-address of the device,
can be found with pyvisa.ResourceManager.list_resources()
:param logger: instance of LogClient
"""
self.log = LogHandler(logger=logger)
self.rm = ResourceManager()
try:
self.device = self.rm.open_resource(gpib_address)
self.device.read_termination = '\n'
self.device_id = self.device.query('*IDN?')
self.log.info(f'Successfully connected to {self.device_id}')
except VisaIOError:
self.log.error(f'Connection to {gpib_address} failed')
raise
def test_open_resource_unknown_resource_type(self, caplog):
"""Test opening a resource for which no registered class exist."""
rc = ResourceManager._resource_classes
old = rc.copy()
class FakeResource:
def __init__(self, *args):
raise RuntimeError()
rc[(InterfaceType.unknown, "")] = FakeResource
del rc[(InterfaceType.tcpip, "INSTR")]
rm = ResourceManager()
try:
caplog.clear()
with caplog.at_level(level=logging.DEBUG, logger="pyvisa"):
with pytest.raises(RuntimeError):
rm.open_resource("TCPIP::192.168.0.1::INSTR")
assert caplog.records
finally:
ResourceManager._resource_classes = old
def test_hislip_clear_in_progress(hislip_example, resource_manager: pyvisa.ResourceManager):
inst1 = resource_manager.open_resource(hislip_example)
inst2 = resource_manager.open_resource(hislip_example)
# Lock
inst1.lock(requested_key="foo")
# Timeout
inst1.close()
inst2.close()
def test_open_resource_unknown_resource_type(self):
"""Test opening a resource for which no registered class exist.
"""
rc = ResourceManager._resource_classes
old = rc.copy()
class FakeResource:
def __init__(self, *args):
raise RuntimeError()
rc[(InterfaceType.unknown, "")] = FakeResource
del rc[(InterfaceType.tcpip, "INSTR")]
rm = ResourceManager()
try:
with self.assertLogs(level=logging.DEBUG, logger=logger):
with self.assertRaises(RuntimeError):
rm.open_resource("TCPIP::192.168.0.1::INSTR")
finally:
ResourceManager._resource_classes = old
def test_blocking_read():
"""
Make sure the the measurement takes a while to complete and
that other operations are fast.
"""
register_resources(instruments.resources)
rc = ResourceManager(visa_library="@mock")
res: MockResource = rc.open_resource("MOCK0::mock5::INSTR")
meas_time = Mocker5.meas_time
start_time = time.time()
res.write(":instr:channel1:volt 12")
end_time = time.time()
elapsted = end_time - start_time
assert elapsted < meas_time/2
start_time = time.time()
voltage = res.query(":inStrument:channel1:vOlT?")
end_time = time.time()
elapsted = end_time - start_time
assert elapsted > meas_time/2
assert voltage == "12.0"
class TestFilter2(BaseTestCase):
def setup_method(self):
"""Create a ResourceManager with the default backend library."""
self.rm = ResourceManager()
def teardown_method(self):
"""Close the ResourceManager."""
self.rm.close()
def _test_filter2(self, expr, *correct):
resources = self.rm.list_resources(expr.split("{")[0])
ok = tuple(resources[n] for n in correct)
filtered = rname.filter2(resources, expr,
lambda rsc: self.rm.open_resource(rsc))
assert filtered == ok
def test_filter2_optional_clause_with_connection(self, caplog,
monkeypatch):
self._test_filter2(
"?*::INSTR{VI_ATTR_TERMCHAR_EN == 1 && VI_ATTR_TERMCHAR == 0}")
# Linefeed \n is 10
self._test_filter2("TCPIP::?*::INSTR{VI_ATTR_TERMCHAR == 10}")
# test handling error in the evaluation of the attribute
def broken_get_visa_attribute(self, name):
raise Exception()
monkeypatch.setattr(Resource, "get_visa_attribute",
broken_get_visa_attribute)
# Using any other log level will cause the test to fail for no apparent
# good reason
caplog.clear()
with caplog.at_level(logging.DEBUG, logger="pyvisa"):
self._test_filter2("TCPIP::?*::INSTR{VI_ATTR_TERMCHAR == 10}")
assert caplog.records
def __init__(self, gpib_address, logger):
"""Instantiate driver class.
:gpib_address: GPIB-address of the device, e.g. 'COM8'
Can ba found in the Windows device manager.
:logger: And instance of a LogClient.
"""
# Instantiate log.
self.log = LogHandler(logger=logger)
self.rm = ResourceManager()
try:
self.device = self.rm.open_resource(gpib_address)
self.device_id = self.device.query('*IDN?')
self.log.info(f"Successfully connected to {self.device_id}.")
except VisaIOError:
self.log.error(f"Connection to {gpib_address} failed.")
# Reset to factory settings.
self.reset()
# Read and store min and max power.
self.power_min, self.power_max = [
float(
self.device.query(f'pow? {string}')
)
for string in ['min', 'max']
]
# Read and store min and max frequency.
self.freq_min, self.freq_max = [
float(
self.device.query(f'freq? {string}')
)
for string in ['min', 'max']
]