def launch(**kwargs): """ Connects to TP Link HS103 Smart Plug :param kwargs: (dict) containing relevant kwargs :logger: instance of LogClient for logging purposes :device_id: (int) Location of Smart plug (e.g. Powermeter Front Smart Plug) """ logger=kwargs['logger'] config = load_device_config('tp_link_hs103', kwargs['config']) smart_plug = Driver( logger=kwargs['logger'], channels=config['channels'] ) # Instantiate Server smart_plug_service = Service() smart_plug_service.assign_module(module=smart_plug) smart_plug_service.assign_logger(logger=kwargs['logger']) smart_plug_server = GenericServer( service=smart_plug_service, host=get_ip(), port=kwargs['port'] ) smart_plug_server.start()
def launch(**kwargs): """ Connects to ANC3000 and instantiates server :param kwargs: (dict) containing relevant kwargs :logger: instance of LogClient for logging purposes :port: (int) port number for the Cnt Monitor server """ device_config = load_device_config('anc300', kwargs['config'], logger=kwargs['logger']) telnet_config = device_config['telnet_config'] anc300 = ANC300(host=telnet_config['host'], port=telnet_config['port'], query_delay=device_config['query_delay'], passwd=telnet_config['passwd'], limits=device_config['limits'], logger=kwargs['logger']) anc300_service = Service() anc300_service.assign_module(module=anc300) anc300_service.assign_logger(logger=kwargs['logger']) anc300_server = GenericServer(service=anc300_service, host=get_ip(), port=kwargs['port']) anc300_server.start()
def launch(**kwargs): """ Connects to NI-daqMX card and launches server Identical to nidaqmx, except uses "device_ai" in the config file as the device name :param kwargs: (dict) containing relevant kwargs :logger: instance of LogClient for logging purposes :port: (int) port number for the Cnt Monitor server """ # Instantiate driver logger = kwargs['logger'] config = kwargs['config'] config = load_device_config('agc_100', config, logger=kwargs['logger']) port_name = config['device_id'] agc = AGC_100(port=port_name, logger=logger) agc_service = Service() agc_service.assign_module(module=agc) agc_service.assign_logger(logger=logger) agc__server = GenericServer( service=agc_service, host=get_ip(), port=kwargs['port'] ) agc__server.start()
def launch(**kwargs): """ Connects to a NI DAQ as staticline :param kwargs: (dict) containing relevant kwargs :logger: instance of LogClient for logging purposes :port: (int) port number for the Cnt Monitor server """ staticline_logger = kwargs['logger'] # Instantiate HDAWG driver. hd = zi_hdawg.Driver(dev_id, logger=staticline_logger) aom = staticline.Driver( name='AOM', logger=staticline_logger, hardware_module=hd, DIO_bit=30, ) # Instantiate Server # Staticline server staticline_service = Service() staticline_service.assign_module(module=aom) staticline_service.assign_logger(logger=staticline_logger) staticline_service_server = GenericServer(service=staticline_service, host=get_ip(), port=kwargs['port']) staticline_service_server.start()
def launch(**kwargs): """ Connects to Tektronix TDS2004C oscilloscope and launches server :param kwargs: (dict) containing relevant kwargs :logger: instance of LogClient for logging purposes :port: (int) port number for the Cnt Monitor server """ # Instantiate driver tektronix_logger = kwargs['logger'] tektronix_driver = tektronix_tds2004C.Driver( gpib_address=kwargs['device_id'], logger=tektronix_logger ) # Instantiate server tektronix_service = Service() tektronix_service.assign_module(module=tektronix_driver) tektronix_service.assign_logger(logger=tektronix_logger) tektronix_server = GenericServer( service=tektronix_service, host=get_ip(), port=kwargs['port'] ) tektronix_server.start()
def launch(**kwargs): """ Connects to NI-daqMX card and launches server Identical to nidaqmx, except uses "device_ai" in the config file as the device name :param kwargs: (dict) containing relevant kwargs :logger: instance of LogClient for logging purposes :port: (int) port number for the Cnt Monitor server """ # Instantiate driver logger = kwargs['logger'] config = kwargs['config'] config = load_device_config('fw102c', config, logger=kwargs['logger']) device_name = config['device_name'] port_name = config['device_id'] filters = config['filters'] filters = {f'{i+1}': f'{filters[i]} OD' for i in range(len(filters))} filterwheel = FW102CFilterWheel(port_name=port_name, device_name=device_name, filters=filters, logger=logger) filterwheel_service = Service() filterwheel_service.assign_module(module=filterwheel) filterwheel_service.assign_logger(logger=logger) filterwheel_service_server = GenericServer(service=filterwheel_service, host=get_ip(), port=kwargs['port']) filterwheel_service_server.start()
def launch(**kwargs): """ Connects to a NI DAQ as staticline :param kwargs: (dict) containing relevant kwargs :logger: instance of LogClient for logging purposes :port: (int) port number for the Cnt Monitor server """ staticline_logger = kwargs['logger'] daq = nidaqmx.Driver(device_name=NI_DEVICE_NAME, logger=staticline_logger) test_staticline = staticline.Driver( name='Green Imaging Laser', logger=kwargs['logger'], hardware_module=daq, ao_output='ao2', down_voltage=0, up_voltage=3.3, ) # Instantiate Server # Staticline server staticline_service = Service() staticline_service.assign_module(module=test_staticline) staticline_service.assign_logger(logger=staticline_logger) staticline_service_server = GenericServer(service=staticline_service, host=get_ip(), port=kwargs['port']) staticline_service_server.start()
def launch(**kwargs): """ Launches the WLM monitor + lock script """ logger = kwargs['logger'] clients = kwargs['clients'] config = load_script_config(script='laser_stabilizer', config=kwargs['config'], logger=logger) for server in config['servers']: if 'name' in server: if server['name'] == 'input': ai_client = find_client(clients=clients, settings=config, client_type=server['type'], client_config=server['config'], logger=logger) if server['name'] == 'output': ao_client = find_client(clients=clients, settings=config, client_type=server['type'], client_config=server['config'], logger=logger) if server['type'] == 'zi_hdawg': hd = find_client(clients=clients, settings=config, client_type='zi_hdawg', client_config=server['config'], logger=logger) if config['check_aom'] == "True": check_aom = True else: check_aom = False # Instantiate Monitor script laser_stabilizer = LaserStabilizer(config=config, ao_client=ao_client, ai_client=ai_client, hd=hd, check_aom=check_aom, logger=logger) update_service = Service() update_service.assign_module(module=laser_stabilizer) update_service.assign_logger(logger=logger) update_server, update_port = create_server(update_service, logger, host=get_ip()) logger.update_data(data={'port': update_port}) laser_stabilizer.gui.set_network_info(port=update_port) update_server.start() # Run continuously # Note that the actual operation inside run() can be paused using the update server while True: laser_stabilizer.run()
def __init__(self, ctr_client: si_tt.Client, ui='count_monitor', logger_client=None, server_port=None, combined_channel=False, config=None): """ Constructor for CountMonitor script :param ctr_client: instance of hardware client for counter :param gui_client: (optional) instance of client of desired output GUI :param logger_client: (obj) instance of logger client. :param server_port: (int) port number of script server :combined_channel: (bool) If true, show additional trace with summed counts. """ self._ctr = ctr_client self.log = logger_client self.combined_channel = combined_channel self._bin_width = None self._n_bins = None self._ch_list = None self._plot_list = None # List of channels to assign to each plot (e.g. [[1,2], [3,4]]) self._plots_assigned = [ ] # List of plots on the GUI that have been assigned if self.combined_channel: ui = 'count_monitor_combined' else: ui = 'count_monitor' # Instantiate GUI window self.gui = Window(gui_template=ui, host=get_ip(), port=server_port) # Setup stylesheet. self.gui.apply_stylesheet() if self.combined_channel: num_plots = 3 else: num_plots = 2 # Get all GUI widgets self.widgets = get_gui_widgets(self.gui, graph_widget=num_plots, number_label=8, event_button=num_plots, legend_widget=num_plots) # Load config self.config = {} if config is not None: self.config = load_script_config(script='monitor_counts', config=config, logger=self.logger_client) if not 'name' in self.config: self.config.update({'name': f'monitor{np.random.randint(1000)}'})
def start_logger(self): """ Starts the log server """ self.log_service = LogService() if self.LOG_PORT is None and not self.master: self.log_server, self.log_port = create_server(self.log_service, host=get_ip()) else: try: self.log_server = GenericServer(service=self.log_service, host=get_ip(), port=self.log_port) except ConnectionRefusedError: print( f'Failed to insantiate Log Server at port {self.LOG_PORT}') raise self.log_server.start() self.log_service.logger.info('log service succesfully started')
def __init__(self, nanopos_client: smaract_mcs2.Client, attocube_client: attocube_anc300.Client, gui='positioner_control_mixed', log_client=None, config=None, port=None): """ Instantiates the controller :param nanopos_client: (pylabnet.network.client_server.smaract_mcs2.Client) :param gui: name of .ui file ot use :param log_client: (pylabnet.utils.logging.logger.LogClient) :param config: (str) name of config file, optional :param port: (int) port number for update/script server """ self.pos = nanopos_client self.attocube = attocube_client self.log = LogHandler(logger=log_client) self.gui = Window(gui_template=gui, host=get_ip(), port=port) self.gui.apply_stylesheet() self.widgets = get_gui_widgets(self.gui, **self.WIDGET_DICT) self.save_params = generate_widgets( dict(n_steps=self.NUM_CHANNELS, amplitude=self.NUM_CHANNELS, frequency=self.NUM_CHANNELS, velocity=self.NUM_CHANNELS)) # Additional attributes self.prev_amplitude = [50] * self.NUM_CHANNELS self.prev_frequency = [30] * self.NUM_CHANNELS self.prev_velocity = [100] * self.NUM_CHANNELS self.prev_voltage = [50] * self.NUM_CHANNELS self.voltage_override = False self.config = config self.lock_status = [False] * int(self.NUM_CHANNELS / 3) self.released = [False] * self.NUM_CHANNELS self.gui.config_label.setText(self.config) # Configure all button and parameter updates self._setup_gui() # Setup shortcut to use keyboard to step fiber self.press_right = QShortcut(QKeySequence('Right'), self.gui) self.press_left = QShortcut(QKeySequence('Left'), self.gui) self.press_up = QShortcut(QKeySequence('Up'), self.gui) self.press_down = QShortcut(QKeySequence('Down'), self.gui) self.press_up_z = QShortcut(QKeySequence('PgUp'), self.gui) self.press_down_z = QShortcut(QKeySequence('PgDown'), self.gui) self.widgets['keyboard_change_combo'].currentIndexChanged.connect( self._bind_arrow_keys)
def launch(**kwargs): """ Connects to SI TT and instantiates server :param kwargs: (dict) containing relevant kwargs :logger: instance of LogClient for logging purposes :port: (int) port number for the Cnt Monitor server """ if not IMPORT_STATUS: msg_str = 'Please make sure Swabian Instruments drivers are installed on this machine.' raise ModuleNotFoundError(msg_str) TT.setTimeTaggerChannelNumberScheme(TT.TT_CHANNEL_NUMBER_SCHEME_ONE) # Connect to the device, otherwise instantiate virtual connection try: tagger = TT.createTimeTagger() except RuntimeError: kwargs['logger'].warn('Failed to connect to Swabian Instruments Time Tagger.' ' Instantiating virtual device instead') tagger = TT.createTimeTaggerVirtual() try: config = kwargs['config'] config = load_device_config('si_tt', config, logger=kwargs['logger']) except: config = None # if config is None: # try: # config = load_device_config('si_tt', logger=kwargs['logger']) # except: # config = {} for channel, trig_level in config['triggers'].items(): tagger.setTriggerLevel(int(channel), float(trig_level)) cnt_trace_wrap = Wrap( tagger=tagger, logger=kwargs['logger'] ) # Instantiate Server cnt_trace_service = Service() cnt_trace_service.assign_module(module=cnt_trace_wrap) cnt_trace_service.assign_logger(logger=kwargs['logger']) cnt_trace_server = GenericServer( service=cnt_trace_service, host=get_ip(), port=kwargs['port'] ) cnt_trace_server.start()
def __init__(self, logger=None, client_tuples=None, config=None, config_name=None): self.log = LogHandler(logger) self.dataset = None # Instantiate GUI window self.gui = Window(gui_template='data_taker', host=get_ip()) # Configure list of experiments self.gui.config.setText(config_name) self.config = config self.exp_path = self.config['exp_path'] if self.exp_path is None: self.exp_path = os.getcwd() sys.path.insert(1, self.exp_path) self.update_experiment_list() # Configure list of clients self.clients = {} # Retrieve Clients for client_entry in self.config['servers']: client_type = client_entry['type'] client_config = client_entry['config'] client = find_client(clients=client_tuples, settings=client_config, client_type=client_type, client_config=client_config, logger=self.log) self.clients[f"{client_type}_{client_config}"] = client for client_name, client_obj in self.clients.items(): client_item = QtWidgets.QListWidgetItem(client_name) client_item.setToolTip(str(client_obj)) self.gui.clients.addItem(client_item) # Configure dataset menu for name, obj in inspect.getmembers(datasets): if inspect.isclass(obj) and issubclass(obj, datasets.Dataset): self.gui.dataset.addItem(name) # Configure button clicks self.gui.configure.clicked.connect(self.configure) self.gui.run.clicked.connect(self.run) self.gui.save.clicked.connect(self.save) self.gui.load_config.clicked.connect(self.reload_config) self.gui.showMaximized() self.gui.apply_stylesheet()
def launch(**kwargs): config_dict = load_device_config('agilent_83732b', kwargs['config']) logger = kwargs['logger'] ag = Driver(config_dict['device_id'], logger) ag_service = Service() ag_service.assign_module(module=ag) ag_service.assign_logger(logger=kwargs['logger']) ag_server = GenericServer(service=ag_service, host=get_ip(), port=kwargs['port']) ag_server.start()
def __init__(self, filterwheel1, filterwheel2, gui='toptica_filterwheels', logger=None, port=None): self.filterwheel1 = filterwheel1 self.filterwheel2 = filterwheel2 self.log = LogHandler(logger) # Setup GUI self.gui = Window(gui_template=gui, host=get_ip(), port=port) # Get Widgets self.widgets = get_gui_widgets(self.gui, comboBox_filter1=1, comboBox_filter2=1, nd_label=1) # Retrieve filter dicts. filters1 = filterwheel1.get_filter_dict() filters2 = filterwheel2.get_filter_dict() # Fill comboboxes. self.widgets['comboBox_filter1'].addItems(filters1.values()) self.widgets['comboBox_filter2'].addItems(filters2.values()) # Get current fitler positions self.current_pos_1 = filterwheel1.get_pos() self.current_pos_2 = filterwheel2.get_pos() # Set comboboxes to current filter positions. self.widgets['comboBox_filter1'].setCurrentIndex( int(self.current_pos_1) - 1) self.widgets['comboBox_filter2'].setCurrentIndex( int(self.current_pos_2) - 1) # Connect change events self.widgets['comboBox_filter1'].currentTextChanged.connect( lambda: self.change_filter(filter_index=1)) self.widgets['comboBox_filter2'].currentTextChanged.connect( lambda: self.change_filter(filter_index=2)) # Update OD reading self.update_od() # Setup stylesheet. self.gui.apply_stylesheet()
def launch(**kwargs): """ Connects to MCS2 and instantiates server :param kwargs: (dict) containing relevant kwargs :logger: instance of LogClient for logging purposes :port: (int) port number for the Cnt Monitor server """ mcs2 = MCS2(logger=kwargs['logger']) mcs2_service = Service() mcs2_service.assign_module(module=mcs2) mcs2_service.assign_logger(logger=kwargs['logger']) mcs2_server = GenericServer(service=mcs2_service, host=get_ip(), port=kwargs['port']) mcs2_server.start()
def launch(**kwargs): """ Launches a dummy hardware driver and instantiates server """ log = kwargs['logger'] log.info(f'Launching with config {kwargs["config"]}') config = load_device_config( os.path.basename(__file__)[:-3], kwargs['config'], log) dum = Dummy() log.info(f'Created dummy object with configuration parameters {config}') dum_service = ServiceBase() dum_service.assign_module(module=dum) dum_service.assign_logger(logger=log) dum_server = GenericServer(service=dum_service, host=get_ip(), port=kwargs['port']) dum_server.start()
def launch(**kwargs): """Launches the script.""" logger = kwargs['logger'] clients = kwargs['clients'] try: staticline_gui = StaticLineGUIGeneric( config=kwargs['config'], staticline_clients=clients, logger_client=logger, host=get_ip(), port=kwargs['server_port'] ) except KeyError: logger.error('Please make sure the module names for required servers and GUIS are correct.') staticline_gui.run()
def launch(**kwargs): """ Connects to NI-daqMX card and launches server :param kwargs: (dict) containing relevant kwargs :logger: instance of LogClient for logging purposes :port: (int) port number for the Cnt Monitor server """ # Instantiate driver ni_daqmx_logger = kwargs['logger'] try: ni_driver = nidaqmx_card.Driver( device_name=kwargs['device_id'], logger=ni_daqmx_logger ) except AttributeError: try: config = load_config(kwargs['config']) ni_driver = nidaqmx_card.Driver( device_name=config['device'], logger=ni_daqmx_logger ) except AttributeError: ni_daqmx_logger.error('Please provide valid config file') raise except OSError: ni_daqmx_logger.error(f'Did not find NI daqMX name {config["device"]}') raise except KeyError: ni_daqmx_logger.error('No device name provided. ' 'Please make sure proper config file is provided') raise # Instantiate server ni_daqmx_service = Service() ni_daqmx_service.assign_module(module=ni_driver) ni_daqmx_service.assign_logger(logger=ni_daqmx_logger) ni_daqmx_server = GenericServer( service=ni_daqmx_service, host=get_ip(), port=kwargs['port'] ) ni_daqmx_server.start()
def launch(**kwargs): # Instantiate driver zi_logger = kwargs['logger'] device_id = load_device_config('zi_hdawg', kwargs['config'], logger=kwargs['logger'])['device_id'] hd = Driver(device_id, zi_logger) # Instantiate server hd_service = Service() hd_service.assign_module(module=hd) hd_service.assign_logger(logger=zi_logger) hd_server = GenericServer(service=hd_service, host=get_ip(), port=kwargs['port']) hd_server.start()
def _launch_script_server(self): """ Launches a GenericServer attached to this script to enable closing """ if 'script_service' in self.config_dict and self.config_dict[ 'script_service'] == 'True': spec = importlib.util.spec_from_file_location( self.name, self.config_dict['script']) mod = importlib.util.module_from_spec(spec) spec.loader.exec_module(mod) self.service = mod.Service() else: self.service = ServiceBase() self.service.assign_logger(logger=self.logger) self.script_server, self.script_server_port = create_server( service=self.service, logger=self.logger, host=get_ip()) self.script_server.start() self.logger.update_data(data=dict(port=self.script_server_port))
def launch(**kwargs): """ Connects to HWC T2220 (microwave source) and instantiates server :param kwargs: (dict) containing relevant kwargs :logger: instance of LogClient for logging purposes :port: (int) port number for the Hittite server """ config = kwargs['config'] config = load_device_config('HMC_T2220', config, logger=kwargs['logger']) mw_source = ht.Driver(logger=kwargs['logger'], gpib_address=config['device_id']) # Instantiate Server mw_service = Service() mw_service.assign_module(module=mw_source) mw_service.assign_logger(logger=kwargs['logger']) mw_server = GenericServer(service=mw_service, host=get_ip(), port=kwargs['port']) mw_server.start()
def __init__(self, dlc: toptica_dl_pro.Client, gui='toptica_control', logger=None, port=None): """ Initializes toptica specific parameters :param dlc: DLC client for the Toptica laser :param gui: .ui file to use :param logger: LogClient for logging purposes :param port: port number of script server """ self.log = LogHandler(logger) # Setup GUI self.gui = Window(gui_template=gui, host=get_ip(), port=port) self.widgets = get_gui_widgets(gui=self.gui, on_off=2, temperature=2, temperature_actual=2, current=2, current_actual=2, offset=2, amplitude=2, frequency=2, scan=2, update_temp=2, update_current=2, update_params=1) self.dlc = dlc self.offset = 65 self.amplitude = 100 self.scan = [False, False] self.emission = [False, False] # Setup stylesheet. self.gui.apply_stylesheet() self._setup_GUI()
def launch(**kwargs): """ Launches the sweeper GUI """ # logger, loghost, logport, clients, guis, params = unpack_launcher(**kwargs) logger = kwargs['logger'] clients = kwargs['clients'] config = load_script_config( 'histogram', kwargs['config'], logger ) ctr = find_client( clients, config, client_type='si_tt', client_config='standard_ctr', logger=logger ) # Instantiate Monitor script trace = TimeTraceGui( ctr=ctr, log=logger, config=config, ) update_service = Service() update_service.assign_module(module=trace) update_service.assign_logger(logger=logger) update_server, update_port = create_server(update_service, logger, host=get_ip()) logger.update_data(data={'port': update_port}) trace.gui.set_network_info(port=update_port) update_server.start() # Run continuously # Note that the actual operation inside run() can be paused using the update server while True: trace.gui.force_update()
def launch(**kwargs): """ Connects to MPC320 instantiates server :param kwargs: (dict) containing relevant kwargs :logger: instance of LogClient for logging purposes :port: (int) port number for the Cnt Monitor server """ settings = load_device_config('thorlabs_mpc320', kwargs['config'], logger=kwargs['logger']) dev_num = settings['device_id'] pol_paddle = Driver(device_num=int(dev_num), logger=kwargs['logger']) pol_paddle_service = Service() pol_paddle_service.assign_module(module=pol_paddle) pol_paddle_service.assign_logger(logger=kwargs['logger']) pol_paddle_service_server = GenericServer(service=pol_paddle_service, host=get_ip(), port=kwargs['port']) pol_paddle_service_server.start()
def launch(**kwargs): """ Connects to HF WS7 Wavemeter and launches server :param kwargs: (dict) containing relevant kwargs :logger: instance of LogClient for logging purposes :port: (int) port number for the Cnt Monitor server """ # Instantiate Logger wavemeter_logger = kwargs['logger'] # Instantiate Wavemeter object hf_wlm = Driver(logger=wavemeter_logger) # Instantiate Server wavemeter_service = Service() wavemeter_service.assign_module(module=hf_wlm) wavemeter_service.assign_logger(logger=wavemeter_logger) wavemeter_server = GenericServer(service=wavemeter_service, host=get_ip(), port=kwargs['port']) wavemeter_server.start()
def launch(**kwargs): """ Connects to DIO breakout and instantiates server :param kwargs: (dict) containing relevant kwargs :logger: instance of LogClient for logging purposes :port: (int) port number for the DIO breakout server :config: (str) name of config file to us """ device_config = load_device_config('dio_breakout', kwargs['config'], logger=kwargs['logger']) # Try to load settings if 'resource_name' in device_config: addr = device_config['resource_name'] else: addr = device_config['device_id'] # Try to connect try: dio = Driver(address=addr, logger=kwargs['logger']) # If it fails, prompt the user to enter GPIB address from resource list except VisaIOError: kwargs['logger'].error( f'Failed to connect to device at address {addr}') raise # Instantiate Service and server dio_service = Service() dio_service.assign_module(module=dio) dio_service.assign_logger(logger=kwargs['logger']) dio_server = GenericServer(service=dio_service, host=get_ip(), port=kwargs['port']) dio_server.start()
def launch(**kwargs): """ Connects to PM320E and instantiates server :param kwargs: (dict) containing relevant kwargs :logger: instance of LogClient for logging purposes :port: (int) port number for the Cnt Monitor server """ try: settings = load_device_config('thorlabs_pm320e', kwargs['config'], logger=kwargs['logger']) except KeyError: kwargs['logger'].warn('No config file was provided') try: pm = Driver( logger=kwargs['logger'], gpib_address=settings['device_id'], ) # Handle error of wrong GPIB address by allowing user to select # NOTE: this will fail if used from the main script launcher, since script client # will automatically try to connect (even though server isn't launched) # # TLDR: if you want to use launch-control, please fill in GPIB variable with # the correct resource string except: kwargs['logger'].error('Please check GPIB address, could not connect') pm_service = Service() pm_service.assign_module(module=pm) pm_service.assign_logger(logger=kwargs['logger']) pm_server = GenericServer(service=pm_service, host=get_ip(), port=kwargs['port']) pm_server.start()
def __init__(self, pm_client, gui='fiber_coupling', logger=None, calibration=None, name=None, port=None): """ Instantiates a monitor for 2-ch power meter with GUI :param pm_clients: (client, list of clients) clients of power meter :param gui_client: client of monitor GUI :param logger: instance of LogClient :calibration: (float) Calibration value for power meter. :name: (str) Humand-readable name of the power meter. """ self.log = LogHandler(logger) self.gui = Window(gui_template=gui, host=get_ip(), port=port) self.gui.apply_stylesheet() self.wavelength = [] self.calibration = calibration self.name = name self.ir_index, self.rr_index = [], [] self.pm = pm_client self.running = False self.num_plots = 3 # Get all GUI widgets self.widgets = get_gui_widgets(self.gui, graph_widget=self.num_plots, number_widget=4, label_widget=2, name_label=1, combo_widget=2) self._initialize_gui()
def launch(**kwargs): """ Connects to toptica laser and launches server :param kwargs: (dict) containing relevant kwargs """ # Instantiate driver toptica_logger = kwargs['logger'] config = load_device_config('toptica_dlc_pro', kwargs['config'], toptica_logger) dlc = DLC_Pro(host=config['host'], port=int(config['port']), logger=toptica_logger) # Instantiate server dlc_service = Service() dlc_service.assign_module(module=dlc) dlc_service.assign_logger(logger=toptica_logger) dlc_server = GenericServer(service=dlc_service, host=get_ip(), port=kwargs['port']) dlc_server.start()