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 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()
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
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
class TestResourceManager(unittest.TestCase): """Test the pyvisa ResourceManager. """ def setUp(self): """Create a ResourceManager with the default backend library. """ self.rm = ResourceManager() def tearDown(self): """Close the ResourceManager. """ self.rm.close() del rm gc.collect() def test_lifecycle(self): """Test creation and closing of the resource manager. """ self.assertIsNotNone(self.rm.session) self.assertIsNotNone(self.rm.visalib) self.assertIs(self.rm, self.rm.visalib.resource_manager) self.assertFalse(self.rm.list_opened_resources()) self.assertIs(self.rm.visalib, ResourceManager(self.rm.visalib).visalib) self.rm.close() with self.assertRaises(InvalidSession): self.rm.session self.assertIsNone(self.rm.visalib.resource_manager) def test_cleanup_on_del(self): """Test that deleting the rm does clean the VISA session """ # The test seems to assert what it should even though the coverage report # seems wrong rm = highlevel.ResourceManager() with self.assertLogs(level=logging.DEBUG) as log: del rm gc.collect() self.assertIn('Closing ResourceManager', log.output) 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 test_str(self): """Test computing the string representation of the resource manager """ self.assertRegex(str(self.rm), r"Resource Manager of .*") self.rm.close() self.assertRegex(str(self.rm), r"Resource Manager of .*") def test_repr(self): """Test computing the repr of the resource manager """ self.assertRegex(repr(self.rm), r"<ResourceManager\(<.*>\)>") self.rm.close() self.assertRegex(repr(self.rm), r"<ResourceManager\(<.*>\)>") def test_last_status(self): """Test accessing the status of the last operation. """ self.assertEqual(self.rm.last_status, StatusCode.success) # Access the generic last status through the visalib self.assertEqual(self.rm.last_status, self.rm.visalib.last_status) # Test accessing the status for an invalid session with self.assertRaises(errors.Error) as cm: self.rm.visalib.get_last_status_in_session("_nonexisting_") self.assertIn("The session", cm.exception.args[0]) def test_list_resource(self): """Test listing the available resources. """ # Default settings self.assertSequenceEqual( sorted(self.rm.list_resources()), sorted([ str(ResourceName.from_string(v)) for v in RESOURCE_ADDRESSES.values() if v.endswith("INSTR") ])) # All resources self.assertSequenceEqual( sorted(self.rm.list_resources("?*")), sorted([ str(ResourceName.from_string(v)) for v in RESOURCE_ADDRESSES.values() ])) def test_accessing_resource_infos(self): """Test accessing resource infos. """ rname = list(RESOURCE_ADDRESSES.values())[0] rinfo_ext = self.rm.resource_info(rname) rinfo = self.rm.resource_info(rname, extended=False) rname = ResourceName().from_string(rname) self.assertEqual(rinfo_ext.interface_type, getattr(InterfaceType, rname.interface_type.lower())) self.assertEqual(rinfo_ext.interface_board_number, int(rname.board)) self.assertEqual(rinfo_ext.resource_class, rname.resource_class) self.assertEqual(rinfo_ext.resource_name, str(rname)) self.assertEqual(rinfo.interface_type, getattr(InterfaceType, rname.interface_type.lower())) self.assertEqual(rinfo.interface_board_number, int(rname.board)) def test_listing_resource_infos(self): """Test listing resource infos. """ infos = self.rm.list_resources_info() for rname, rinfo_ext in infos.items(): rname = ResourceName().from_string(rname) self.assertEqual( rinfo_ext.interface_type, getattr(InterfaceType, rname.interface_type.lower())) self.assertEqual(rinfo_ext.interface_board_number, int(rname.board)) self.assertEqual(rinfo_ext.resource_class, rname.resource_class) self.assertEqual(rinfo_ext.resource_name, str(rname)) def test_opening_resource(self): """Test opening and closing resources. """ rname = list(RESOURCE_ADDRESSES.values())[0] rsc = self.rm.open_resource(rname, timeout=1234) # Check the resource is listed as opened and the attributes are right. self.assertIn(rsc, self.rm.list_opened_resources()) self.assertEqual(rsc.timeout, 1234) # Close the rm to check that we close all resources. self.rm.close() self.assertFalse(self.rm.list_opened_resources()) with self.assertRaises(InvalidSession): rsc.session def test_opening_resource_bad_open_timeout(self): """Test opening a resource with a non integer open_timeout. """ rname = list(RESOURCE_ADDRESSES.values())[0] with self.assertRaises(ValueError) as cm: rsc = self.rm.open_resource(rname, open_timeout="") self.assertIn("integer (or compatible type)", str(cm.exception)) def test_opening_resource_with_lock(self): """Test opening a locked resource """ rname = list(RESOURCE_ADDRESSES.values())[0] rsc = self.rm.open_resource(rname, access_mode=AccessModes.exclusive_lock) self.assertEqual(len(self.rm.list_opened_resources()), 1) # Timeout when accessing a locked resource with self.assertRaises(VisaIOError): self.rm.open_resource(rname, access_mode=AccessModes.exclusive_lock) self.assertEqual(len(self.rm.list_opened_resources()), 1) # Success to access an unlocked resource. rsc.unlock() rsc2 = self.rm.open_resource(rname, access_mode=AccessModes.exclusive_lock) self.assertEqual(len(self.rm.list_opened_resources()), 2) def test_opening_resource_specific_class(self): """Test opening a resource requesting a specific class. """ rname = list(RESOURCE_ADDRESSES.values())[0] with self.assertRaises(TypeError): rsc = self.rm.open_resource(rname, resource_pyclass=object) self.assertEqual(len(self.rm.list_opened_resources()), 0) def test_open_resource_unknown_resource_type(self): """Test opening a resource for which no registered class exist. """ rc = highlevel.ResourceManager._resource_classes old = rc.copy() class FakeResource: def __init__(self, *args): raise RuntimeError() rc[(constants.InterfaceType.unknown, "")] = FakeResource rm = highlevel.ResourceManager() try: with self.assertLogs(level=logging.WARNING): highlevel.ResourceManager.open_resource( "TCPIP::192.168.0.1::INSTR") self.assertIs( highlevel.ResourceManager._resource_classes[( constants.InterfaceType.tcpip, "INSTR")], object) finally: highlevel.ResourceManager._resource_classes = old def test_opening_resource_unknown_attribute(self): """Test opening a resource and attempting to set an unknown attr. """ rname = list(RESOURCE_ADDRESSES.values())[0] with self.assertRaises(ValueError): rsc = self.rm.open_resource(rname, unknown_attribute=None) self.assertEqual(len(self.rm.list_opened_resources()), 0) def test_get_instrument(self): """Check that we get the expected deprecation warning. """ rname = list(RESOURCE_ADDRESSES.values())[0] with self.assertWarns(FutureWarning): rsc = self.rm.get_instrument(rname)
import pyvisa from pyvisa import ResourceManager m = ResourceManager() resources_list = m.list_resources() print(resources_list) inst = m.open_resource(resources_list[1]) print("eae") a = inst.write_raw(b"*IDN?") f = inst.read_raw() print(a) inst.close()
class TestResourceManager: """Test the pyvisa ResourceManager.""" def setup_method(self): """Create a ResourceManager with the default backend library.""" self.rm = ResourceManager() def teardown_method(self): """Close the ResourceManager.""" if self.rm is not None: self.rm.close() del self.rm gc.collect() def test_lifecycle(self, caplog): """Test creation and closing of the resource manager.""" assert self.rm.session is not None assert self.rm.visalib is not None assert self.rm is self.rm.visalib.resource_manager assert not self.rm.list_opened_resources() assert self.rm.visalib is ResourceManager(self.rm.visalib).visalib with caplog.at_level(level=logging.DEBUG, logger="pyvisa"): self.rm.close() assert caplog.records with pytest.raises(InvalidSession): self.rm.session assert self.rm.visalib.resource_manager is None def test_cleanup_on_del(self, caplog): """Test that deleting the rm does clean the VISA session""" # The test seems to assert what it should even though the coverage report # seems wrong rm = self.rm self.rm = None with caplog.at_level(logging.DEBUG, logger="pyvisa"): del rm gc.collect() assert "Closing ResourceManager" in caplog.records[0].message def test_resource_manager_unicity(self): """Test the resource manager is unique per backend as expected.""" new_rm = ResourceManager() assert self.rm is new_rm assert self.rm.session == new_rm.session def test_str(self): """Test computing the string representation of the resource manager""" assert re.match(r"Resource Manager of .*", str(self.rm)) self.rm.close() assert re.match(r"Resource Manager of .*", str(self.rm)) def test_repr(self): """Test computing the repr of the resource manager""" assert re.match(r"<ResourceManager\(<.*>\)>", repr(self.rm)) self.rm.close() assert re.match(r"<ResourceManager\(<.*>\)>", repr(self.rm)) def test_last_status(self): """Test accessing the status of the last operation.""" assert self.rm.last_status == StatusCode.success # Access the generic last status through the visalib assert self.rm.last_status == self.rm.visalib.last_status # Test accessing the status for an invalid session with pytest.raises(errors.Error) as cm: self.rm.visalib.get_last_status_in_session("_nonexisting_") assert "The session" in cm.exconly() def test_list_resource(self): """Test listing the available resources.""" # Default settings resources = self.rm.list_resources() for v in (v for v in RESOURCE_ADDRESSES.values() if v.endswith("INSTR")): assert str(ResourceName.from_string(v)) in resources # All resources resources = self.rm.list_resources("?*") for v in RESOURCE_ADDRESSES.values(): assert str(ResourceName.from_string(v)) in resources def test_accessing_resource_infos(self): """Test accessing resource infos.""" rname = list(RESOURCE_ADDRESSES.values())[0] rinfo_ext = self.rm.resource_info(rname) rinfo = self.rm.resource_info(rname, extended=False) rname = ResourceName().from_string(rname) assert rinfo_ext.interface_type == getattr( InterfaceType, rname.interface_type.lower()) assert rinfo_ext.interface_board_number == int(rname.board) assert rinfo_ext.resource_class == rname.resource_class assert rinfo_ext.resource_name == str(rname) assert rinfo.interface_type == getattr(InterfaceType, rname.interface_type.lower()) assert rinfo.interface_board_number == int(rname.board) def test_listing_resource_infos(self): """Test listing resource infos.""" infos = self.rm.list_resources_info() for rname, rinfo_ext in infos.items(): rname = ResourceName().from_string(rname) assert rinfo_ext.interface_type == getattr( InterfaceType, rname.interface_type.lower()) assert rinfo_ext.interface_board_number == int(rname.board) assert rinfo_ext.resource_class == rname.resource_class assert rinfo_ext.resource_name == str(rname) def test_opening_resource(self): """Test opening and closing resources.""" rname = list(RESOURCE_ADDRESSES.values())[0] rsc = self.rm.open_resource(rname, timeout=1234) # Check the resource is listed as opened and the attributes are right. assert rsc in self.rm.list_opened_resources() assert rsc.timeout == 1234 # Close the rm to check that we close all resources. self.rm.close() assert not self.rm.list_opened_resources() with pytest.raises(InvalidSession): rsc.session def test_opening_resource_bad_open_timeout(self): """Test opening a resource with a non integer open_timeout.""" rname = list(RESOURCE_ADDRESSES.values())[0] with pytest.raises(ValueError) as cm: self.rm.open_resource(rname, open_timeout="") assert "integer (or compatible type)" in str(cm.exconly()) def test_opening_resource_with_lock(self): """Test opening a locked resource""" rname = list(RESOURCE_ADDRESSES.values())[0] rsc = self.rm.open_resource(rname, access_mode=AccessModes.exclusive_lock) assert len(self.rm.list_opened_resources()) == 1 # Timeout when accessing a locked resource with pytest.raises(VisaIOError): self.rm.open_resource(rname, access_mode=AccessModes.exclusive_lock) assert len(self.rm.list_opened_resources()) == 1 # Success to access an unlocked resource. rsc.unlock() with self.rm.open_resource( rname, access_mode=AccessModes.exclusive_lock) as rsc2: assert rsc.session != rsc2.session assert len(self.rm.list_opened_resources()) == 2 def test_opening_resource_specific_class(self): """Test opening a resource requesting a specific class.""" rname = list(RESOURCE_ADDRESSES.values())[0] with pytest.raises(TypeError): self.rm.open_resource(rname, resource_pyclass=object) assert len(self.rm.list_opened_resources()) == 0 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_opening_resource_unknown_attribute(self): """Test opening a resource and attempting to set an unknown attr.""" rname = list(RESOURCE_ADDRESSES.values())[0] with pytest.raises(ValueError): self.rm.open_resource(rname, unknown_attribute=None) assert len(self.rm.list_opened_resources()) == 0 def test_get_instrument(self): """Check that we get the expected deprecation warning.""" rname = list(RESOURCE_ADDRESSES.values())[0] with pytest.warns(FutureWarning): self.rm.get_instrument(rname)
class InputParameter(object): 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 check_data(self): """check input parameters, and open serials, remember to close ser!!!""" if self.directory is None: raise InputError('请选择数据保存位置') try: self.measurement_strategy = int(self.measurement_strategy) except Exception: raise InputError('须指定测量方案') if self.measurement_strategy == 0: try: self.len_total = float(self.len_total) except Exception: raise InputError('缺少腔体长度') try: self.len_step = float(self.len_step) except Exception: raise InputError('缺少运动步长') if self.len_step * self.len_total <= 0: raise InputError('总长度和步长符号须一致,负号表示反向') elif self.measurement_strategy == 1: try: self.num_of_mea = float(self.num_of_mea) except Exception: raise InputError('请指定一周测量次数') try: self.time_step = float(self.time_step) except Exception: raise InputError('缺少等待时间') if self.time_step < 1: raise InputError('至少等1s') try: self.multi_measure = int(self.multi_measure) except Exception: raise InputError('指定测量次数') try: self.frequency = float(self.frequency) except Exception: raise InputError('缺少真空频率') if self.access_sensor_times is None: self.access_sensor_times = 0 try: self.access_sensor_times = int(self.access_sensor_times) except Exception: raise InputError('设置温湿度') if self.access_sensor_times == 0: try: self.temperature = float(self.temperature) except Exception: raise InputError('缺少温度数据') try: self.humidity = float(self.humidity) except Exception: raise InputError('缺少湿度数据') else: if self.access_sensor_times == 2 and self.time_step < 2.5: raise InputError('使用传感器,需要更多等待时间') if self.sensor_comp is None: try: port_list = list(list_ports.comports()) self.sensor_comp = port_list[1][0] except IndexError: raise InputError('检查串口连接情况') try: self.sensor_ser = Serial(self.sensor_comp, 9600, timeout=2) self.sensor = Sensor(self.sensor_ser) [self.temperature, self.humidity] = self.sensor.current_t_rh except Exception as e: raise InputError(f'串口错误:\n{e}') # Step Motor if self.motor_comp is None: try: self.motor_comp = list(list_ports.comports())[0][0] except Exception as e: raise InputError('检查串口连接情况\n' + str(e)) try: self.motor_ser = Serial(self.motor_comp, 9600, timeout=0.2) self.motor = StepMotor(self.motor_ser) except Exception as e: raise InputError('检查串口连接情况\n' + str(e)) # Network Analyzer try: self.na_average_factor = int(self.na_average_factor) except ValueError or TypeError: raise InputError('网分平均因子出错') if self.NA_identifier is None: try: self.NA_identifier = self.visa_rm.list_resources()[0] except Exception as e: raise InputError('检查网分连接情况\n' + str(e)) try: self.network_analysis_resource = self.visa_rm.open_resource( self.NA_identifier) self.NA = NetworkAnalyzer(self.network_analysis_resource, self.na_state, self.na_average_factor) except Exception as e: raise InputError('检查网分连接情况\n' + str(e)) def pass_parameters(self, measurement_object): """pass input parameters to measurement object""" measurement_object.len_total = self.len_total measurement_object.f0 = self.frequency * 1e6 measurement_object.num_of_measurements = self.num_of_mea measurement_object.len_step = self.len_step measurement_object.time_step = self.time_step measurement_object.na_average_factor = self.na_average_factor measurement_object.multi_measure = self.multi_measure measurement_object.temperature = self.temperature measurement_object.humidity = self.humidity / 100 measurement_object.access_sensor_times = self.access_sensor_times measurement_object.motor = self.motor measurement_object.sensor = self.sensor measurement_object.network_analyzer = self.NA measurement_object.cal_cavity_frequency() def access_sensor_once(self): self.access_sensor_times = 1 def access_sensor_repeat(self): self.access_sensor_times = 2 def manual_measure_temperature_humidity(self): self.access_sensor_times = 0 def set_auto_find_comp(self): self.sensor_comp = None self.motor_comp = None self.network_analysis_resource = None def close_ser(self): if isinstance(self.sensor_ser, Serial): self.sensor_ser.close() if isinstance(self.motor_ser, Serial): self.motor_ser.close() try: self.network_analysis_resource.close() except Exception: return def generate_measurement(self): """generate different measurement according to different strategy""" if self.measurement_strategy == 0: m1 = LongitudinalMeasurement() self.motor.set_distance(distance_mm=self.len_step) self.pass_parameters(m1) return m1 elif self.measurement_strategy == 1: m1 = AngularMeasurement() self.motor.set_distance(distance=20000 / self.num_of_mea) self.pass_parameters(m1) return m1 def save_input_file(self, file_name): file1 = open(file_name, 'w') file1.write( '& input parameters for field distribution measurement program\n') file1.write( '& lines begin with \'&\' will be ignored, \n' '& you don\'t have to write these lines in your input file.\n&\n&----------------------------\n&\n' ) file1.write( '& measurement strategy (0 for longitudinal measurement, 1 for angular measurement)\n' ) file1.write(f' {self.measurement_strategy}\n') if self.measurement_strategy == 0: file1.write('& total length movement step\n') file1.write(f' {self.len_total} {self.len_step}\n') elif self.measurement_strategy == 1: file1.write('& number of measurement\n') file1.write(f' {self.num_of_mea}\n') file1.write( '& waiting time multiple measurement time at each position (optional, default 1)\n' ) file1.write(f' {self.time_step} {self.multi_measure}\n') file1.write('& vacuum frequency\n') file1.write(f' {self.frequency}\n') file1.write('& temperature and humidity\n') if self.access_sensor_times == 0: file1.write(f' 0 {self.temperature} {self.humidity}\n') else: file1.write(f' {int(self.access_sensor_times)}\n') file1.write('& data storage directory\n') file1.write(f' {self.directory}\n') file1.write('& sensor (0 for auto find)\n') if self.sensor_comp is None: file1.write(f' 0\n') else: file1.write(f' {self.sensor_comp}\n') file1.write('& motor (0 for auto find)\n') if self.motor_comp is None: file1.write(f' 0\n') else: file1.write(f' {self.motor_comp}\n') file1.write('& network analyzer (0 for auto find)\n') if self.NA_identifier is None: file1.write(f' 0\n') else: file1.write(f' {self.NA_identifier}\n') file1.write('& network analyzer average factor\n') file1.write(f' {self.na_average_factor}\n') file1.write('& network analyzer state (optional)\n') if self.na_state is not None: file1.write(f' {self.na_state}\n') file1.close() def __str__(self): text = '' if self.measurement_strategy == 0: text += f'\n{"腔体长度":4} = {self.len_total:8f} mm' text += f"\n{'运动步长':4} = {self.len_step:8f} mm" elif self.measurement_strategy == 1: text += f"\n{'测量次数':4} = {self.num_of_mea:4f}" text += f"\n{'等待时间':4} = {self.time_step:8f} s" text += f"\n{'真空频率':4} = {self.frequency:8f} MHz" if self.access_sensor_times == 1 or self.access_sensor_times == 2: text += "\n温湿度数据由传感器提供\n" text += f"\n{'温度':4} = {self.temperature:8f} ℃" text += f"\n{'湿度':4} = {self.humidity:8f} %\n" return text
class lifetimeMeasurement(QWidget): 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 connectAll(self): # self.comboBox_laserController.currentTextChanged.connect(self.selectResources) self.pushButton_refresh.clicked.connect(self.refreshResources) self.pushButton_powerMeter.clicked.connect( self.refreshResourcesPowerMeter) self.pushButton_selectFolder.clicked.connect(self.selectFolder) self.pushButton_start.clicked.connect(self.startMeasure) self.pushButton_tmp.clicked.connect(self.clickTmp) # without singleShot, weird error occurs for pyvisa self.rm.open_resource for oscilloscope self.comboBox_laserController.currentIndexChanged.connect( lambda: QTimer.singleShot(0, self.updateResources)) # without singleShot, weird error occurs for pyvisa self.rm.open_resource for oscilloscope self.comboBox_oscilloscope.currentIndexChanged.connect( lambda: QTimer.singleShot(0, self.updateResources)) self.comboBox_powerMeter.currentIndexChanged.connect( lambda: QTimer.singleShot(0, self.updateResourcesPowerMeter)) self.pushButton_laserOn.clicked.connect( lambda: self.laser_controller.write("OUTP ON")) self.pushButton_laserOff.clicked.connect( lambda: self.laser_controller.write("OUTP OFF")) self.lineEdit_setpoint.editingFinished.connect(self.currentSetpoint) self.pushButton_selectFileFit.clicked.connect(self.selectFileFit) self.pushButton_fromFile.clicked.connect(self.loadDataFromCsv) self.pushButton_fromMeasurement.clicked.connect( self.loadDataFromMeasurement) self.pushButton_fitDecay.clicked.connect(self.fitDecay) self.pushButton_saveFittedCurve.clicked.connect(self.saveFittedCurve) self.pushButton_startScanning.clicked.connect(self.startScanning) self.pushButton_scanFromMeasure.clicked.connect( self.loadScanDataFromMeasurement) self.pushButton_scanSave.clicked.connect(self.saveScanData) self.pushButton_scanFromFile.clicked.connect(self.loadScanDataFromFile) self.pushButton_scanFromMeasure_2.clicked.connect( self.loadScanDataFromMeasurement2) self.pushButton_scanFromFile_2.clicked.connect( self.loadScanDataFromFile2) # def selectResources(self): # self.laserController = self.comboBox_laserController.currentText() # self.oscilloscope = self.comboBox_oscilloscope.currentText() def clickTmp(self): print('on: ', np.shape(self.on_list)) print('off: ', np.shape(self.off_list)) def load_ui(self): path = os.path.join(os.path.dirname(__file__), "form.ui") uic.loadUi(path, self) def listResources(self): usb_list = self.rm.list_resources() print(usb_list) for item in usb_list: self.comboBox_laserController.addItem(item) self.comboBox_oscilloscope.addItem(item) self.comboBox_powerMeter.addItem(item) if "DS6D150100004" in item: self.comboBox_oscilloscope.setCurrentText( item) # find and define oscilloscope USB port elif "M00460823" in item: self.comboBox_laserController.setCurrentText( item) # find and define laser controller USB port elif "P0016683" in item: self.comboBox_powerMeter.setCurrentText( item) # find and define laser controller USB port # print(__file__) def refreshResources(self): self.comboBox_laserController.clear() self.comboBox_oscilloscope.clear() self.listResources() def refreshResourcesPowerMeter(self): self.comboBox_powerMeter.clear() self.listResources() def selectFolder(self): filename = QFileDialog.getExistingDirectory(self, 'select directory') self.lineEdit_folder.setText(filename) # def abort(self): # pass def updateResources(self): # self.rm.close() # self.rm = ResourceManager() # print(self.comboBox_laserController.currentText()) self.laser_controller = self.rm.open_resource( self.comboBox_laserController.currentText()) # print(self.comboBox_oscilloscope.currentText()) self.oscilloscope = self.rm.open_resource( self.comboBox_oscilloscope.currentText()) print('update resources: laser_controller:', self.comboBox_laserController.currentText(), ' oscilloscope:', self.comboBox_oscilloscope.currentText()) def updateResourcesPowerMeter(self): self.powerMeter = self.rm.open_resource( self.comboBox_powerMeter.currentText()) print('update resources: powerMeter:', self.comboBox_powerMeter.currentText()) def currentSetpoint(self): currSetpoint = self.lineEdit_setpoint.text() try: currSetpointValue = int(currSetpoint) print(currSetpointValue) self.laser_controller.write("SOUR:CURR {}".format( currSetpointValue / 1e4)) except: self.lineEdit_setpoint.editingFinished.disconnect() msg = QMessageBox() msg.setIcon(QMessageBox.Information) msg.setText("Laser Current Setpoint must be integers") # msg.setInformativeText("This is additional information") msg.setWindowTitle("Warning") # msg.setDetailedText("The details are as follows:") # msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel) # msg.buttonClicked.connect(msgbtn) msg.exec_() self.lineEdit_setpoint.editingFinished.connect( self.currentSetpoint) # print # "value of pressed message box button:", retval def startMeasure(self): # self.rm.close() # self.rm = ResourceManager() self.laser_controller = self.rm.open_resource( self.comboBox_laserController.currentText()) self.oscilloscope = self.rm.open_resource( self.comboBox_oscilloscope.currentText()) self.steps = self.spinBox_turns.value() self.stepsDouble = self.steps * 2 waiting_time = self.spinBox_acquiringTime.value() timeBetweenTurns = self.spinBox_timeBetweenTurns.value() self.spinBox_turns.setEnabled(False) self.spinBox_acquiringTime.setEnabled(False) self.spinBox_timeBetweenTurns.setEnabled(False) self.spinBox_xaxis.setEnabled(False) # self.pushButton_start.setText('Abort') # self.process = QProcess(self) # # QProcess emits `readyRead` when there is data to be read # self.process.readyRead.connect(self.dataReady) # self.runButton1.clicked.connect(self.process.kill) print(self.steps, waiting_time, timeBetweenTurns) self.label_turnsLeft.setText('Turns Finished: 0/' + str(self.steps)) self.totalTime = int( (self.stepsDouble) * (waiting_time + timeBetweenTurns)) - timeBetweenTurns + 1 self.timeLeft = self.totalTime print(self.timeLeft) self.countdown(intervalSecond=1) self.progressBar.setValue(0) self.on_list = [] self.off_list = [] # self.measureEachTurn(-1,laser_controller,oscilloscope,stepsDouble,waiting_time=waiting_time,timeBetweenTurns=timeBetweenTurns) self.timerLaserControl = QTimer() self.timerOscilloscopeRun = QTimer() self.timerOscilloscopeStop = QTimer() # self.currTurn = 0 # self.timerLaserControl.timeout.connect( lambda: self.laserControl(self.laser_controller)) self.timerOscilloscopeRun.timeout.connect( lambda: self.oscilloscopeRun(self.oscilloscope)) self.timerOscilloscopeStop.timeout.connect( lambda: self.oscilloscopeStop(self.oscilloscope)) self.laserControl(self.laser_controller) self.oscilloscopeRun(self.oscilloscope) QTimer.singleShot(int(waiting_time * 1e3), lambda: self.oscilloscopeStop(self.oscilloscope)) self.timerLaserControl.start( int((waiting_time + timeBetweenTurns) * 1e3)) self.timerOscilloscopeRun.start( int((waiting_time + timeBetweenTurns) * 1e3)) QTimer.singleShot( int(waiting_time * 1e3), lambda: self.timerOscilloscopeStop.start( int((waiting_time + timeBetweenTurns) * 1e3))) QTimer.singleShot(int((self.totalTime) * 1e3), self.restartSpinBoxes) def restartSpinBoxes(self): self.spinBox_turns.setEnabled(True) self.spinBox_acquiringTime.setEnabled(True) self.spinBox_timeBetweenTurns.setEnabled(True) self.spinBox_xaxis.setEnabled(True) def laserControl(self, laser_controller): # print(self.currTurn) if self.currTurn % 2 == 0: laser_controller.write("OUTP ON") print('laser on') else: laser_controller.write("OUTP OFF") print('laser off') def oscilloscopeRun(self, oscilloscope): oscilloscope.write(":RUN") print('oscilloscopeRun') def oscilloscopeStop( self, oscilloscope, start=1, points=70000000, ): if self.currTurn == self.stepsDouble - 1: print('stop properly') self.timerLaserControl.stop() self.timerOscilloscopeRun.stop() self.timerOscilloscopeStop.stop() wt = 0 oscilloscope.write(":STOP") oscilloscope.write( ":WAV:MODE NORM" ) # RAW means deeper raw data. NORM means displayed data time.sleep(wt) oscilloscope.write(":WAV:STAR " + str(start)) time.sleep(wt) oscilloscope.write(":WAV:STOP " + str(points + start)) time.sleep(wt) oscilloscope.write(":WAV:POIN " + str(points)) time.sleep(wt) oscilloscope.write(":WAV:SOUR CHAN1") time.sleep(wt) oscilloscope.write(":WAV:RES") time.sleep(wt) oscilloscope.write(":WAV:BEG") time.sleep(wt) rawdata = oscilloscope.query_binary_values(':WAV:DATA?', datatype='B', is_big_endian=False) if self.currTurn % 2 == 0: self.on_list.append(rawdata) print('onlist append') else: self.off_list.append(rawdata) print('offlist append') self.label_turnsLeft.setText( 'Turns Finished: ' + str(int(np.floor((self.currTurn + 1) / 2))) + '/' + str(int(self.steps))) QTimer.singleShot(500, self.plotDecay) QTimer.singleShot(500, lambda: print('plotDecay')) self.currTurn += 1 print('oscilloscopeStop') def countdown(self, intervalSecond): self.timerCountdown = QTimer() # print(123) self.timerCountdown.timeout.connect( lambda: self.updateCountdown(intervalSecond)) self.timerCountdown.start(int(intervalSecond * 1e3)) # print(456) def updateCountdown(self, intervalSecond): self.timeLeft -= intervalSecond self.progressBar.setValue( int((self.totalTime - self.timeLeft) / self.totalTime * 100)) newtime = time.strftime('%H : %M : %S', time.gmtime(self.timeLeft)) self.label_countdown.setText("Time Left: " + newtime + " (hh : mm : ss)") print(newtime) if self.timeLeft == 0: self.timerCountdown.stop() # "Time Left: 00 : 00 : 00 (hh : mm : ss)" def plotDecay(self): unitTime = int(self.spinBox_xaxis.value()) currentDecay = np.asarray([ item1 - item2 for item1, item2 in zip(self.on_list[-1], self.off_list[-1]) ]) self.widget_currentDecay.clear() self.xaxis = unitTime * 14 / len(currentDecay) * np.asarray( range(len(currentDecay))) self.widget_currentDecay.plot(self.xaxis, currentDecay) on_mean = np.mean(self.on_list, axis=0) off_mean = np.mean(self.off_list, axis=0) self.averagedDecay = np.array( [item1 - item2 for item1, item2 in zip(on_mean, off_mean)]) self.widget_averagedDecay.clear() self.widget_averagedDecay.plot(self.xaxis, self.averagedDecay) path = self.lineEdit_folder.text() filename = self.lineEdit_file.text() self.saveFiles(path, filename, self.on_list, self.off_list, self.averagedDecay, self.xaxis) def saveFiles(self, path, filename, rawdata_on, rawdata_off, averaged, xaxis): df1 = DataFrame(rawdata_on).T df2 = DataFrame(rawdata_off).T df3 = DataFrame(averaged) df1 = df1.rename(columns={0: 'signal'}) df2 = df2.rename(columns={0: 'signal'}) df3 = df3.rename(columns={0: 'signal'}) df1.index = xaxis df2.index = xaxis df3.index = xaxis df1.index.name = 'Time(ns)' df2.index.name = 'Time(ns)' df3.index.name = 'Time(ns)' df1.to_csv(path + '/' + filename + '_on.csv') df2.to_csv(path + '/' + filename + '_off.csv') df3.to_csv(path + '/' + filename + '_averaged.csv') def selectFileFit(self): filename, _ = QFileDialog.getOpenFileName( self, 'select *_averaged.csv file') self.lineEdit_selectFileFit.setText(filename) def loadDataFromCsv(self): self.widget_fitting.clear() dataLoaded = read_csv(self.lineEdit_selectFileFit.text(), index_col=0) self.dataLoadedX = np.asarray(dataLoaded.index) if self.checkBox_inversed.isChecked(): self.dataLoadedY = -np.asarray(dataLoaded['signal']) else: self.dataLoadedY = np.asarray(dataLoaded['signal']) # print(self.dataLoaded) self.widget_fitting.plot(self.dataLoadedX, self.dataLoadedY) def loadDataFromMeasurement(self): self.widget_fitting.clear() self.dataLoadedX = self.xaxis if self.checkBox_inversed.isChecked(): self.dataLoadedY = -self.averagedDecay else: self.dataLoadedY = self.averagedDecay self.widget_fitting.plot(self.dataLoadedX, self.dataLoadedY) def fitDecay(self): self.widget_fitting.clear() self.widget_fitting.plot(self.dataLoadedX, self.dataLoadedY) if self.radioButton_decay1.isChecked(): decay = decay1 bounds = [[0, 0, -np.inf], np.inf] elif self.radioButton_decay2.isChecked(): decay = decay2 bounds = [[0, 0, 0, 0, -np.inf], np.inf] elif self.radioButton_decay3.isChecked(): decay = decay3 bounds = [[0, 0, 0, 0, 0, 0, -np.inf], np.inf] starting = self.doubleSpinBox_starting.value() ending = self.doubleSpinBox_ending.value() selectedIndices = np.where( np.logical_and(self.dataLoadedX > starting, self.dataLoadedX < ending))[0] xSelected = self.dataLoadedX[selectedIndices] ySelected = self.dataLoadedY[selectedIndices] xFit = normalize(xSelected) params, corrs = curve_fit(decay, xFit, ySelected, bounds=bounds) self.yFitted = decay(xFit, *params) self.xFitReal = np.round(denormalize(xFit, xSelected), 2) self.widget_fitting.plot(self.xFitReal, self.yFitted, pen=mkPen(color='r')) if decay == decay1: self.textBrowser_result.setText( 'A=' + str(np.round(params[0], 5)) + ', t=' + str(np.round(denormalize(params[1], xSelected), 5)) + ', y0=' + str(np.round(params[2], 5))) elif decay == decay2: # paramIndices = np.argsort([params[1],params[2]]) self.textBrowser_result.setText( 'A1=' + str(np.round(params[0], 5)) + ', A2=' + str(np.round(params[1], 5)) + ', t1=' + str(np.round(denormalize(params[2], xSelected), 5)) + ', t2=' + str(np.round(denormalize(params[3], xSelected), 5)) + ', y0=' + str(np.round(params[4], 5))) elif decay == decay3: self.textBrowser_result.setText( 'A1=' + str(np.round(params[0], 5)) + ', A2=' + str(np.round(params[1], 5)) + ', A3=' + str(np.round(params[2], 5)) + ', t1=' + str(np.round(denormalize(params[3], xSelected), 5)) + ', t2=' + str(np.round(denormalize(params[4], xSelected), 5)) + ', t3=' + str(np.round(denormalize(params[5], xSelected), 5)) + ', y0=' + str(np.round(params[6], 5))) def saveFittedCurve(self): path = QFileDialog.getSaveFileName( self, 'Save Fitted Curve with Data', './', "csv Files (*.csv);;All Files (*)")[0] df1 = DataFrame(self.dataLoadedY).rename(columns={0: 'signal'}) df1.index = self.dataLoadedX df2 = DataFrame(self.yFitted).rename(columns={0: 'fitting'}) df2.index = self.xFitReal df = df1.join(df2) df.index.name = 'Time(ns)' print(path) # print(df) df.to_csv(path) def startScanning(self): self.tableWidget_scanCurrent.setRowCount(0) self.progressBar_currentScan.setValue(0) self.current_list = [] self.power_list = [] self.laser_controller = self.rm.open_resource( self.comboBox_laserController.currentText()) self.powerMeter = self.rm.open_resource( self.comboBox_powerMeter.currentText()) starting = self.spinBox_currentStart.value() * 1e-4 self.scanCurrent = np.round(starting, 6) ending = self.spinBox_currentEnd.value() * 1e-4 steps = self.spinBox_currentSteps.value() currentDelta = float(ending - starting) / steps time = self.spinBox_currentTime.value() step_time = int(float(time) / steps * 1e3) self.tmpIndexScan = 0 self.scanTimer = QTimer() self.scanTimer.timeout.connect( lambda: self.getPower(currentDelta, self.current_list, self. power_list, starting, ending, steps)) self.scanTimer.start(step_time) print('scanning started', self.scanTimer) def getPower(self, currentDelta, current_list, power_list, starting, ending, steps): flag = False if self.tmpIndexScan >= steps: #self.scanCurrent>ending: self.scanTimer.stop() self.progressBar_currentScan.setValue(100) flag = True # del self.tmpIndexScan # current input self.laser_controller.write("SOUR:CURR {}".format(self.scanCurrent)) power = self.powerMeter.query('Measure:Scalar:POWer?') self.tableWidget_scanCurrent.insertRow( self.tableWidget_scanCurrent.rowCount()) self.tableWidget_scanCurrent.setItem( self.tmpIndexScan, 0, QTableWidgetItem(str(int(self.scanCurrent * 1e4)))) self.tableWidget_scanCurrent.setItem( self.tmpIndexScan, 1, QTableWidgetItem(str(float(power) * 1e6))) current_list.append(np.float(self.scanCurrent)) power_list.append(np.float(power)) self.scanCurrent += currentDelta self.scanCurrent = np.round(self.scanCurrent, 6) self.tmpIndexScan += 1 self.progressBar_currentScan.setValue( int((self.scanCurrent - starting) / (ending - starting) * 100)) if flag == True: #self.scanCurrent>ending: self.laser_controller.write("SOUR:CURR {}".format(0)) print(self.scanCurrent, power) def fillScanTable(self, tableWidget, scan_current_list, scan_power_list): tableWidget.setRowCount(0) tableWidget.setRowCount(len(scan_current_list)) for ind in range(len(scan_current_list)): tableWidget.setItem( ind, 0, QTableWidgetItem(str(int(scan_current_list[ind] * 1e4)))) tableWidget.setItem( ind, 1, QTableWidgetItem(str(float(scan_power_list[ind]) * 1e6))) def loadScanDataFromMeasurement(self): self.fillScanTable(self.tableWidget_scanCurrent, self.current_list, self.power_list) def loadScanDataFromMeasurement2(self): self.fillScanTable(self.tableWidget_scanCurrent_2, self.current_list, self.power_list) def saveScanData(self): path = QFileDialog.getSaveFileName( self, 'Save Measured Powers with Currents', './', "csv Files (*.csv);;All Files (*)")[0] df = DataFrame({ 'Current (A)': self.current_list, 'Power (W)': self.power_list }) df.to_csv(path, index=False) def loadScanDataFromFile(self): path = QFileDialog.getOpenFileName(self, 'Selected Saved *csv File')[0] df = read_csv(path, index_col=None) file_current_list = df.iloc[:, 0].values file_power_list = df.iloc[:, 1].values self.fillScanTable(self.tableWidget_scanCurrent, file_current_list, file_power_list) def loadScanDataFromFile2(self): path = QFileDialog.getOpenFileName(self, 'Selected Saved *csv File')[0] df = read_csv(path, index_col=None) file_current_list = df.iloc[:, 0].values file_power_list = df.iloc[:, 1].values self.fillScanTable(self.tableWidget_scanCurrent_2, file_current_list, file_power_list)