def reader_hook(self, attribute, values):
"""This method will be executed by the ReaderProcess to process the queried data."""
try:
print('>' * 80)
print(time.ctime() + ' In reader_hook(%s,[%d])' %
(attribute, len(values)))
MAXDIM = 1024 * 1024 * 1024
#First create the attributes
epoch, data, aname = [], [], attribute.replace('/', '__')
values = decimate_values(values)
[(epoch.append(v[0]), data.append(v[1])) for v in values]
writable = PyTango.AttrWriteType.READ
#Adding time attribute
m, atformat, dims = None, PyTango.SpectrumAttr, [MAXDIM]
for d in data:
if d is not None:
if fn.isSequence(d):
atformat, dims = PyTango.ImageAttr, [MAXDIM, MAXDIM]
m = d[0]
else:
m = d
break
attype = PyTango.DevDouble if (
fn.isNumber(m) or fn.isBool(m)) else PyTango.DevString
self.add_attribute(
PyTango.ImageAttr(aname, attype, writable, MAXDIM, MAXDIM),
self.read_dyn_attr, None, self.is_dyn_attr_allowed)
self.add_attribute(
PyTango.SpectrumAttr(aname + '_t', PyTango.DevDouble, writable,
MAXDIM), self.read_dyn_attr, None,
self.is_dyn_attr_allowed)
self.add_attribute(
PyTango.SpectrumAttr(aname + '_d', PyTango.DevString, writable,
MAXDIM), self.read_dyn_attr, None,
self.is_dyn_attr_allowed)
self.add_attribute(atformat(aname + '_r', attype, writable,
*dims), self.read_dyn_attr, None,
self.is_dyn_attr_allowed)
#Then add the data to Cache values, so IsDataReady will return True
t = fn.now()
self.RemoveCachedAttribute(attribute)
self.AttrData[attribute] = (t, atformat, attype, values)
print('Done: %s,%s,%s,%s,%d' %
(attribute, t, atformat, attype, len(values)))
except:
print(traceback.format_exc())
def dyn_attr(self):
for process in self.ProcessList:
#self.debug_stream('dyn_attr(): Adding attributes for %s process'%process)
aname = re.sub('[^0-9a-zA-Z]+', '_', process)
for suffix,data_type,data_format,unit in\
(('nprocesses',PyTango.DevLong,PyTango.SCALAR,None),
('nthreads',PyTango.DevLong,PyTango.SCALAR,None),
('pids',PyTango.DevLong,PyTango.SPECTRUM,None),
('cpu',PyTango.DevDouble,PyTango.SCALAR,'%'),
('mem',PyTango.DevDouble,PyTango.SCALAR,'MB'),
('vmem',PyTango.DevDouble,PyTango.SCALAR,'MB'),
('memRatio',PyTango.DevDouble,PyTango.SCALAR,'%'),
('kbpm',PyTango.DevDouble,PyTango.SCALAR,'%'),
):
#TODO: set the units
if data_format == PyTango.SCALAR:
self.add_attribute(
PyTango.Attr(aname + '_' + suffix, data_type,
PyTango.AttrWriteType.READ),
self.read_dyn_attr, None,
(lambda s, req_type, attr_name=aname + '_' + suffix:
True))
if self.UseEvents:
self.set_change_event(aname + '_' + suffix, True,
False)
elif data_format == PyTango.SPECTRUM:
self.add_attribute(
PyTango.SpectrumAttr(aname + '_' + suffix, data_type,
PyTango.READ, 1000),
self.read_dyn_attr, None,
(lambda s, req_type, attr_name=aname + '_' + suffix:
True))
if self.UseEvents:
self.set_change_event(aname + '_' + suffix, True,
False)
#self._dyn_attr_build = True
self.change_state(PyTango.DevState.ON)
return
def initialize_dynamic_attributes(self):
self.debug_stream('In initialize_dynamic_attributes()')
if self.pv is not None: # already initialized
return
# variables initialization
READ_METHOD = self.read_attr
WRITE_METHOD = self.write_attr
if self.Host == []:
self.Host = ''
self.pv = {}
pvs = {}
try:
# initialize libca library
epics.ca.initialize_libca()
# get pv names and build libca channels
for pv_entry in self.ProcessVariables:
pv_attr = pv_entry.split('\t')
attr_name = None
if len(pv_attr) == 1:
pv_name = pv_attr[0]
elif len(pv_attr) == 2:
pv_name, attr_name = pv_attr
else:
msg = 'Invalid entry in ProcessVariables device property:'\
' %s' % pv_entry
self.error_stream(msg)
self._set_state(PyTango.DevState.FAULT, msg)
return
# get host name if necessary
if self.Host != '':
pv_full_name = '%s:%s' % (self.Host, pv_name)
else:
pv_full_name = pv_name
# create epics channel to PV (to increase performance do not
# wait for a connection)
ch_id = epics.ca.create_channel(
pv_full_name,
connect=False,
auto_cb=False)
# build default attribute name (if not provided)
if attr_name is None:
attr_name = self.epics2tango_name(pv_name)
self.pv[attr_name] = [ch_id, pv_full_name]
pvs[attr_name] = [ch_id]
# connect PVs and get necessary info
for name, data in pvs.items():
connected = epics.ca.connect_channel(data[0])
if not connected:
msg = 'At least one channel unreachable. Is hardware up?'
self.error_stream(msg)
self._set_state(PyTango.DevState.FAULT,
msg, force_init=True)
return
epics.ca.poll() # wait for connections completion
for name, data in pvs.items():
data.append(epics.ca.field_type(data[0]))
data.append(epics.ca.read_access(data[0]))
data.append(epics.ca.write_access(data[0]))
data.append(epics.ca.element_count(data[0]))
# add dynamic attributes
for attr_name, data in pvs.items():
# find out tango type
tango_type = self.epics2tango_type(data[1])
if tango_type is None:
msg = 'Unknown type %s for PV %s' %\
(str(data[1]), self.pv[attr_name][1])
self.error_stream(msg)
self._set_state(PyTango.DevState.ALARM, msg)
del self.pv[attr_name]
continue
# find out read/write access
read_access = bool(data[2])
write_access = bool(data[3])
read_method = None
write_method = None
if read_access and write_access:
read_method = READ_METHOD
write_method = WRITE_METHOD
access_type = PyTango.AttrWriteType.READ_WRITE
elif read_access and not write_access:
read_method = READ_METHOD
access_type = PyTango.AttrWriteType.READ
elif not read_access and write_access:
write_method = WRITE_METHOD
access_type = PyTango.AttrWriteType.WRITE
else:
msg = 'PV %s has neither read nor write permissions'\
% pv_full_name
self.error_stream(msg)
self._set_state(PyTango.DevState.FAULT, msg)
continue
# find out dimension and build attribute
dimension = data[4]
if dimension > 1:
attr = PyTango.SpectrumAttr(
attr_name,
tango_type,
access_type,
dimension)
else:
attr = PyTango.Attr(
attr_name,
tango_type,
access_type)
properties = PyTango.UserDefaultAttrProp()
# set description field with PV name
properties.set_description(self.pv[attr_name][1])
attr.set_default_properties(properties)
# add attribute
self.add_attribute(attr, read_method, write_method)
except Exception as e:
msg = 'Unable to create dynamic attributes'
self.error_stream('%s: %s' % (msg, str(e)))
self._set_state(PyTango.DevState.FAULT, msg)
del pvs # no longer used
def __getAttrObj(self,
attrName,
definition,
channel=None,
function=None,
multiple=None):
# TODO: image dimensions
if self.__device is not None:
if definition['dim'] == [0]:
if 'writeCmd' in definition:
attr = PyTango.Attr(attrName, definition['type'],
PyTango.READ_WRITE)
readmethod = AttrExc(getattr(self.__device, 'read_attr'))
writemethod = AttrExc(getattr(self.__device, 'write_attr'))
else:
attr = PyTango.Attr(attrName, definition['type'],
PyTango.READ)
readmethod = AttrExc(getattr(self.__device, 'read_attr'))
writemethod = None
elif definition['dim'][0] == 1:
if 'writeCmd' in definition:
attr = PyTango.SpectrumAttr(attrName, definition['type'],
PyTango.READ_WRITE,
definition['dim'][1])
readmethod = AttrExc(getattr(self.__device, 'read_attr'))
writemethod = AttrExc(getattr(self.__device, 'write_attr'))
else:
attr = PyTango.SpectrumAttr(attrName, definition['type'],
PyTango.READ,
definition['dim'][1])
readmethod = AttrExc(getattr(self.__device, 'read_attr'))
writemethod = None
else:
raise AttributeError("Not supported multiple dimensions")
# attribute properties
aprop = PyTango.UserDefaultAttrProp()
if 'unit' in definition:
aprop.set_unit(latin1(definition['unit']))
if 'min' in definition:
aprop.set_min_value(str(definition['min']))
if 'max' in definition:
aprop.set_max_value(str(definition['max']))
if 'format' in definition:
format = latin1(definition['format'])
if format.count("%") == 2:
format = format.replace('%', '', 1)
aprop.set_format(format)
if 'description' in definition:
aprop.set_description(latin1(definition['description']))
if 'label' in definition:
aprop.set_label(latin1(definition['label']))
if 'memorized' in definition:
attr.set_memorized()
attr.set_memorized_init(True)
attr.set_default_properties(aprop)
self.__device.add_attribute(attr,
r_meth=readmethod,
w_meth=writemethod)
multiattr = self.__device.get_device_attr()
attrId = multiattr.get_attr_ind_by_name(attrName)
self._attributeIds[attrId] = attrName
else:
attrId = self._generateAttrId(attrName)
attr = None
aprop = None
# self.debug_stream("Attribute %s has the id %s" % (attrName, attrId))
self._attributeList.append(attrName)
# prepare internal structure ---
if channel is not None or function is not None or multiple is not None:
if channel is not None:
like = "channel"
number = channel
elif function is not None:
like = "function"
number = function
elif multiple is not None and \
'scpiPrefix' in definition['multiple'] and\
'attrSuffix' in definition['multiple']:
like = definition['multiple']['scpiPrefix']
number = multiple
else:
raise AttributeError("Wrong definition of multiple attribute")
self.__prepareChannelLikeAttr(like, number, definition, attrName)
else:
readCmd = definition['readCmd']
if 'writeCmd' not in definition:
# writeCmd = definition['writeCmd']
definition['writeCmd'] = None
if 'readFormula' not in definition:
# readFormula = definition['readFormula']
definition['readFormula'] = None
# if 'writeFormula' not in definition:
# # writeFormula = definition['writeFormula']
# writeFormula = None
# build internal structure ---
if 'rampeable' in definition and definition['rampeable'] is True:
self.__buildRWObj(attrName, attrId, definition, readmethod,
writemethod)
if 'delayAfterWrite' not in definition:
definition['delayAfterWrite'] = 0.0
if definition['writeCmd'] is None:
self.__buildROObj(attrName, attrId, definition)
else:
self.__buildRWObj(attrName, attrId, definition)
if 'writeValues' in definition:
self.__prepareWriteValues(attrName, definition, aprop, attr)
return attr
def __getAttrObj(self,
attrName,
definition,
channel=None,
function=None,
multiple=None):
# TODO: image dimensions
if definition['dim'] == [0]:
if 'writeCmd' in definition:
attr = PyTango.Attr(attrName, definition['type'],
PyTango.READ_WRITE)
readmethod = AttrExc(getattr(self.__device, 'read_attr'))
writemethod = AttrExc(getattr(self.__device, 'write_attr'))
else:
attr = PyTango.Attr(attrName, definition['type'], PyTango.READ)
readmethod = AttrExc(getattr(self.__device, 'read_attr'))
writemethod = None
elif definition['dim'][0] == 1:
if 'writeCmd' in definition:
attr = PyTango.SpectrumAttr(attrName, definition['type'],
PyTango.READ_WRITE,
definition['dim'][1])
readmethod = AttrExc(getattr(self.__device, 'read_attr'))
writemethod = AttrExc(getattr(self.__device, 'write_attr'))
else:
attr = PyTango.SpectrumAttr(attrName, definition['type'],
PyTango.READ, definition['dim'][1])
readmethod = AttrExc(getattr(self.__device, 'read_attr'))
writemethod = None
else:
raise AttributeError("Not supported multiple dimensions")
# attribute properties
aprop = PyTango.UserDefaultAttrProp()
if 'unit' in definition:
aprop.set_unit(latin1(definition['unit']))
if 'min' in definition:
aprop.set_min_value(str(definition['min']))
if 'max' in definition:
aprop.set_max_value(str(definition['max']))
if 'format' in definition:
aprop.set_format(latin1(definition['format']))
if 'description' in definition:
aprop.set_description(latin1(definition['description']))
if 'label' in definition:
aprop.set_label(latin1(definition['label']))
if 'memorized' in definition:
attr.set_memorized()
attr.set_memorized_init(True)
attr.set_default_properties(aprop)
self.__device.add_attribute(attr,
r_meth=readmethod,
w_meth=writemethod)
self._attributeList.append(attrName)
# prepare internal structure ---
if channel or function or multiple:
if channel:
like = "channel"
elif function:
like = "function"
elif multiple and 'scpiPrefix' in definition['multiple'] and\
'attrSuffix' in definition['multiple']:
like = definition['multiple']['scpiPrefix']
else:
raise AttributeError("Wrong definition of multiple attribute")
number = channel or function or multiple
self.__prepareChannelLikeAttr(like, number, definition)
else:
readCmd = definition['readCmd']
if 'writeCmd' not in definition:
# writeCmd = definition['writeCmd']
definition['writeCmd'] = None
if 'readFormula' not in definition:
# readFormula = definition['readFormula']
definition['readFormula'] = None
# if 'writeFormula' not in definition:
# # writeFormula = definition['writeFormula']
# writeFormula = None
# build internal structure ---
if definition['writeCmd'] is None:
self.__buildROObj(attrName, definition)
else:
self.__buildRWObj(attrName, definition, readmethod, writemethod)
if 'writeValues' in definition:
self.__prepareWriteValues(attrName, definition, aprop, attr)
return attr
