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 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 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 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_servers(self):
""" Searches through active servers and connects/launches them """
for server in self.config_dict['servers']:
module_name = server['type']
if "script" in server and server["script"] == "True":
server_config = load_script_config(module_name,
server['config'],
self.logger)
else:
server_config = load_device_config(module_name,
server['config'],
self.logger)
matches = []
for connector in self.connectors.values():
# Add servers that have the correct name and ID
if (connector.name.startswith(module_name)) and (
server_config['device_id'] == connector.device_id):
matches.append(connector)
if 'auto_connect' in server and server['auto_connect'] == 'False':
auto_connect = False
else:
auto_connect = True
self._connect_matched_servers(matches, module_name,
server['config'], server_config,
auto_connect)
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 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 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):
# 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(**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 launch(**kwargs):
""" Connects to spectrum analyzer and instantiates server
:param kwargs: (dict) containing relevant kwargs
:logger: instance of LogClient for logging purposes
:port: (int) port number for the spectrum analyzer server
"""
config = kwargs['config']
config = load_device_config('CLD101x', config, logger=kwargs['logger'])
il = laser.Driver(gpib_address=config['device_id'],
logger=kwargs['logger'])
# Instantiate Server
il_service = Service()
il_service.assign_module(module=il)
il_service.assign_logger(logger=kwargs['logger'])
il_server = GenericServer(service=il_service,
host=socket.gethostbyname_ex(
socket.gethostname())[2][0],
port=kwargs['port'])
il_server.start()
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 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 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 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()