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'] ]