def addControllerComboItems(self):
db = Database()
items = [""]
items.extend(db.get_device_exported("*/elotech*").value_string)
items.extend(db.get_device_exported("*/bestec*").value_string)
self.controllerCombo.addItems(
sorted(i for i in items if not i.startswith("dserver")))
def __init__(self, poolName, mntgrpName, flagClear):
self.db = Database()
#
# the pool for the Mg
#
try:
self.poolMg = DeviceProxy(poolName)
except Exception as e:
Except.print_exception(e)
print("failed to get proxy to ", poolName)
sys.exit(255)
#
# find the MG
#
try:
self.mg = DeviceProxy(mntgrpName)
except Exception:
lst = [mntgrpName, 'exp_t01', 'exp_c01', 'exp_c02']
self.poolMg.command_inout('CreateMeasurementGroup', lst)
self.mg = DeviceProxy(mntgrpName)
if not flagClear:
self.hsh = json.loads(self.mg.Configuration)
self.masterTimer = self.findMasterTimer()
self.index = len(self.mg.ElementList)
else:
self.hsh = {}
self.hsh[u'controllers'] = {}
self.hsh[u'description'] = "Measurement Group"
self.hsh[u'label'] = mntgrpName
self.index = 0
def addPressureComboItems(self):
db = Database()
items = [""]
items.extend(db.get_device_exported("*/vgct*").value_string)
items.extend(db.get_device_exported("*/mks*").value_string)
self.pressureCombo.addItems(
sorted(i for i in items if not i.startswith("dserver")))
def getSubDevice(filter):
exportedDevices = dict()
db = Database()
eDevices = db.get_device_exported(filter).value_string
for eDevice in eDevices:
sd = db.get_device_property(eDevice, "__SubDevices")["__SubDevices"]
for s in sd:
exportedDevices[s] = eDevice
return exportedDevices
def create_device(ctrl, addr, axis):
db = Database()
new_device_info_mcc = DbDevInfo()
new_device_info_mcc._class = "PhytronMcc2"
new_device_info_mcc.server = "PhytronMcc2/raspi14"
new_device = NAME + ctrl + '_' + addr + '_' + axis
print("Creating device: %s" % new_device)
new_device_info_mcc.name = new_device
db.add_device(new_device_info_mcc)
return (new_device)
def setUpClass(cls):
cls.db = Database()
cls.add_devices()
sleep(2)
for device_server in cls.REQUIRED_DEVICE_SERVERS:
cls.start_device_server(device_server)
sleep(2)
def generate_db_file(self, server, instance, device,
tangoclass=None, properties={}):
"""Generate a database file corresponding to the given arguments."""
if not tangoclass:
tangoclass = server
# Open the file
with open(self.db, 'w') as f:
f.write("/".join((server, instance, "DEVICE", tangoclass)))
f.write(': "' + device + '"\n')
# Create database
db = Database(self.db)
# Patched the property dict to avoid a PyTango bug
patched = dict((key, value if value != '' else ' ')
for key, value in properties.items())
# Write properties
db.put_device_property(device, patched)
return db
def append_device_to_db_file(server,
instance,
device,
db_file_name,
tangoclass=None,
properties={}):
"""Generate a database file corresponding to the given arguments."""
if not tangoclass:
tangoclass = server
# Open the file
with open(db_file_name, 'a') as f:
f.write("/".join((server, instance, "DEVICE", tangoclass)))
f.write(': "' + device + '"\n')
# Create database
db = Database(db_file_name)
# Patched the property dict to avoid a PyTango bug
patched = dict((key, value if value != '' else ' ')
for key, value in properties.items())
# Write properties
db.put_device_property(device, patched)
return db
def __init__(self, host=None, port=None, parent=None):
if host is None or port is None:
try:
_hp = TangoAuthority.get_default_tango_host()
host, port = _hp.rsplit(':', 1)
except Exception:
from taurus import warning
warning("Error getting default Tango host")
# Set host to fqdn
host = socket.getfqdn(host)
self.dbObj = Database(host, port)
self._dbProxy = None
self._dbCache = None
complete_name = "tango://%s:%s" % (host, port)
self.call__init__(TaurusAuthority, complete_name, parent)
try:
self.get_class_for_device(self.dev_name())
except:
# Ok, old tango database.
self.get_class_for_device = self.__get_class_for_device
def __init__(self, *args, **kwargs):
super(Memorised, self).__init__(*args, **kwargs)
self._tangodb = Database()
self._storeValue = {}
self._recoverValue = {}
class Memorised(_LinacFeature):
_storeValue = None
_recoverValue = None
def __init__(self, *args, **kwargs):
super(Memorised, self).__init__(*args, **kwargs)
self._tangodb = Database()
self._storeValue = {}
self._recoverValue = {}
def __str__(self):
if self.owner.alias:
name = "%s (Memorised)" % self.owner.alias
else:
name = "%s (Memorised)" % self.owner.name
return name
def __repr__(self):
content = ""
if len(self._recoverValue) > 0:
content = "%s\n\tRecover:" % (content)
for key in self._recoverValue:
content = "%s %s:%s" % (content, key, self._recoverValue[key])
if len(self._storeValue) > 0:
content = "%s \n\tStore:" % (content)
for key in self._storeValue:
content = "%s %s:%s" % (content, key, self._storeValue[key])
return "%s%s" % (self.__str__(), content)
def store(self, value, suffix=None):
if self._owner is None or self._owner.device is None:
self.warning("Cannot memorise values %soutside a "
"tango device server"
% ("for %s " % self._owner.alias
if self._owner.alias is not None else ""))
return False
devName = self._owner.device.get_name()
attrName = self._owner.alias or self._owner.name
fieldName = suffix or defaultFieldName
memorisedName = devName+"/"+attrName
self.info("Memorising attribute %s%s with value %s"
% (attrName, "_%s" % suffix if suffix else "", value))
try:
self._tangodb.put_device_attribute_property(memorisedName,
{attrName:
{fieldName:
str(value)}})
self.info("put_device_attribute_property(%s,{%s:{%s:%s}})"
% (memorisedName, attrName, fieldName, str(value)))
except Exception as e:
self.warning("Property %s_%s cannot be stored due to: %s"
% (attrName, "_%s" % suffix if suffix else "", e))
return False
self._storeValue[fieldName] = value
return True
def recover(self, suffix=None):
"""
Recover the value from the tangoDB
"""
if self._owner is None or self._owner.device is None:
self.warning("Cannot recover memorised values %soutside a "
"tango device server"
% ("for %s " % self._owner.alias
if self._owner.alias is not None else ""))
return False
devName = self._owner.device.get_name()
attrName = self._owner.alias or self._owner.name
fieldName = suffix or defaultFieldName
memorisedName = devName+"/"+attrName
try:
property = self._tangodb.\
get_device_attribute_property(memorisedName, [attrName])
if attrName in property and fieldName in property[attrName]:
try:
value = literal_eval(property[attrName][fieldName][0])
except:
value = property[attrName][fieldName][0]
self.info("Recovered %r as %s" % (value, type(value)))
else:
self.info("Nothing to recover from %s%s"
% (attrName, "_%s" % suffix if suffix else ""))
return False
except Exception as e:
self.warning("Property %s%s couldn't be recovered due to: %s"
% (attrName, "_%s" % suffix if suffix else "", e))
else:
self.info("Recovering memorised value %r for %s%s"
% (value, attrName, "_%s" % suffix if suffix else ""))
if hasattr(self, fieldName):
self._applyValue(attrName, value, fieldName)
else:
self._applyValue(attrName, value)
self._recoverValue[fieldName] = value
return True
def _applyValue(self, attrName, value, field=None, check=True,
silent=False):
if field is None:
for fieldCandidate in ['wvalue', 'rvalue']:
if self._applyValue(attrName, value, field=fieldCandidate,
check=check, silent=True):
self.info("Applied %s to %s[%s]" % (str(value), attrName,
fieldCandidate))
return True
self.error("Unknown field candidate to apply %s to %s"
% (str(value), attrName))
try:
dct = self._owner.__class__.__dict__
if dct[field] is not None:
dct[field].fset(self._owner, value)
if check:
readback = dct[field].fget(self._owner)
if value != readback:
if not silent:
self.warning("readback %s doesn't corresponds "
"with set %s" % (value, readback))
return True
except Exception as e:
if not silent:
self.error("Exception applying %s[%s]: %s -> %s(%s)"
% (attrName, field, value, type(e).__name__, e))
return False
def getStoreValue(self, suffix=None):
if not suffix:
if defaultFieldName in self._storeValue:
return self._storeValue[defaultFieldName]
else:
if suffix in self._storeValue:
return self._storeValue[suffix]
# other case return None
def getRecoverValue(self, suffix=None):
if not suffix:
if defaultFieldName in self._recoverValue:
return self._recoverValue[defaultFieldName]
else:
if suffix in self._recoverValue:
return self._recoverValue[suffix]
from PyTango import Database, DbDevInfo
# A reference on the DataBase
db = Database()
# The devices name we want to create
new_device_name = "PIStageTango/ktof/pi_stage/test/c413test"
# Define the Tango Class served by this DServer
new_device_info_stage = DbDevInfo()
new_device_info_stage._class = "linear Stage"
new_device_info_stage.server = "TangoTest"
# add the device
print("Creating device: %s" % new_device_name)
new_device_info_stage.name = new_device_name
db.add_device(new_device_info_stage)
from PyTango import Database, DbDevInfo
# A reference on the DataBase
db = Database()
new_device_name1 = "C3/unity/eras1"
# Define the Tango Class served by this DServer
new_device_info_mouse = DbDevInfo()
new_device_info_mouse._class = "PyTracker"
new_device_info_mouse.server = "tango_pygame/eras1" #servername/instance
# add the first device
print("Creating device: %s" % new_device_name1)
new_device_info_mouse.name = new_device_name1
db.add_device(new_device_info_mouse)
from PyTango import Database, DbDevInfo
# A reference on the Database
db = Database()
# Define device name
new_device_name = "test/tpm_board/1"
# Define the Tango Class served by this DServer
dev_info = DbDevInfo()
dev_info._class = "TPM_DS"
dev_info.server = "TPM_DS/test"
# add the device
dev_info.name = new_device_name
print("Creating device: %s" % new_device_name)
db.add_device(dev_info)
# SECOND DEVICE
# Define device name
new_device_name = "test/tpm_board/2"
# Define the Tango Class served by this DServer
dev_info = DbDevInfo()
dev_info._class = "TPM_DS"
dev_info.server = "TPM_DS/test"
# add the device
dev_info.name = new_device_name
def prepare_logstash(args):
"""Prepare logstash handler based on the configuration stored in the Tango
database.
:param args: process execution arguments
:type args: list<str>
.. note::
The prepare_logstash function has been included in Sardana
on a provisional basis. Backwards incompatible changes
(up to and including its removal) may occur if
deemed necessary by the core developers.
"""
log_messages = []
try:
from logstash_async.handler import AsynchronousLogstashHandler
except ImportError:
msg = ("Unable to import logstash_async. Skipping logstash " +
"configuration...", )
log_messages.append(msg, )
return log_messages
def get_logstash_conf(dev_name):
try:
props = db.get_device_property(dev_name, "LogstashHost")
host = props["LogstashHost"][0]
except IndexError:
host = None
try:
props = db.get_device_property(dev_name, "LogstashPort")
port = int(props["LogstashPort"][0])
except IndexError:
port = None
try:
props = db.get_device_property(dev_name, "LogstashCacheDbPath")
cache_db_path = props["LogstashCacheDbPath"][0]
except IndexError:
cache_db_path = None
return host, port, cache_db_path
db = Database()
bin_name = args[0]
try:
instance_name = args[1]
except IndexError:
msg = ("Unknown %s instance name. " % bin_name +
"Skipping logstash configuration...")
log_messages.append(msg, )
return log_messages
server_name = bin_name + "/" + instance_name
if bin_name in ["Pool", "MacroServer"]:
class_name = bin_name
dev_name = get_dev_from_class_server(db, class_name, server_name)[0]
host, port, cache = get_logstash_conf(dev_name)
else:
dev_name = get_dev_from_class_server(db, "Pool", server_name)[0]
host, port, cache = get_logstash_conf(dev_name)
if host is None:
dev_name = get_dev_from_class_server(db, "MacroServer",
server_name)[0]
host, port, cache = get_logstash_conf(dev_name)
if host is not None:
root = Logger.getRootLog()
handler = AsynchronousLogstashHandler(host, port, database_path=cache)
# don't use full path for program_name
handler._create_formatter_if_necessary()
_, handler.formatter._program_name = os.path.split(
handler.formatter._program_name)
root.addHandler(handler)
msg = ("Log is being sent to logstash listening on %s:%d", host, port)
log_messages.append(msg)
return log_messages
from PyTango import Database, DbDevInfo
import os, signal
# A reference on the Database
db = Database()
# Kill running servers
# Get device info of Tile
try:
dev_info = db.get_device_info('test/tile/1')
if dev_info.pid != 0:
os.kill(dev_info.pid, signal.SIGTERM) #o r signal.SIGKILL
print "Killed PID: %s" % dev_info.pid
except Exception as ex:
print "No process to kill for test/tile/1"
#get device info of ObsConf
try:
dev_info = db.get_device_info('test/obsconf/1')
if dev_info.pid != 0:
os.kill(dev_info.pid, signal.SIGTERM) #o r signal.SIGKILL
print "Killed PID: %s" % dev_info.pid
except Exception as ex:
print "No process to kill for test/obsconf/1"
#get device info of TPM
try:
dev_info = db.get_device_info('test/tpm_board/1')
if dev_info.pid != 0:
os.kill(dev_info.pid, signal.SIGTERM)
print "Killed PID: %s" % dev_info.pid
class MgConf:
def __init__(self, poolName, mntgrpName, flagClear):
self.db = Database()
#
# the pool for the Mg
#
try:
self.poolMg = DeviceProxy(poolName)
except Exception as e:
Except.print_exception(e)
print("failed to get proxy to ", poolName)
sys.exit(255)
#
# find the MG
#
try:
self.mg = DeviceProxy(mntgrpName)
except Exception:
lst = [mntgrpName, 'exp_t01', 'exp_c01', 'exp_c02']
self.poolMg.command_inout('CreateMeasurementGroup', lst)
self.mg = DeviceProxy(mntgrpName)
if not flagClear:
self.hsh = json.loads(self.mg.Configuration)
self.masterTimer = self.findMasterTimer()
self.index = len(self.mg.ElementList)
else:
self.hsh = {}
self.hsh[u'controllers'] = {}
self.hsh[u'description'] = "Measurement Group"
self.hsh[u'label'] = mntgrpName
self.index = 0
def findMasterTimer(self):
if not HasyUtils.versionSardanaNewMg():
self.findMasterTimerD8()
else:
self.findMasterTimerD9()
def findMasterTimerD8(self):
for ctrl in self.hsh[u'controllers']:
Channels = self.hsh[u'controllers'][ctrl][u'units'][u'0'][
u'channels']
for chan in Channels:
if chan.find('dgg2') > 0:
temp = chan
if temp.find('0000') >= 0:
lst = temp.split("/")
temp = "/".join(lst[1:])
masterTimer = self.db.get_alias(str(temp))
return masterTimer
raise ('MgUtils.findMasterTimer', "No timer found")
def findMasterTimerD9(self):
temp = self.hsh[u'timer']
if temp.find('0000') >= 0:
lst = temp.split("/")
#
# tango://haso113u.desy.de:10000/expchan/dgg2_d1_01/1
#
if lst[0].lower() == 'tango:':
temp = "/".join(lst[3:])
else:
temp = "/".join(lst[1:])
#
# expchan/dgg2_d1_01/1
#
masterTimer = self.db.get_alias(str(temp))
return masterTimer
def findDeviceController(self, device):
"""
returns the controller that belongs to a device
"""
lst = []
if self.poolMg.ExpChannelList is not None:
lst = self.poolMg.ExpChannelList
ctrl = None
for elm in lst:
chan = json.loads(elm)
# chan:
# {
# u'axis': 17,
# u'controller':
# u'haso107klx:10000/controller/sis3820ctrl/sis3820_exp',
# u'full_name': u'haso107klx:10000/expchan/sis3820_exp/17',
# u'id': 146,
# u'instrument': u'',
# u'interfaces': [u'Object', u'PoolObject', u'Element',
# u'ExpChannel', u'PoolElement', u'CTExpChannel', u'Acquirable'],
# u'manager': u'exp_pool01',
# u'name': u'exp_c17',
# u'parent': u'sis3820_exp',
# u'pool': u'exp_pool01',
# u'source': u'haso107klx:10000/expchan/sis3820_exp/17/value',
# u'type': u'CTExpChannel',
# u'unit': u'0',
# }
if device == chan['name']:
ctrl = chan['controller']
break
if ctrl is None and device.find("adc") >= 0:
ctrl = os.getenv("TANGO_HOST") + "/" + \
"controller/hasylabadcctrl/hasyadcctrl"
elif ctrl is None and device.find("vfc") >= 0:
ctrl = os.getenv("TANGO_HOST") + "/" + \
"controller/vfcadccontroller/hasyvfcadcctrl"
return ctrl
def findFullDeviceName(self, device):
"""
input: exp_c01
returns: expchan/hasylabvirtualcounterctrl/1
"""
lst = self.poolMg.AcqChannelList
argout = None
for elm in lst:
chan = json.loads(elm)
if device == chan['name']:
#
# from: expchan/hasysis3820ctrl/1/value
# to: expchan/hasysis3820ctrl/1
#
arr = chan['full_name'].split("/")
argout = "/".join(arr[0:-1])
if argout is None:
print("Error with device")
print(device)
raise Exception('MgUtils.findFullDeviceName, %s' % device,
"failed to find %s" % device)
return argout
def updateConfiguration(self):
"""
json-dump the dictionary self.hsh to the Mg configuration
"""
self.mg.Configuration = json.dumps(self.hsh)
def addTimer(self, device):
if not HasyUtils.versionSardanaNewMg():
self.addTimerD8(device)
else:
self.addTimerD9(device)
def addTimerD8(self, device):
"""
add a timer to the Mg
device: exp_t01
"""
ctrl = self.findDeviceController(device)
if ctrl not in self.hsh[u'controllers'].keys():
self.masterTimer = device
self.hsh[u'monitor'] = self.findFullDeviceName(device)
self.hsh[u'timer'] = self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl] = {}
self.hsh[u'controllers'][ctrl][u'units'] = {}
self.hsh[u'controllers'][ctrl][u'units'][u'0'] = {}
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'channels'] = {}
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'id'] = 0
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'monitor'] = \
self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'timer'] = \
self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'trigger_type'] = 0
ctrlChannels = self.hsh[u'controllers'][ctrl][u'units'][u'0'][
u'channels']
fullDeviceName = self.findFullDeviceName(device)
if fullDeviceName not in ctrlChannels.keys():
print("adding index", self.index, device)
dct = {}
dct[u'_controller_name'] = str(ctrl)
dct[u'_unit_id'] = u'0'
dct[u'conditioning'] = u''
dct[u'data_type'] = u'float64'
dct[u'data_units'] = u'No unit'
dct[u'enabled'] = True
dct[u'full_name'] = fullDeviceName
dct[u'index'] = self.index
self.index += 1
dct[u'instrument'] = None
dct[u'label'] = str(device)
dct[u'name'] = str(device)
dct[u'ndim'] = 0
dct[u'nexus_path'] = u''
dct[u'normalization'] = 0
dct[u'output'] = True
dct[u'plot_axes'] = []
dct[u'plot_type'] = 0
dct[u'shape'] = []
dct[u'source'] = dct['full_name'] + "/value"
ctrlChannels[fullDeviceName] = dct
def addTimerD9(self, device):
"""
add a timer to the Mg
device: exp_t01
"""
ctrl = self.findDeviceController(device)
if ctrl not in self.hsh[u'controllers'].keys():
self.masterTimer = device
self.hsh[u'monitor'] = self.findFullDeviceName(device)
self.hsh[u'timer'] = self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl] = {}
self.hsh[u'controllers'][ctrl][u'synchronizer'] = "software"
self.hsh[u'controllers'][ctrl][u'channels'] = {}
self.hsh[u'controllers'][ctrl][u'id'] = 0
self.hsh[u'controllers'][ctrl][u'monitor'] = \
self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl][u'timer'] = \
self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl][u'trigger_type'] = 0
ctrlChannels = self.hsh[u'controllers'][ctrl][u'channels']
fullDeviceName = self.findFullDeviceName(device)
if fullDeviceName not in ctrlChannels.keys():
print("adding index", self.index, device)
dct = {}
dct[u'conditioning'] = u''
dct[u'enabled'] = True
dct[u'full_name'] = fullDeviceName
dct[u'index'] = self.index
self.index += 1
dct[u'label'] = str(device)
dct[u'name'] = str(device)
dct[u'ndim'] = 0
dct[u'normalization'] = 0
dct[u'output'] = True
dct[u'plot_axes'] = []
dct[u'plot_type'] = 0
dct[u'source'] = dct['full_name'] + "/value"
ctrlChannels[fullDeviceName] = dct
def addExtraTimer(self, device):
if not HasyUtils.versionSardanaNewMg():
self.addExtraTimerD8(device)
else:
self.addExtraTimerD9(device)
#
# add an extra timer to the measurement group
#
def addExtraTimerD8(self, device):
""" device: exp_t01"""
ctrl = self.findDeviceController(device)
if ctrl not in self.hsh[u'controllers'].keys():
self.hsh[u'controllers'][ctrl] = {}
self.hsh[u'controllers'][ctrl][u'units'] = {}
self.hsh[u'controllers'][ctrl][u'units'][u'0'] = {}
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'channels'] = {}
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'id'] = 0
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'monitor'] = \
self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'timer'] = \
self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'trigger_type'] = 0
ctrlChannels = self.hsh[u'controllers'][ctrl][u'units'][u'0'][
u'channels']
fullDeviceName = self.findFullDeviceName(device)
if fullDeviceName not in ctrlChannels.keys():
dct = {}
dct[u'_controller_name'] = str(ctrl)
dct[u'_unit_id'] = u'0'
dct[u'conditioning'] = u''
dct[u'data_type'] = u'float64'
dct[u'data_units'] = u'No unit'
dct[u'enabled'] = True
dct[u'full_name'] = fullDeviceName
dct[u'index'] = self.index
self.index += 1
dct[u'instrument'] = None
dct[u'label'] = str(device)
dct[u'name'] = str(device)
dct[u'ndim'] = 0
dct[u'nexus_path'] = u''
dct[u'normalization'] = 0
dct[u'output'] = True
dct[u'plot_axes'] = []
dct[u'plot_type'] = 0
dct[u'shape'] = []
dct[u'source'] = dct['full_name'] + "/value"
ctrlChannels[fullDeviceName] = dct
#
# add an extra timer to the measurement group
#
def addExtraTimerD9(self, device):
""" device: exp_t01"""
ctrl = self.findDeviceController(device)
if ctrl not in self.hsh[u'controllers'].keys():
self.hsh[u'controllers'][ctrl] = {}
self.hsh[u'controllers'][ctrl][u'synchronizer'] = "software"
self.hsh[u'controllers'][ctrl][u'channels'] = {}
self.hsh[u'controllers'][ctrl][u'id'] = 0
self.hsh[u'controllers'][ctrl][u'monitor'] = \
self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl][u'timer'] = \
self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl][u'trigger_type'] = 0
ctrlChannels = self.hsh[u'controllers'][ctrl][u'channels']
fullDeviceName = self.findFullDeviceName(device)
if fullDeviceName not in ctrlChannels.keys():
dct = {}
dct[u'conditioning'] = u''
dct[u'enabled'] = True
dct[u'full_name'] = fullDeviceName
dct[u'index'] = self.index
self.index += 1
dct[u'label'] = str(device)
dct[u'name'] = str(device)
dct[u'ndim'] = 0
dct[u'normalization'] = 0
dct[u'output'] = True
dct[u'plot_axes'] = []
dct[u'plot_type'] = 0
dct[u'source'] = dct['full_name'] + "/value"
ctrlChannels[fullDeviceName] = dct
def addCounter(self, device, flagDisplay, flagOutput):
if not HasyUtils.versionSardanaNewMg():
self.addCounterD8(device, flagDisplay, flagOutput)
else:
self.addCounterD9(device, flagDisplay, flagOutput)
#
# add a counter to the measurement group
#
def addCounterD8(self, device, flagDisplay, flagOutput):
if device.find('sca_') == 0:
return self.addSCA(device, flagDisplay, flagOutput)
ctrl = self.findDeviceController(device)
if ctrl not in self.hsh[u'controllers'].keys():
print("MgUtils.addCounter adding controller ", ctrl)
self.hsh[u'controllers'][ctrl] = {}
self.hsh[u'controllers'][ctrl][u'units'] = {}
self.hsh[u'controllers'][ctrl][u'units'][u'0'] = {}
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'channels'] = {}
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'id'] = 0
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'monitor'] = \
self.findFullDeviceName(self.masterTimer)
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'timer'] = \
self.findFullDeviceName(self.masterTimer)
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'trigger_type'] = 0
ctrlChannels = self.hsh[u'controllers'][ctrl][u'units'][u'0'][
u'channels']
fullDeviceName = self.findFullDeviceName(device)
if fullDeviceName not in ctrlChannels.keys():
print("adding index", self.index, device)
dct = {}
dct[u'_controller_name'] = str(ctrl)
dct[u'_unit_id'] = u'0'
dct[u'conditioning'] = u''
dct[u'data_type'] = u'float64'
dct[u'data_units'] = u'No unit'
dct[u'enabled'] = True
dct[u'full_name'] = fullDeviceName
dct[u'index'] = self.index
self.index += 1
dct[u'instrument'] = u''
dct[u'label'] = str(device)
dct[u'name'] = str(device)
dct[u'ndim'] = 0
dct[u'nexus_path'] = u''
dct[u'normalization'] = 0
if flagOutput:
dct[u'output'] = True
else:
dct[u'output'] = False
dct[u'plot_axes'] = [u'<mov>']
if flagDisplay:
dct[u'plot_type'] = 1
else:
dct[u'plot_type'] = 0
dct[u'shape'] = []
dct[u'source'] = dct['full_name'] + "/value"
ctrlChannels[fullDeviceName] = dct
#
# add a counter to the measurement group
#
def addCounterD9(self, device, flagDisplay, flagOutput):
if device.find('sca_') == 0:
return self.addSCA(device, flagDisplay, flagOutput)
ctrl = self.findDeviceController(device)
if ctrl not in self.hsh[u'controllers'].keys():
print("MgUtils.addCounter adding controller ", ctrl)
self.hsh[u'controllers'][ctrl] = {}
self.hsh[u'controllers'][ctrl][u'synchronizer'] = "software"
self.hsh[u'controllers'][ctrl][u'channels'] = {}
self.hsh[u'controllers'][ctrl][u'id'] = 0
self.hsh[u'controllers'][ctrl][u'monitor'] = \
self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl][u'timer'] = \
self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl][u'trigger_type'] = 0
ctrlChannels = self.hsh[u'controllers'][ctrl][u'channels']
fullDeviceName = self.findFullDeviceName(device)
if fullDeviceName not in ctrlChannels.keys():
print("adding index", self.index, device)
dct = {}
dct[u'conditioning'] = u''
dct[u'enabled'] = True
dct[u'full_name'] = fullDeviceName
dct[u'index'] = self.index
self.index += 1
dct[u'label'] = str(device)
dct[u'name'] = str(device)
dct[u'ndim'] = 0
dct[u'normalization'] = 0
if flagOutput:
dct[u'output'] = True
else:
dct[u'output'] = False
dct[u'plot_axes'] = [u'<mov>']
if flagDisplay:
dct[u'plot_type'] = 1
else:
dct[u'plot_type'] = 0
dct[u'source'] = dct['full_name'] + "/value"
ctrlChannels[fullDeviceName] = dct
def addMCA(self, device):
if not HasyUtils.versionSardanaNewMg():
self.addMCAD8(device)
else:
self.addMCAD9(device)
#
# add a MCA to the measurement group
#
def addMCAD8(self, device):
ctrl = self.findDeviceController(device)
if ctrl not in self.hsh[u'controllers'].keys():
print("MgUtils.addMCA adding controller ", ctrl)
self.hsh[u'controllers'][ctrl] = {}
self.hsh[u'controllers'][ctrl][u'units'] = {}
self.hsh[u'controllers'][ctrl][u'units'][u'0'] = {}
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'channels'] = {}
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'id'] = 0
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'monitor'] = \
self.findFullDeviceName(self.masterTimer)
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'timer'] = \
self.findFullDeviceName(self.masterTimer)
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'trigger_type'] = 0
ctrlChannels = self.hsh[u'controllers'][ctrl][u'units'][u'0'][
u'channels']
fullDeviceName = self.findFullDeviceName(device)
if fullDeviceName not in ctrlChannels.keys():
print("adding index", self.index, device)
proxy = DeviceProxy(str(fullDeviceName))
dct = {}
dct[u'_controller_name'] = str(ctrl)
dct[u'_unit_id'] = u'0'
dct[u'conditioning'] = u''
dct[u'data_type'] = u'float64'
dct[u'data_units'] = u'No unit'
dct[u'enabled'] = True
dct[u'full_name'] = fullDeviceName
dct[u'index'] = self.index
self.index += 1
dct[u'instrument'] = None
dct[u'label'] = str(device)
dct[u'name'] = str(device)
dct[u'ndim'] = 1
dct[u'nexus_path'] = u''
dct[u'normalization'] = 0
dct[u'output'] = True
dct[u'plot_axes'] = []
dct[u'plot_type'] = 0
dct[u'shape'] = [proxy.DataLength]
dct[u'source'] = fullDeviceName + "/Value"
ctrlChannels[fullDeviceName] = dct
#
# add a MCA to the measurement group
#
def addMCAD9(self, device):
ctrl = self.findDeviceController(device)
if ctrl not in self.hsh[u'controllers'].keys():
print("MgUtils.addMCA adding controller ", ctrl)
self.hsh[u'controllers'][ctrl] = {}
self.hsh[u'controllers'][ctrl][u'synchronizer'] = "software"
self.hsh[u'controllers'][ctrl][u'channels'] = {}
self.hsh[u'controllers'][ctrl][u'id'] = 0
self.hsh[u'controllers'][ctrl][u'monitor'] = \
self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl][u'timer'] = \
self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl][u'trigger_type'] = 0
ctrlChannels = self.hsh[u'controllers'][ctrl][u'channels']
fullDeviceName = self.findFullDeviceName(device)
if fullDeviceName not in ctrlChannels.keys():
print("adding index", self.index, device)
# proxy =
DeviceProxy(str(fullDeviceName))
dct = {}
dct[u'conditioning'] = u''
dct[u'enabled'] = True
dct[u'full_name'] = fullDeviceName
dct[u'index'] = self.index
self.index += 1
dct[u'label'] = str(device)
dct[u'name'] = str(device)
dct[u'ndim'] = 1
dct[u'normalization'] = 0
dct[u'output'] = True
dct[u'plot_axes'] = [u'<mov>']
dct[u'plot_type'] = 0
dct[u'source'] = fullDeviceName + "/Value"
ctrlChannels[fullDeviceName] = dct
def addPilatus(self, device):
if not HasyUtils.versionSardanaNewMg():
self.addPilatusD8(device)
else:
self.addPilatusD9(device)
#
# add a MCA to the measurement group
#
def addPilatusD8(self, device):
ctrl = self.findDeviceController(device)
if ctrl not in self.hsh[u'controllers'].keys():
print("MgUtils.addPilatus adding controller ", ctrl)
self.hsh[u'controllers'][ctrl] = {}
self.hsh[u'controllers'][ctrl][u'units'] = {}
self.hsh[u'controllers'][ctrl][u'units'][u'0'] = {}
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'channels'] = {}
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'id'] = 0
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'monitor'] = \
self.findFullDeviceName(self.masterTimer)
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'timer'] = \
self.findFullDeviceName(self.masterTimer)
self.hsh[u'controllers'][ctrl][u'units'][u'0'][u'trigger_type'] = 0
ctrlChannels = self.hsh[u'controllers'][ctrl][u'units'][u'0'][
u'channels']
fullDeviceName = self.findFullDeviceName(device)
if fullDeviceName not in ctrlChannels.keys():
print("adding index", self.index, device)
# proxy =
DeviceProxy(str(fullDeviceName))
dct = {}
dct[u'_controller_name'] = str(ctrl)
dct[u'_unit_id'] = u'0'
dct[u'conditioning'] = u''
dct[u'enabled'] = True
dct[u'full_name'] = fullDeviceName
dct[u'index'] = self.index
self.index += 1
dct[u'instrument'] = u''
dct[u'label'] = str(device)
dct[u'name'] = str(device)
dct[u'ndim'] = 2
dct[u'nexus_path'] = u''
dct[u'normalization'] = 0
dct[u'output'] = True
dct[u'plot_axes'] = []
dct[u'plot_type'] = 0
dct[u'source'] = fullDeviceName + "/Value"
ctrlChannels[fullDeviceName] = dct
#
# add a Pilatus to the measurement group
#
def addPilatusD9(self, device):
ctrl = self.findDeviceController(device)
if ctrl not in self.hsh[u'controllers'].keys():
print("MgUtils.addPilatus adding controller ", ctrl)
self.hsh[u'controllers'][ctrl] = {}
self.hsh[u'controllers'][ctrl][u'synchronizer'] = "software"
self.hsh[u'controllers'][ctrl][u'channels'] = {}
self.hsh[u'controllers'][ctrl][u'id'] = 0
self.hsh[u'controllers'][ctrl][u'monitor'] = \
self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl][u'timer'] = \
self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl][u'trigger_type'] = 0
ctrlChannels = self.hsh[u'controllers'][ctrl][u'channels']
fullDeviceName = self.findFullDeviceName(device)
if fullDeviceName not in ctrlChannels.keys():
print("adding index", self.index, device)
# proxy =
DeviceProxy(str(fullDeviceName))
dct = {}
dct[u'conditioning'] = u''
dct[u'enabled'] = True
dct[u'full_name'] = fullDeviceName
dct[u'index'] = self.index
self.index += 1
dct[u'label'] = str(device)
dct[u'name'] = str(device)
dct[u'ndim'] = 2
dct[u'normalization'] = 0
dct[u'output'] = True
dct[u'plot_axes'] = [u'<mov>']
dct[u'plot_type'] = 0
dct[u'source'] = fullDeviceName + "/Value"
ctrlChannels[fullDeviceName] = dct
def parseSCA(self, name):
"""
name: sca_exp_mca01_100_200, returns ['exp_mca01', '100', '200']
"""
lst = name.split('_')
return [lst[1] + '_' + lst[2], lst[3], lst[4]]
def _getMcaName(self, mcaSardanaDeviceAlias):
"""
input: sardana device name alias
output: the MCA Tango server name which is used by the Sardana device
"""
try:
proxy = DeviceProxy(mcaSardanaDeviceAlias)
except DevFailed as e:
Except.re_throw_exception(
e, "MgUtils",
"failed to create proxy to %s " % mcaSardanaDeviceAlias,
"MgUtils._gHeMcaName")
return proxy.TangoDevice
def _addSca(self, device):
"""
Input: device: sca_exp_mca01_100_200
Returns full controller name, e.g.:
haso107klx:10000/controller/hasscactrl/sca_exp_mca01_100_200
Creates a HasySca controller and creates a device for this controller,
There is only one device per controller
"""
mca, roiMin, roiMax = self.parseSCA(device)
#
# find the tango device name which is used my the sardana device
#
tgMca = self._getMcaName(mca)
#
# sca_exp_mca01_100_200_ctrl
#
ctrlAlias = device + "_ctrl"
#
# see whether the controller exists already
#
lst = self.poolMg.ControllerList
ctrlFullName = None
for elm in lst:
chan = json.loads(elm)
if ctrlAlias == chan['name']:
ctrlFullName = chan['full_name']
break
#
# if the controller does not exist, create it
#
proxy = DeviceProxy(tgMca)
dataLength = proxy.DataLength
if int(roiMax) >= dataLength:
raise Exception(
"MgUtils._addSca %s " % device,
"roiMax %d >= datalength %d " %
(int(roiMax), int(dataLength)))
if int(roiMin) >= dataLength:
raise Exception(
"MgUtils._addSca %s " % device,
"roiMin %d >= datalength %d " % (int(roiMin), dataLength))
if ctrlFullName is None:
lst = [
'CTExpChannel', 'HasyScaCtrl.py', 'HasyScaCtrl', ctrlAlias,
"mca", tgMca, "roi1", roiMin, "roi2", roiMax
]
print("MgUtils._addSca", lst)
try:
self.poolMg.CreateController(lst)
except DevFailed as e:
Except.print_exception(e)
# print "failed to get proxy to ", poolName
sys.exit(255)
lst = self.poolMg.ControllerList
for elm in lst:
chan = json.loads(elm)
if ctrlAlias == chan['name']:
ctrlFullName = chan['full_name']
break
if ctrlFullName is None:
raise Exception('MgUtils._addSca',
"failed to make controller for %s" % device)
#
# see whether the SCA device exists
#
lst = self.poolMg.ExpChannelList
flag = False
for elm in lst:
chan = json.loads(elm)
if device == chan['name']:
flag = True
break
if not flag:
#
# "CTExpChannel","HasyScaCtrl","1","sca_exp_mca01_100_200"
#
lst = ["CTExpChannel", ctrlAlias, "1", device]
self.poolMg.CreateElement(lst)
return ctrlFullName
def makeScaControllerForPseudoCounter(self, device):
"""
Input: device: sca_exp_mca01_100_200
Returns full controller name, e.g.:
haso107klx:10000/controller/mca2scactrl/sca_exp_mca01_100_200_ctrl
"""
mca, roiMin, roiMax = self.parseSCA(device)
ctrlAlias = device + "_ctrl"
#
# see whether the controller exists already
#
lst = self.poolMg.ControllerList
for elm in lst:
chan = json.loads(elm)
if ctrlAlias == chan['name']:
return chan['full_name']
lst = [
'PseudoCounter', 'MCA2SCACtrl.py', 'MCA2SCACtrl', device + "_ctrl",
'mca=' + self.findFullDeviceName(mca), 'sca=' + device
]
# print "MgUutils.makeSardanaController", lst
self.poolMg.CreateController(lst)
#
# now it has been created.
# go through the list again an return the full controller name
#
lst = self.poolMg.ControllerList
for elm in lst:
chan = json.loads(elm)
if ctrlAlias == chan['name']:
#
# set the ROIs
#
proxy = DeviceProxy(device)
proxy.Roi1 = int(roiMin)
proxy.Roi2 = int(roiMax)
return chan['full_name']
raise Exception('MgUtils.makeController',
"failed to make controller for %s" % device)
def addSCA(self, device, flagDisplay, flagOutput):
if not HasyUtils.versionSardanaNewMg():
self.addSCAD8(device, flagDisplay, flagOutput)
else:
self.addSCAD9(device, flagDisplay, flagOutput)
def addSCAD8(self, device, flagDisplay, flagOutput):
"""
add a SCA to the measurement group
input: device, e.g. sca_exp_mca01_100_200
"""
if device.find('sca_') != 0:
print("MgUtils.addSCA: '%s' does not begin with 'sca_'," % device)
return False
#
# there is one element per controller
#
fullCtrlName = self._addSca(device)
if fullCtrlName not in self.hsh[u'controllers'].keys():
print("MgUtils.addSca adding controller ", fullCtrlName)
self.hsh[u'controllers'][fullCtrlName] = {}
self.hsh[u'controllers'][fullCtrlName][u'units'] = {}
self.hsh[u'controllers'][fullCtrlName][u'units'][u'0'] = {}
self.hsh[u'controllers'][fullCtrlName][u'units'][u'0'][
u'channels'] = {}
self.hsh[u'controllers'][fullCtrlName][u'units'][u'0'][u'id'] = 0
self.hsh[u'controllers'][fullCtrlName][u'units'][u'0'][
u'monitor'] = self.findFullDeviceName(self.masterTimer)
self.hsh[u'controllers'][fullCtrlName][u'units'][u'0'][
u'timer'] = self.findFullDeviceName(self.masterTimer)
self.hsh[u'controllers'][fullCtrlName][u'units'][u'0'][
u'trigger_type'] = 0
ctrlChannels = self.hsh[u'controllers'][fullCtrlName][u'units'][u'0'][
u'channels']
if not self.findFullDeviceName(device) in ctrlChannels.keys():
print("adding index", self.index, device)
dct = {}
dct[u'_controller_name'] = str(fullCtrlName)
dct[u'_unit_id'] = u'0'
dct[u'conditioning'] = u''
dct[u'enabled'] = True
dct[u'full_name'] = self.findFullDeviceName(device)
dct[u'index'] = self.index
self.index += 1
dct[u'instrument'] = None
dct[u'label'] = str(device)
dct[u'name'] = str(device)
dct[u'ndim'] = 0
dct[u'normalization'] = 0
if flagOutput:
dct[u'output'] = True
else:
dct[u'output'] = False
dct[u'plot_axes'] = [u'<mov>']
if flagDisplay:
dct[u'plot_type'] = 1
else:
dct[u'plot_type'] = 0
dct[u'source'] = dct['full_name'] + "/value"
ctrlChannels[self.findFullDeviceName(device)] = dct
return True
def addSCAD9(self, device, flagDisplay, flagOutput):
"""
add a SCA to the measurement group
input: device, e.g. sca_exp_mca01_100_200
"""
if device.find('sca_') != 0:
print("MgUtils.addSCA: '%s' does not begin with 'sca_'," % device)
return False
#
# there is one element per controller
#
fullCtrlName = self._addSca(device)
if fullCtrlName not in self.hsh[u'controllers'].keys():
print("MgUtils.addSca adding controller ", fullCtrlName)
self.hsh[u'controllers'][fullCtrlName] = {}
ctrl = fullCtrlName
self.hsh[u'controllers'][ctrl][u'synchronizer'] = "software"
self.hsh[u'controllers'][ctrl][u'channels'] = {}
self.hsh[u'controllers'][ctrl][u'id'] = 0
self.hsh[u'controllers'][ctrl][u'monitor'] = \
self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl][u'timer'] = \
self.findFullDeviceName(device)
self.hsh[u'controllers'][ctrl][u'trigger_type'] = 0
ctrlChannels = self.hsh[u'controllers'][fullCtrlName][u'channels']
if not self.findFullDeviceName(device) in ctrlChannels.keys():
print("adding index", self.index, device)
dct = {}
dct[u'conditioning'] = u''
dct[u'enabled'] = True
dct[u'full_name'] = self.findFullDeviceName(device)
dct[u'index'] = self.index
self.index += 1
dct[u'label'] = str(device)
dct[u'name'] = str(device)
dct[u'ndim'] = 0
dct[u'normalization'] = 0
if flagOutput:
dct[u'output'] = True
else:
dct[u'output'] = False
dct[u'plot_axes'] = [u'<mov>']
if flagDisplay:
dct[u'plot_type'] = 1
else:
dct[u'plot_type'] = 0
dct[u'source'] = dct['full_name'] + "/value"
ctrlChannels[self.findFullDeviceName(device)] = dct
return True
default=1,
metavar='no_channels')
args = vars(parser.parse_args())
for dev in ['lima', 'xspress3']:
d = None
try:
d = DeviceProxy(args[dev])
except DevFailed:
pass
if d:
print 'Device aleady exist, skipping'
exit()
db = Database()
print 'Creating LimaCCDs device'
lima = DbDevInfo()
lima._class = 'LimaCCDs'
lima.server = 'LimaCCDs/{instance}'.format(instance=args['name'])
lima.name = args['lima']
db.add_device(lima)
print 'Creating Xspress3 device'
x3 = DbDevInfo()
x3._class = 'Xspress3'
x3.server = 'LimaCCDs/{instance}'.format(instance=args['name'])
x3.name = args['xspress3']
db.add_device(x3)
def prepare_logstash(args):
"""Prepare logstash handler based on the configuration stored in the Tango
database.
:param args: process execution arguments
:type args: list<str>
.. note::
The prepare_logstash function has been included in Sardana
on a provisional basis. Backwards incompatible changes
(up to and including its removal) may occur if
deemed necessary by the core developers.
"""
log_messages = []
try:
import logstash
except ImportError:
msg = ("Unable to import logstash. Skipping logstash " +
"configuration...", )
log_messages.append(msg, )
return log_messages
def get_logstash_conf(dev_name):
try:
props = db.get_device_property(dev_name, "LogstashHost")
host = props["LogstashHost"][0]
except IndexError:
host = None
try:
props = db.get_device_property(dev_name, "LogstashPort")
port = int(props["LogstashPort"][0])
except IndexError:
port = 12345
return host, port
db = Database()
bin_name = args[0]
instance_name = args[1]
server_name = bin_name + "/" + instance_name
if bin_name in ["Pool", "MacroServer"]:
class_name = bin_name
dev_name = get_dev_from_class_server(db, class_name, server_name)[0]
host, port = get_logstash_conf(dev_name)
else:
dev_name = get_dev_from_class_server(db, "Pool", server_name)[0]
host, port = get_logstash_conf(dev_name)
if host is None:
dev_name = get_dev_from_class_server(db, "MacroServer",
server_name)[0]
host, port = get_logstash_conf(dev_name)
if host is not None:
root = Logger.getRootLog()
handler = logstash.TCPLogstashHandler(host, port, version=1)
root.addHandler(handler)
msg = ("Log is being sent to logstash listening on %s:%d", host, port)
log_messages.append(msg)
return log_messages
def __init__(self, connector=None, uri=None):
Camera.__init__(self)
self.uri = uri
attributes = [ \
{"attr": "ExposureAuto", "name": "exposure_time_auto"},
{"attr": "ExposureAutoMin", "name": "exposure_time_min"},
{"attr": "ExposureAutoMax", "name": "exposure_time_max"},
{"attr": "ExposureTimeAbs", "name": "exposure_time"},
{"attr": "GainAuto", "name": "gain_auto"},
{"attr": "GainAutoMin", "name": "gain_min"},
{"attr": "GainAutoMax", "name": "gain_max"},
{"attr": "Gain", "name": "gain"},
{"attr": "TriggerSource", "name": "trigger_source"},
{"attr": "AcquisitionFrameRateAbs", "name": "frame_rate"},
{"attr": "Width"},
{"attr": "Height"},
{"attr": "OffsetX", "name": "offset_x"},
{"attr": "OffsetY", "name": "offset_y"},
{"attr": "WidthMax", "name": "width_max"},
{"attr": "HeightMax", "name": "height_max"},
{"attr": "Image8", "name": "image_8"},
]
if connector == "simulation":
attributes.append({"attr": "Image8", "name": "image_8"})
self.connector = VimbaCameraSimulationConnector(uri, attributes)
self.connector.write("width", 640)
self.connector.write("height", 480)
self.connector.write("width_max", 640)
self.connector.write("height_max", 480)
self.connector.image_changed.connect(self.on_image_changed)
elif connector == "tango":
#determine gain attribute name
if -1 < uri.find(":") < uri.find("/"):
host, port = uri.partition("/")[0].split(":")
db = Database(host, port)
gain_prop = db.get_device_property(
uri.partition("/")[2], "GainFeatureName")
else:
db = Database()
gain_prop = db.get_device_property(uri, "GainFeatureName")
if len(gain_prop["GainFeatureName"]) > 0:
gain_attr = gain_prop["GainFeatureName"][0]
for attr in attributes:
if "name" in attr and attr["name"] == "gain":
attr["attr"] = gain_attr
#setup connector
self.connector = TangoConnector(uri, attributes)
#start acquisition in right viewing mode and connect changed signal
try:
self.connector.proxy.write_attribute("ViewingMode", 1)
if self.state(refresh=True) != State.RUNNING:
self.connector.proxy.command_inout("StartAcquisition")
sleep(0.2)
self.connector.proxy.subscribe_event("image_8", \
EventType.DATA_READY_EVENT, \
self.on_image_changed, [], False)
except:
self.janus.utils["logger"].error(
"VimbaCamera(" + self.uri + ").__init__() " +
"failed to set viewing mode")
self.janus.utils["logger"].debug("", exc_info=True)
self.connector.write("trigger_source", "FixedRate")
self.connector.write("frame_rate", 10.)
self.connector.value_changed.connect(self.value_changed.emit)
self.buffer = None
"""Created Receiving device server class"""
class Receiving(Device):
__metaclass__ = DeviceMeta
def init_device(self):
Device.init_device(self)
self.set_state(DevState.STANDBY)
self.debug_stream("Init Receiving Device.")
@command(dtype_in='DevVarStringArray', dtype_out=None)
def log(self, details):
message = details[3]
# print(message)
self.debug_stream(message)
"""This part is needed to start device server from command line"""
if '--register' in sys.argv:
reg_ind = sys.argv.index('--register')
sys.argv.pop(reg_ind)
name = sys.argv.pop(reg_ind)
db = Database()
dev_info = DbDevInfo()
dev_info._class = 'Receiving'
dev_info.server = 'ReceivingDS/logdev'
dev_info.name = name
db.add_device(dev_info)
print("In registration")
else:
print("Running DS")
run([Receiving])
}
},
'loggers': {
'aavs.ctl': {
'handlers': ['console'],
'level': 'DEBUG',
},
'aavs.none': {
'handlers': [],
'level': 'DEBUG',
}
}
}
logging.config.dictConfig(LOGGING)
db = Database()
def setup_tango_config(loaded_config):
""" Set up tango configuration """
devices = loaded_config["devices"]
domain = loaded_config["domain"]
default_logging_target = loaded_config["default_logging_target"]
default_logging_level = loaded_config["default_logging_level"]
for group_name, instances in devices.iteritems():
for device_id, config in instances.iteritems():
device_class = config["class"]
full_device_name = "/".join([domain, group_name, device_id])
device_server_name = config.get("server", None)
def prepare_server(args, tango_args):
"""Register a proper server if the user gave an unknown server"""
log_messages = []
_, bin_name = os.path.split(args[0])
server_name, _ = os.path.splitext(bin_name)
if "-?" in tango_args:
return log_messages
nodb = "-nodb" in tango_args
if nodb and not hasattr(DeviceClass, "device_name_factory"):
print "In order to start %s with 'nodb' you need PyTango >= 7.2.3" % server_name
sys.exit(1)
if len(tango_args) < 2:
valid = False
while not valid:
inst_name = raw_input("Please indicate %s instance name: " %
server_name)
# should be a instance name validator.
valid_set = string.letters + string.digits + '_' + '-'
out = ''.join([c for c in inst_name if c not in valid_set])
valid = len(inst_name) > 0 and len(out) == 0
if not valid:
print "We only accept alphanumeric combinations"
args.append(inst_name)
tango_args.append(inst_name)
else:
inst_name = tango_args[1].lower()
if "-nodb" in tango_args:
return log_messages
db = Database()
if not exists_server_instance(db, server_name, inst_name):
if ask_yes_no('%s does not exist. Do you wish to create a new '
'one' % inst_name,
default='y'):
if server_name == 'MacroServer':
# build list of pools to which the MacroServer should connect
# to
pool_names = []
pools = get_dev_from_class(db, "Pool")
all_pools = pools.keys()
for pool in pools.values():
pool_alias = pool[2]
if pool_alias is not None:
all_pools.append(pool_alias)
all_pools = map(str.lower, all_pools)
pools_for_choosing = []
for i in pools:
pools_for_choosing.append(pools[i][3])
pools_for_choosing = sorted(pools_for_choosing,
key=lambda s: s.lower())
no_pool_msg = ("\nMacroServer %s has not been connected to "
"any Pool\n" % inst_name)
if len(pools_for_choosing) == 0:
print(no_pool_msg)
else:
print("\nAvailable Pools:")
for pool in pools_for_choosing:
print pool
print("")
while True:
msg = "Please select the Pool to connect to " \
"(return to finish): "
# user may abort it with Ctrl+C - this will not
# register anything in the database and the
# KeyboardInterrupt will be raised
elem = raw_input(msg).strip()
# no pools selected and user ended loop
if len(elem) == 0 and len(pool_names) == 0:
print(no_pool_msg)
break
# user ended loop with some pools selected
elif len(elem) == 0:
print(
"\nMacroServer %s has been connected to "
"Pool/s %s\n" % (inst_name, pool_names))
break
# user entered unknown pool
elif elem.lower() not in all_pools:
print "Unknown pool element"
else:
pool_names.append(elem)
log_messages += register_sardana(db, server_name, inst_name,
pool_names)
else:
log_messages += register_sardana(db, server_name, inst_name)
else:
raise AbortException("%s startup aborted" % server_name)
return log_messages
def register_horizontal_motor():
register("tomo/horizontal_motor/1", "HorizontalMotor", "HorizontalMotor/horizontal_motor")
def register_detector():
register("tomo/detector/1", "Detector", "Detector/detector")
def register_shutter():
register("tomo/shutter/1", "XRayShutter", "XRayShutter/shutter")
def register_source():
register("tomo/source/1", "XRaySource", "XRaySource/source")
def register_tomograph():
register("tomo/tomograph/1", "Tomograph", "Tomograph/tomograph")
db = Database()
# register_motor()
register_angle_motor()
register_horizontal_motor()
register_detector()
register_shutter()
register_source()
register_tomograph()
def prepare_server(args, tango_args):
"""Register a proper server if the user gave an unknown server"""
log_messages = []
_, bin_name = os.path.split(args[0])
server_name, _ = os.path.splitext(bin_name)
if "-?" in tango_args:
return log_messages
nodb = "-nodb" in tango_args
if nodb and not hasattr(DeviceClass, "device_name_factory"):
print "In order to start %s with 'nodb' you need PyTango >= 7.2.3" % server_name
sys.exit(1)
if len(tango_args) < 2:
valid = False
while not valid:
inst_name = raw_input("Please indicate %s instance name: " %
server_name)
# should be a instance name validator.
valid_set = string.letters + string.digits + '_' + '-'
out = ''.join([c for c in inst_name if c not in valid_set])
valid = len(inst_name) > 0 and len(out) == 0
if not valid:
print "We only accept alphanumeric combinations"
args.append(inst_name)
tango_args.append(inst_name)
else:
inst_name = tango_args[1].lower()
if "-nodb" in tango_args:
return log_messages
db = Database()
if not exists_server_instance(db, server_name, inst_name):
if ask_yes_no('%s does not exist. Do you wish create a new one' %
inst_name,
default='y'):
if server_name == 'MacroServer':
# build list of pools to which the MacroServer should connect
# to
pool_names = []
pools = get_dev_from_class(db, "Pool")
all_pools = pools.keys()
for pool in pools.values():
pool_alias = pool[2]
if pool_alias is not None:
all_pools.append(pool_alias)
all_pools = map(str.lower, all_pools)
for i in pools:
print pools[i][3]
while True:
elem = raw_input(
"Please select pool to connect to (return to finish): "
).strip()
if not len(elem):
break
if elem.lower() not in all_pools:
print "Unknown pool element"
print all_pools
else:
pool_names.append(elem)
log_messages += register_sardana(db, server_name, inst_name,
pool_names)
else:
log_messages += register_sardana(db, server_name, inst_name)
return log_messages
from PyTango import Database, DbDevInfo
# A reference on the DataBase
db = Database()
new_device_name1 = "test/powersupply/1"
# Define the Tango Class served by this DServer
new_device_info_mouse = DbDevInfo()
new_device_info_mouse._class = "PowerSupply"
new_device_info_mouse.server = "PowerSupplyDS/test" #servername/instance
# add the first device
print("Creating device: %s" % new_device_name1)
new_device_info_mouse.name = new_device_name1
db.add_device(new_device_info_mouse)
