def test_alarm_propagation(self):
device_name = '%s/sub1/1' % self.DOMAIN_NAME
members_template = ['%s/capability/sub1cap1', '%s/capability/sub1cap2']
members = [member % self.DOMAIN_NAME for member in members_template]
self.add_members(device_name, 'tiles', members)
dp = DeviceProxy(device_name)
self.assertNotEqual(dp.state(), AttrQuality.ATTR_ALARM)
member_dp = DeviceProxy(members[0])
alarm_data = json.dumps({
'name': 'an_attr',
'min_alarm': '20',
'max_alarm': '50'
})
member_dp.command_inout('set_attribute_alarm', alarm_data)
member_dp.an_attr = 10
attr = AttributeProxy(members[0] + '/an_attr')
self.assertEqual(attr.read().quality, AttrQuality.ATTR_ALARM)
self.assertEqual(member_dp.state(), PyTango._PyTango.DevState.ALARM)
i = 0
while (dp.state() != PyTango._PyTango.DevState.ALARM) and i < 3:
sleep(1)
i += 1
self.assertEqual(dp.state(), PyTango._PyTango.DevState.ALARM)
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 init(self):
self.moving = None
self.deviceOk = True
self.prev_state = None
self.doBacklashCompensation = False
# Channel and commands for monochormator pitch.
# it will be used here to make sure it is on before moving energy (PX2)
# not needed on PX1
self.mono_mt_rx_statech = None
self.mono_mt_rx_oncmd = None
# Connect to device BLEnergy defined "tangoname" in the xml file
try:
self.BLEnergydevice = DeviceProxy(self.getProperty("tangoname"))
except:
self.errorDeviceInstance(self.getProperty("tangoname"))
# Connect to device mono defined "tangoname2" in the xml file
# used for conversion in wavelength
try:
self.monodevice = DeviceProxy(self.getProperty("tangoname2"))
except:
self.errorDeviceInstance(self.getProperty("tangoname2"))
# Nom du device bivu (Energy to gap) : necessaire pour amelioration du positionnement de l'onduleur (Backlash)
try:
# self.U20Energydevice = DeviceProxy(self.getProperty("tangoname3"), movingState="RUNNING")
# Modif suite a changement par ICA de l etat du device U20 RUNNING devient MOVING
self.U20Energydevice = DeviceProxy(self.getProperty("tangoname3"))
except:
self.errorDeviceInstance(self.getProperty("tangoname3"))
self.doBacklashCompensation = self.getProperty("backlash")
# print self.doBacklashCompensation
try:
self.mono_mt_rx_statech = self.getChannelObject("mono_mt_rx_state")
self.mono_mt_rx_oncmd = self.getCommandObject("mono_mt_rx_on")
except KeyError:
logging.info(
"Beware that mt_rx control is not properly defined for BLEnergy"
)
# parameters for polling
if self.deviceOk:
self.isConnected()
self.prev_state = str(self.BLEnergydevice.State())
energyChan = self.getChannelObject("energy")
energyChan.connectSignal("update", self.energyChanged)
stateChan = self.getChannelObject(
"state"
) # utile seulement si statechan n'est pas defini dans le code
stateChan.connectSignal("update", self.stateChanged)
def main():
# Find out what we're supposed to be doing...
config = parse_args(sys.argv[1:])
# ...and set up the reduced set of parameters we're interested in.
make_reduced_attribs()
# Construct all the names of the motors we're interested in
dev_names = generate_device_names(config['server'], config['dev_ids'])
all_motors = set(itertools.chain.from_iterable(dev_names.values()))
if config['write_params']:
input_motor_params = read_dat(config['input_file'])
# We check that all of the motors we are interested in have an entry in our input file
motors_with_params = set(input_motor_params.keys())
motors_to_update = list(all_motors & motors_with_params)
# The input file should contain only motors which are on the given
# server or, the input file should contain parameters for all motors
# when device IDs have been specified.
if set(motors_with_params).issubset(all_motors) or (bool(config['dev_ids']) and all_motors.issubset(motors_with_params)):
for motor in sorted(motors_to_update):
oms_dp = DeviceProxy('{}/{}/motor/{}'.format(config['tango_host'], config['beamline'], motor))
zmx_dp = DeviceProxy('{}/{}/ZMX/{}'.format(config['tango_host'], config['beamline'], motor))
print('Writing config to motor {}'.format(motor))
write_parameters(oms_dp, zmx_dp, input_motor_params[motor])
print('{}: DONE'.format(motor))
print('\nSuccessfully updated configuration for motors:\n{}'.format(', '.join(sorted(motors_to_update))))
else:
print('ERROR: Configuration for one or more of the requested motors is not in the input file.\nAborting...')
sys.exit(1)
elif config['compare_params']: # FIXME: this part of function not tested!
input_all_motor_params = read_dat(config['input_file'])
current_all_motor_params = read_motors(config, dev_names)
# As per the write, we check that all of the motors we are interested in have an entry in our input file
motors_with_params = set(input_all_motor_params.keys())
motors_to_update = list(all_motors & motors_with_params)
if set(motors_with_params).issubset(all_motors) or (bool(config['dev_ids']) and all_motors.issubset(motors_with_params)):
for motor in sorted(motors_to_update):
motors_equal = True
input_this_motor_params = input_all_motor_params[motor]
current_this_motor_params = current_all_motor_params[motor]
for recorded_param in input_this_motor_params.keys():
curr_param_equal = (input_this_motor_params[recorded_param] == current_this_motor_params[recorded_param])
motors_equal = motors_equal and curr_param_equal
if not curr_param_equal:
print('{} parameter for motor {} differ! (Input: {} Current: {})'.format(recorded_param, motor, input_this_motor_params[recorded_param], current_this_motor_params[recorded_param]))
if motors_equal:
print('{}: Input and current params are same\n'.format(motor))
else:
print('{}: Input and current params are DIFFERENT\n'.format(motor))
else:
all_motor_params = read_motors(config, dev_names)
write_dat(all_motor_params)
def create_meas(self, config):
""" Create a meas with the given configuration
"""
# creating mg
config = copy.deepcopy(config)
self.expchan_names = []
self.tg_names = []
ordered_chns = [None] * 10
for ctrl_name, ctrl_config in config.items():
channels = ctrl_config["channels"]
for chn, chn_config in channels.items():
index = chn_config["index"]
ordered_chns[index] = chn
self.expchan_names = [chn for chn in ordered_chns if chn is not None]
self.pool.CreateMeasurementGroup([self.mg_name] + self.expchan_names)
for ctrl_name in config.keys():
ctrl_config = config.pop(ctrl_name)
channels = ctrl_config["channels"]
for chn_name in channels.keys():
chn_config = channels.pop(chn_name)
chn_full_name = _get_full_name(DeviceProxy(chn_name))
channels[chn_full_name] = chn_config
ctrl_full_name = _get_full_name(DeviceProxy(ctrl_name))
synchronizer = ctrl_config.get("synchronizer")
if synchronizer is not None and synchronizer != "software":
self.tg_names.append(synchronizer)
synchronizer = _get_full_name(DeviceProxy(synchronizer))
ctrl_config["synchronizer"] = synchronizer
config[ctrl_full_name] = ctrl_config
try:
self.meas = PyTango.DeviceProxy(self.mg_name)
except:
raise Exception('Could not create the MeasurementGroup: %s' %
(self.mg_name))
# When measurement group gets created it fills the configuration with
# the default values. Reusing read configuration in order to set test
# parameters.
jcfg = self.meas.read_attribute('configuration').value
cfg = json.loads(jcfg)
for ctrl in cfg['controllers']:
ctrl_config = cfg['controllers'][ctrl]
ctrl_test_config = config[ctrl]
channels = ctrl_config['channels']
channels_test = ctrl_test_config.pop("channels")
for chn, chn_config in channels.items():
chn_test_config = channels_test[chn]
chn_config.update(chn_test_config)
ctrl_config.update(ctrl_test_config)
# Write the built configuration
self.meas.write_attribute('configuration', json.dumps(cfg))
def read_motors(config, dev_names): # FIXME: Should have separate test?
# For each motor in the list, make Tango servers and query them for information
all_motor_params = {}
for server in sorted(dev_names.keys()):
for motor in dev_names[server]:
oms_dp = DeviceProxy('{}/{}/motor/{}'.format(config['tango_host'], config['beamline'], motor))
zmx_dp = DeviceProxy('{}/{}/ZMX/{}'.format(config['tango_host'], config['beamline'], motor))
print('Reading parameters for motor {}...'.format(motor))
all_motor_params[motor] = read_parameters(oms_dp, zmx_dp)
print('{}: DONE'.format(motor))
print('\nSuccessfully read configurations for motors:\n{}'.format(', '.join(dev_names[server])))
return all_motor_params
def __init__(self, inst, props, *args, **kwargs):
MotorController.__init__(self, inst, props, *args, **kwargs)
self.axisAttributes = {}
self.interlockProxy = None
try:
print self.MotorName, self.InterlockDevice
self.motorProxy = DeviceProxy(self.MotorName)
if self.InterlockDevice != "":
self.interlockProxy = DeviceProxy(self.InterlockDevice)
except DevFailed, df:
de = df[0]
self._log.error("__init__ DevFailed: (%s) %s" %
(de.reason, de.desc))
self._log.error("__init__ DevFailed: %s" % str(df))
def make_test(self, attr=None):
"""
Performs a full test of the tango server device
If the attribute is given - trying to read it as well
:param attr:
:return:
"""
#@TODO : test database
res = True
try:
d = DeviceProxy(self.device)
self.debug("Device ({}) ping value ({})".format(
self.device, d.ping()))
state = d.state()
if state == DevState.FAULT or state == DevState.UNKNOWN:
raise DevFailed
if self.testString(attr):
v = d.read_attribute(attr)
except (DevFailed, AttributeError) as e:
res = False
return res
def read_attributes(self, attrs):
"""
Reads attribute value, returns none in case of na error
:param attr:
:return:
"""
res = []
try:
if not self.test(self.device):
raise ValueError
d = DeviceProxy(self.device)
d.ping()
self.debug("Device ({}) is online".format(self.device))
state = d.state()
values = None
# read value only if the state is fine
if state != DevState.FAULT and state != DevState.UNKNOWN:
values = d.read_attributes(attrs)
for value in values:
res.append(value.value)
self.debug("Attributes value ({}/{}/{})".format(state, attrs, res))
except DevFailed:
self.error(
"There is an error with access to the device ({})".format(
self.device))
except ValueError:
self.error("User has not provided a valid device name")
return res
def _poll_image(sleep_time, video_device, device_uri, video_mode, formats):
from PyTango import DeviceProxy
connected = False
while not connected:
try:
logging.getLogger("HWR").info("Connecting to %s", device_uri)
lima_tango_device = DeviceProxy(device_uri)
lima_tango_device.ping()
except Exception as ex:
logging.getLogger("HWR").exception("")
logging.getLogger("HWR").info(
"Could not connect to %s, retrying ...", device_uri)
connected = False
time.sleep(0.2)
else:
connected = True
while True:
try:
data = poll_image(lima_tango_device, video_mode, formats)[0]
video_device.write(data)
except Exception as ex:
print(ex)
finally:
time.sleep(sleep_time / 2)
def __init__(self, model, parent=None):
QWidget.__init__(self, parent)
uic.loadUi("MotorWidget.ui", self)
self.connect(self.configButton, SIGNAL("clicked()"), self.openConfig)
self.connect(self.goButton, SIGNAL("clicked()"), self.go)
self.connect(self.moveNegButton, SIGNAL("clicked()"), self.moveNeg)
self.connect(self.movePosButton, SIGNAL("clicked()"), self.movePos)
self.connect(self.disableButton, SIGNAL("toggled(bool)"), self.disable)
self.stateLabel.setModel("%s/state" % model)
self.positionLCD.setModel("%s/position" % model)
self.motor = DeviceProxy(str(model))
try:
self.nameLabel.setText(self.motor.alias())
except Exception:
match = re.search(r"((?:[^/]+/){2}[^/]+)$", model)
if not match:
self.nameLabel.setText(model)
else:
self.nameLabel.setText(match.group(1))
pos = AttributeProxy("%s/position" % model)
try:
self.unitLabel.setText(pos.get_config().unit)
except Exception:
self.unitLabel.setText("")
self.absMotionEdit.setText(str(self.motor.position))
def init(self):
self.predefinedPositions = {}
self.predefinedLightLevel = {}
self.predefinedPositionsNamesList = []
self.delta = self.getProperty('delta') or 10
self.light_dev = DeviceProxy(self.getProperty('tangoname_light'))
try:
positions = self['positions']
except:
logging.getLogger().error('%s does not define positions.', str(self.name()))
else:
for definedPosition in positions:
positionUsername = definedPosition.getProperty('username')
try:
offset = float(definedPosition.getProperty('offset'))
light_level = float(definedPosition.getProperty('lightLevel'))
except:
logging.getLogger().warning('%s, ignoring position %s: invalid offset.', str(self.name()), positionUsername)
else:
self.predefinedPositions[positionUsername] = offset
self.predefinedLightLevel[positionUsername] = light_level
self.sortPredefinedPositionsList()
def subscribe(self, form, callback):
"""
Tango event subscription.
The 'form' argument is an instance of TangoEventSubscriptionForm
Throws in case of error
"""
dev_proxy = DeviceProxy(form.dev)
fq_attr_name = event_source_str("{}/{}".format(dev_proxy.dev_name(),
form.attr))
if (fq_attr_name, form.evt_type) in self._subscriptions:
try:
self.unsubscribe(fq_attr_name, form.evt_type)
except Exception as e:
self.logger.error(e)
raise
tango_evt = TangoEventInfo(
attr=form.attr,
dev_proxy=dev_proxy,
evt_type=form.evt_type,
message_id=form.message_id,
user_data=form.user_data,
)
pre_subscription_action(form, dev_proxy)
self._subscriptions[(fq_attr_name, form.evt_type)] = tango_evt
try:
tango_evt.subscribe(callback)
except:
del self._subscriptions[(fq_attr_name, form.evt_type)]
raise
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 refreshAttributes(self, device):
attrs = []
try:
db = self.db
name = device.name()
full_name = db.getFullName() + "/" + name
taurus_dev = db.factory().getDevice(full_name,
create_if_needed=False)
if taurus_dev is None:
dev = DeviceProxy(full_name)
else:
dev = taurus_dev.getDeviceProxy()
attr_info_list = dev.attribute_list_query_ex()
for attr_info in attr_info_list:
full_attr_name = "%s/%s" % (full_name, attr_info.name)
attr_obj = TangoAttrInfo(self,
name=attr_info.name,
full_name=full_attr_name,
device=device,
info=attr_info)
attrs.append(attr_obj)
attrs = sorted(attrs, key=lambda attr: attr.name().lower())
except DevFailed as df:
pass
device.setAttributes(attrs)
def _init(self):
self.currentResolution = None
self.currentDistance = None
self.currentWavelength = None
self.currentEnergy = None
self.connect("equipmentReady", self.equipmentReady)
self.connect("equipmentNotReady", self.equipmentNotReady)
self.device = DeviceProxy( self.getProperty("tangoname") )
#self.monodevice = SimpleDevice(self.getProperty("tangoname2"), waitMoves = False, verbose=False)
self.blenergyHOname = self.getProperty("BLEnergy")
if self.blenergyHOname is None:
logging.getLogger("HWR").error('TangoResolution: you must specify the %s hardware object' % self.blenergyHOname)
hobj=None
self.configOk=False
else:
hobj=HardwareRepository.HardwareRepository().getHardwareObject(self.blenergyHOname)
if hobj is None:
logging.getLogger("HWR").error('TangoResolution: invalid %s hardware object' % self.blenergyHOname)
self.configOk=False
self.blenergyHO=hobj
self.connect(self.blenergyHO,qt.PYSIGNAL('energyChanged'), self.energyChanged)
# creer un chanel sur l'energy: pour faire un update
positChan = self.getChannelObject("position") # utile seulement si statechan n'est pas defini dans le code
positChan.connectSignal("update", self.positionChanged)
stateChan = self.getChannelObject("state") # utile seulement si statechan n'est pas defini dans le code
stateChan.connectSignal("update", self.stateChanged)
self.currentDistance = self.device.position
self.currentEnergy = self.blenergyHO.getCurrentEnergy()
self.currentWavelength = self.blenergyHO.getCurrentWavelength()
return BaseHardwareObjects.Equipment._init(self)
def log(self, details):
cmessage = details[3]
clevel = details[1]
tango_log_level = {
"FATAL": 1,
"ERROR": 2,
"WARN": 3,
"INFO": 4,
"DEBUG": 5
}
level_number = tango_log_level[clevel]
clogsource = details[2]
if clogsource == details[2]:
device = DeviceProxy(clogsource)
deviceLogLevel = device.centralLoggingLevel
if clevel == "FATAL" and level_number <= deviceLogLevel:
self.fatal_stream("%s : %s", clogsource, cmessage)
elif clevel == "ERROR" and level_number <= deviceLogLevel:
self.error_stream("%s : %s", clogsource, cmessage)
elif clevel == "WARN" and level_number <= deviceLogLevel:
self.warn_stream("%s : %s", clogsource, cmessage)
elif clevel == "INFO" and level_number <= deviceLogLevel:
self.info_stream("%s : %s", clogsource, cmessage)
elif clevel == "DEBUG" and level_number <= deviceLogLevel:
self.debug_stream("%s : %s", clogsource, cmessage)
else:
pass
else:
pass
def test_add_member(self):
device_name = '%s/sub/1' % self.DOMAIN_NAME
group_name = 'capabilities'
# self.stop_device_server('Subarray_DS')
# self.start_device_server('Subarray_DS')
dp = DeviceProxy(device_name)
dp.set_logging_level(5)
member_device_name_1 = '%s/capability/sub1cap1' % self.DOMAIN_NAME
data_1 = json.dumps({
'group_name': group_name,
'device_name': member_device_name_1
})
dp.command_inout('add_member', data_1)
self.assertTrue(
member_device_name_1 in dp.get_property(group_name)[group_name])
member_device_name_2 = '%s/capability/sub1cap2' % self.DOMAIN_NAME
data_2 = json.dumps({
'group_name': group_name,
'device_name': member_device_name_2
})
dp.command_inout('add_member', data_2)
items = dp.get_property(group_name)[group_name]
self.assertTrue(member_device_name_2 in items)
self.assertEqual(len(items), 2)
dp.command_inout('remove_member', data_2)
items = dp.get_property(group_name)[group_name]
self.assertFalse(member_device_name_2 in items)
self.assertEqual(len(items), 1)
dp.command_inout('remove_member', data_1)
self.assertFalse(
member_device_name_1 in dp.get_property(group_name)[group_name])
def __init__(self,
devName,
attrName,
minPeriod=0.1,
minChange=0.001,
callbacks=None,
*args,
**kwargs):
super(Monitor, self).__init__(*args, **kwargs)
self._devName = devName
self._attrName = attrName
self._name = "%s/%s" % (devName, attrName)
try:
self._proxy = DeviceProxy(self._devName)
except:
raise ReferenceError("DeviceProxy for %s not available" %
self._name)
self._eventId = None
self._value = None
self._quality = None
self._minPeriod = minPeriod
self._minChange = minChange
self._timestamp = None
self._callbacks = callbacks
self.subscribe()
def errorDeviceInstance(self, device):
logging.getLogger("HWR").debug("%s: BLEnergy.errorDeviceInstance: %s",
self.name(), device)
db = DeviceProxy("sys/database/dbds1")
logging.getLogger().error("Check Instance of Device server %s" %
db.DbGetDeviceInfo(device)[1][3])
self.sDisconnected()
def _init(self):
self.MOVESTARTED = 0
self.NOTINITIALIZED = 0
self.UNUSABLE = 0
self.READY = 2
self.MOVING = 4
self.ONLIMIT = 1
self.device = DeviceProxy(
self.getProperty("tangoname")) #, verbose=False)
self.device.timeout = 6000 # Setting timeout to 6 sec
self.device.waitMoves = False
logging.getLogger("HWR").info("TangoMotor._init of device %s" %
self.device.name)
self.setIsReady(True)
print "TangoMotor._init of device %s" % self.device.name
positionChan = self.getChannelObject(
"position"
) # utile seulement si statechan n'est pas defini dans le code
positionChan.connectSignal("update", self.positionChanged)
stateChan = self.getChannelObject(
"state"
) # utile seulement si statechan n'est pas defini dans le code
stateChan.connectSignal("update", self.motorStateChanged)
def ping_to_device():
Log('server asked to ping from device', 'd')
global disable_Pytango
if disable_Pytango:
p = DeviceProxy("sys/tg_test/1")
elapsed_time = p.ping()
emit("pong from device", {'elapsed': elapsed_time})
Log('client ponged from device', 'd')
def add_members(self, device_name, group_name, members=None):
dp = DeviceProxy(device_name)
for member in members:
data = json.dumps({
'group_name': group_name,
'device_name': member
})
dp.command_inout('add_member', data)
def init(self):
HardwareObject.init(self)
self.template_dir = self.get_property("template_dir")
var_dsname = self.get_property("variables_ds")
logging.getLogger("HWR").debug(
"ALBAAutoProcessing INIT: var_ds=%s, template_dir=%s" %
(var_dsname, self.template_dir))
self.var_ds = DeviceProxy(var_dsname)
def get_attribute_list():
print("in get_attribute_list")
try:
p = DeviceProxy("sys/tg_test/1")
attributes = p.get_attribute_list()
parsedAttributes = parseStdStringVector(attributes)
return jsonify(parsedAttributes)
except (CommunicationFailed, ConnectionFailed, DevFailed) as e:
return jsonify(handleException(e))
def command_list_query():
print("in command_list_query")
try:
p = DeviceProxy("sys/tg_test/1")
commands = p.command_list_query()
parsedCommands = parseCommandInfoList(commands)
return jsonify(parsedCommands)
except (CommunicationFailed, ConnectionFailed, DevFailed) as e:
return jsonify(handleException(e))
def init_graph(self):
temp = str(self.itemText).split(' - ')
self.ui.hour_label.show()
self.ui.hour_value.show()
self.ui.minutes_label.show()
self.ui.minutes_value.show()
if len(temp) > 1:
self.attr = temp[1]
with open('graph_config', 'r') as fin:
graph_nodes = json.loads(fin.read())
current_graph_node = graph_nodes[str(self.itemText)]
total_graph_values = int(
current_graph_node['total_graph_values'])
graph_updation_time = int(
current_graph_node['graph_updation_time'])
print "----init_graph----"
print "total_graph_values:", total_graph_values
print "graph_updation_time:", graph_updation_time
elif len(temp) == 1:
self.attr = str(self.ui.childrenBox.currentText())
with open('graph_config', 'r') as fin:
graph_nodes = json.loads(fin.read())
current_graph_node = graph_nodes[str(self.itemText)]
self.total_graph_values = int(
current_graph_node['total_graph_values'])
graph_updation_time = int(
current_graph_node['graph_updation_time'])
print "----init_graph----"
print "total_graph_values:", self.total_graph_values
print "graph_updation_time:", graph_updation_time
self.branch_time_array = []
self.branch_axis_counter = 0
pg.setConfigOptions(antialias=True)
self.ui.graphicsView.clear()
self.curve = self.ui.graphicsView.plot(pen='y')
try:
self.l.scene().removeItem(self.l)
except AttributeError:
pass
self.l = pg.LegendItem((100, 60), offset=(70, 30))
self.l.setParentItem(self.ui.graphicsView.graphicsItem())
self.l.addItem(self.curve, self.attr)
self.data = []
self.ptr = 0
if len(temp) > 1:
self.proxy = DeviceProxy(temp[0])
params = json.dumps({'period': 1})
data = json.loads(self.proxy.get_data(params))
data = data[self.attr]
data_len = len(data)
self.data_period = total_graph_values / data_len
else:
self.proxy = ''
self.graphTimer.stop()
self.graphTimer.timeout.connect(self.update_plot)
self.graphTimer.start(graph_updation_time)
def cmdDevice(domain,deviceClass,deviceInstance):
dev = DeviceProxy(domain+"/"+deviceClass+"/"+deviceInstance)
json_data = request.get_json()
cmd_name = json_data["cmd_name"]
cmd_param = json_data["cmd_param"]
if (cmd_param== "None"):
result = dev.command_inout(cmd_name)
else:
result = dev.command_inout(cmd_name,cmd_param)
return cmd_name
def read_attribute(attribute):
if app.testing:
print("in read_attribute")
try:
p = DeviceProxy("sys/tg_test/1")
redAttribute = p.read_attribute(attribute)
response = parseAttribute(redAttribute)
return jsonify(response)
except (CommunicationFailed, ConnectionFailed, DevFailed) as e:
return jsonify(handleException(e))
def init(self):
self.get_object_by_role("controller")
self.shutter = self.get_deviceby_role("shutter")
self.aperture = self.get_object_by_role("aperture")
self.factor = self.get_property("current_photons_factor")
self.shutter.connect("shutterStateChanged", self.shutterStateChanged)
self.tg_device = DeviceProxy(self.get_property("tango_device"))
self.counts_reading_task = self._read_counts_task(wait=False)
