def set(self, conf, mnt_grps=None):
"""Sets the ExperimentConfiguration dictionary."""
if mnt_grps is None:
mnt_grps = list(conf['MntGrpConfigs'].keys())
codec = CodecFactory().getCodec('json')
msg_error = ''
for mnt_grp in mnt_grps:
try:
mnt_grp_cfg = conf['MntGrpConfigs'][mnt_grp]
if mnt_grp_cfg is None: # a mntGrp to be deleted
pool = self._getPoolOfElement(mnt_grp)
pool.DeleteElement(mnt_grp)
else:
try:
# TODO: Fix incorrect implementation. It must check if
# the measurement group is part of the Pools
# controlled by the MacroServer. Otherwise,
# it must raise an exception.
mnt_grp_dev = Device(mnt_grp)
except Exception:
# if the mnt_grp did not already exist, create it now
chconfigs = getChannelConfigs(mnt_grp_cfg)
chnames, chinfos = list(zip(*chconfigs)) # unzipping
# We assume that all the channels belong to the same
# pool!
pool = self._getPoolOfElement(chnames[0])
pool.createMeasurementGroup([mnt_grp] + list(chnames))
mnt_grp_dev = Device(mnt_grp)
# TODO when we start using measurement group extension
# change the code below with the following:
# mnt_grp.setConfiguration(mnt_grp_cfg)
data = codec.encode(('', mnt_grp_cfg))[1]
mnt_grp_dev.write_attribute('configuration', data)
except PyTango.DevFailed as df:
# Take the description of the first exception.
desc = df.args[0].desc
desc = desc.replace('\r', '')
desc = desc.replace('\n', '')
msg_error += 'Measurement Group {0}:\n'\
'{1}\n\n'.format(mnt_grp, desc)
if len(msg_error) > 0:
raise RuntimeError(msg_error)
# Send the environment changes
env = dict(ScanDir=conf.get('ScanDir'),
ScanFile=conf.get('ScanFile'),
DataCompressionRank=conf.get('DataCompressionRank', -1),
ActiveMntGrp=conf.get('ActiveMntGrp'),
PreScanSnapshot=conf.get('PreScanSnapshot'))
self._door.putEnvironments(env)
def prepare(self, integ_time, mnt_grp, **opts):
self.print_value = False
if mnt_grp is None:
self.mnt_grp_name = self.getEnv('ActiveMntGrp')
self.mnt_grp = self.getObj(self.mnt_grp_name,
type_class=Type.MeasurementGroup)
else:
self.mnt_grp_name = mnt_grp.name
self.mnt_grp = mnt_grp
if self.mnt_grp is None:
return
names = self.mnt_grp.getChannelLabels()
self.names = [[n] for n in names]
self.channels = []
self.values = []
for channel_info in self.mnt_grp.getChannels():
full_name = channel_info["full_name"]
channel = Device(full_name)
self.channels.append(channel)
value = channel.getValue(force=True)
self.values.append([value])
valueObj = channel.getValueObj_()
valueObj.subscribeEvent(self.counterChanged, channel)
def onPlayMacro(self):
door = Device(self.doorName())
try:
doorState = door.state()
except TypeError:
# TODO: For Taurus 4 adaptation
doorState = door.getState()
if doorState == PyTango.DevState.ON or doorState == PyTango.DevState.ALARM:
self.setFocus()
paramEditorModel = self.paramEditorModel()
macroNode = paramEditorModel.root()
id = macroNode.assignId()
self.setMacroId(id)
params, alerts = macroNode.toRun()
xmlString = paramEditorModel.toXmlString()
if len(alerts) > 0:
Qt.QMessageBox.warning(self, "Macro parameters warning",
alerts)
return
door.runMacro(xmlString)
self.addToHistory()
# door.runMacro(str(macroNode.name()), params)
elif doorState == PyTango.DevState.STANDBY:
door.command_inout("ResumeMacro")
else:
Qt.QMessageBox.warning(
self, "Error while starting/resuming macro",
"It was not possible to start/resume macro, because state of the door was different than ON/STANDBY"
)
def stress_count(self, elements, repeats, synchronizer, synchronization):
if (elements == ["_test_ct_1_1", "_test_0d_1_1"]
and synchronizer == "_test_tg_1_1"
and synchronization == AcqSynchType.Trigger
and os.name == "nt"):
self.skipTest("fails on Windows")
mg_name = str(uuid.uuid1())
argin = [mg_name] + elements
self.pool.CreateMeasurementGroup(argin)
try:
mg = Device(mg_name)
mg.setSynchronizer(synchronizer, elements[0], apply=False)
mg.setSynchronization(synchronization, elements[0])
for i in range(repeats):
state, values = mg.count(.001)
self.assertEqual(state, DevState.ON,
"wrong state after measurement {}".format(i))
for channel_name, value in values.items():
msg = ("Value {} for {} is not numerical in "
"measurement {}").format(value, channel_name, i)
self.assertTrue(is_numerical(value), msg)
finally:
mg.cleanUp()
if os.name != "nt":
self.pool.DeleteElement(mg_name)
def test_ValueRefEnabled(self, elements=["_test_2d_1_1", "_test_2d_1_2",
"_test_ct_1_3",
"_test_mt_1_3/position"]):
mg_name = str(uuid.uuid1())
argin = [mg_name] + elements
self.pool.CreateMeasurementGroup(argin)
try:
mg = Device(mg_name)
# Check initial state of all kind of channels, nonexistent
# channels for the feature return None as result.
enabled = mg.getValueRefEnabled(*elements)
expected = [False, False, None, None]
self._assertMultipleResults(enabled, elements, expected)
# Check if the nonexistent channels raise error if trying to set
with self.assertRaises(Exception):
mg.setValueRefEnabled(True, *elements[-2])
with self.assertRaises(Exception):
mg.setValueRefEnabled(True, *elements[-1])
# Redefine elements to ony use existing values
elements = ["_test_2d_1_1", "_test_2d_1_2"]
# Test every possible combination of setting values
# Check that changing one channel doesn't affect the other
mg.setValueRefEnabled(True, *elements)
enabled = mg.getValueRefEnabled(*elements)
self._assertResult(enabled, elements, True)
mg.setValueRefEnabled(False, elements[0])
result = mg.getValueRefEnabled(*elements)
expected = [True] * len(elements)
expected[0] = False
self._assertMultipleResults(result, elements, expected)
mg.setValueRefEnabled(True, *elements)
enabled = mg.getValueRefEnabled(*elements)
self._assertResult(enabled, elements, True)
# Set values using the controller instead of channels
mg.setValueRefEnabled(True, "_test_2d_ctrl_1")
enabled = mg.getValueRefEnabled(*elements)
self._assertResult(enabled, elements, True)
# Get values by controller
mg.setValueRefEnabled(False, *elements)
enabled = mg.getValueRefEnabled("_test_2d_ctrl_1")
self._assertResult(enabled, elements, False)
# Check ret_full_name
v = TangoDeviceNameValidator()
full_names = [v.getNames(element)[0] for element in elements]
enabled = mg.getValueRefEnabled(*full_names)
self._assertResult(enabled, elements, False)
mg.setValueRefEnabled(True, *full_names)
enabled = mg.getValueRefEnabled(*elements, ret_full_name=True)
self._assertResult(enabled, full_names, True)
finally:
mg.cleanUp()
if os.name != "nt":
self.pool.DeleteElement(mg_name)
def init_device(self):
try:
self.device = Device(self.taurusname)
except DevFailed, traceback:
last_error = traceback[-1]
logging.getLogger('HWR').error("%s: %s", str(self.name()),
last_error['desc'])
self.device = None
def onPauseMacro(self):
door = Device(self.doorName())
doorState = door.getState()
if doorState == PyTango.DevState.RUNNING:
door.command_inout("PauseMacro")
else:
Qt.QMessageBox.warning(self, "Error while pausing macro",
"It was not possible to pause macro, because state of the door was different than RUNNING")
def onStopMacro(self):
door = Device(self.doorName())
doorState = door.getState()
if doorState in (PyTango.DevState.RUNNING, PyTango.DevState.STANDBY):
door.command_inout("StopMacro")
else:
Qt.QMessageBox.warning(self, "Error while stopping macro",
"It was not possible to stop macro, because state of the door was different than RUNNING or STANDBY")
def test_value_ref_enabled(self):
mg_name = str(uuid.uuid1())
channel_name = "_test_2d_1_1"
argin = [mg_name, channel_name]
self.pool.CreateMeasurementGroup(argin)
try:
mg = Device(mg_name)
channel = Device(channel_name)
mg.setValueRefEnabled(True, channel_name)
_, values = mg.count(.1)
for channel_name, value in values.items():
msg = "ValueRef (%s) for %s is not string" %\
(value, channel_name)
self.assertTrue(is_pure_str(value), msg)
finally:
channel.cleanUp()
mg.cleanUp()
self.pool.DeleteElement(mg_name)
def test_value_ref_disabled(self):
mg_name = str(uuid.uuid1())
channel_name = "_test_2d_1_1"
argin = [mg_name, channel_name]
self.pool.CreateMeasurementGroup(argin)
try:
mg = Device(mg_name)
channel = Device(channel_name)
conf = mg.getConfiguration().raw_data
_set_value_ref_enabled(conf, channel, False)
mg.setConfiguration(conf)
_, values = mg.count(.1)
for channel_name, value in values.iteritems():
msg = "Value (%s) for %s is not numerical" %\
(value, channel_name)
self.assertTrue(is_numerical(value), msg)
finally:
channel.cleanUp()
mg.cleanUp()
self.pool.DeleteElement(mg_name)
def count(self, elements):
argin = [self.mg_name] + elements
self.pool.CreateMeasurementGroup(argin)
try:
self.mg = Device(self.mg_name)
_, values = self.mg.count(1)
for channel, value in values.iteritems():
msg = "Value for %s is not numerical" % channel
self.assertTrue(is_numerical(value), msg)
finally:
self.pool.DeleteElement(self.mg_name)
def onDoorChanged(self, doorName):
MacroExecutionWindow.onDoorChanged(self, doorName)
if self._qDoor:
Qt.QObject.disconnect(
self._qDoor, Qt.SIGNAL("macroStatusUpdated"),
self.taurusMacroExecutorWidget.onMacroStatusUpdated)
if doorName == "": return
self._qDoor = Device(doorName)
Qt.QObject.connect(self._qDoor, Qt.SIGNAL("macroStatusUpdated"),
self.taurusMacroExecutorWidget.onMacroStatusUpdated)
self.taurusMacroExecutorWidget.onDoorChanged(doorName)
def onDoorChanged(self, doorName):
MacroExecutionWindow.onDoorChanged(self, doorName)
if self._qDoor:
self._qDoor.macroStatusUpdated.disconnect(
self.taurusMacroExecutorWidget.onMacroStatusUpdated)
if doorName == "":
return
self._qDoor = Device(doorName)
self._qDoor.macroStatusUpdated.connect(
self.taurusMacroExecutorWidget.onMacroStatusUpdated)
self.taurusMacroExecutorWidget.onDoorChanged(doorName)
def test_ValueRefPattern(self,
elements=[
"_test_2d_1_1", "_test_2d_1_2",
"_test_ct_1_3", "_test_mt_1_3/position"
]):
mg_name = str(uuid.uuid1())
argin = [mg_name] + elements
self.pool.CreateMeasurementGroup(argin)
try:
mg = Device(mg_name)
# Check initial state of all kind of channels, nonexistent
# channels for the feature return None as result.
pattern = mg.getValueRefPattern(*elements)
expected = ['', '', None, None]
self._assertMultipleResults(pattern, elements, expected)
# Check if the nonexistent channels raise error if trying to set
with self.assertRaises(Exception):
mg.setValueRefPattern('/tmp/test_foo.txt', *elements[-2])
with self.assertRaises(Exception):
mg.setValueRefPattern('/tmp/test_foo.txt', *elements[-1])
# Redefine elements to ony use existing values
elements = ["_test_2d_1_1", "_test_2d_1_2"]
# Test every possible combination of setting values
# Check that changing one channel doesn't affect the other
mg.setValueRefPattern('/tmp/test_foo.txt', *elements)
pattern = mg.getValueRefPattern(*elements)
self._assertResult(pattern, elements, '/tmp/test_foo.txt')
# Set values using the controller instead of channels
mg.setValueRefPattern('/tmp/test_foo2.txt', "_test_2d_ctrl_1")
pattern = mg.getValueRefPattern(*elements)
self._assertResult(pattern, elements, '/tmp/test_foo2.txt')
# Get values by controller
mg.setValueRefPattern('/tmp/test_foo.txt', *elements)
pattern = mg.getValueRefPattern("_test_2d_ctrl_1")
self._assertResult(pattern, elements, '/tmp/test_foo.txt')
# Check ret_full_name
v = TangoDeviceNameValidator()
full_names = [v.getNames(element)[0] for element in elements]
pattern = mg.getValueRefPattern(*full_names)
self._assertResult(pattern, elements, '/tmp/test_foo.txt')
mg.setValueRefPattern('/tmp/test_foo2.txt', *full_names)
pattern = mg.getValueRefPattern(*elements, ret_full_name=True)
self._assertResult(pattern, full_names, '/tmp/test_foo2.txt')
finally:
mg.cleanUp()
self.pool.DeleteElement(mg_name)
def set(self, conf, mnt_grps=None):
"""Sets the ExperimentConfiguration dictionary."""
env = dict(ScanDir=conf.get('ScanDir'),
ScanFile=conf.get('ScanFile'),
DataCompressionRank=conf.get('DataCompressionRank', -1),
ActiveMntGrp=conf.get('ActiveMntGrp'),
PreScanSnapshot=conf.get('PreScanSnapshot'))
if mnt_grps is None:
mnt_grps = conf['MntGrpConfigs'].keys()
self._door.putEnvironments(env)
codec = CodecFactory().getCodec('json')
for mnt_grp in mnt_grps:
try:
mnt_grp_cfg = conf['MntGrpConfigs'][mnt_grp]
if mnt_grp_cfg is None: # a mntGrp to be deleted
pool = self._getPoolOfElement(mnt_grp)
pool.DeleteElement(mnt_grp)
else:
try:
mnt_grp_dev = Device(mnt_grp)
except: # if the mnt_grp did not already exist, create it now
chconfigs = getChannelConfigs(mnt_grp_cfg)
chnames, chinfos = zip(*chconfigs) # unzipping
# We assume that all the channels belong to the same
# pool!
pool = self._getPoolOfElement(chnames[0])
pool.createMeasurementGroup([mnt_grp] + list(chnames))
mnt_grp_dev = Device(mnt_grp)
# TODO when we start using measurement group extension change the
# code below with the following:
# mnt_grp.setConfiguration(mnt_grp_cfg)
data = codec.encode(('', mnt_grp_cfg))[1]
mnt_grp_dev.write_attribute('configuration', data)
except Exception, e:
from taurus.core.util.log import error
error(
'Could not create/delete/modify Measurement group "%s": %s',
mnt_grp, repr(e))
def test_Synchronization(self, elements=["_test_ct_1_1", "_test_ct_1_2",
"_test_ct_1_3", "_test_2d_1_1",
"_test_mt_1_3/position"]):
mg_name = str(uuid.uuid1())
argin = [mg_name] + elements
self.pool.CreateMeasurementGroup(argin)
try:
mg = Device(mg_name)
result = mg.getSynchronization()
expected = [AcqSynchType.Trigger, AcqSynchType.Trigger,
AcqSynchType.Trigger, AcqSynchType.Trigger, None]
self._assertMultipleResults(result, elements, expected)
# TODO: maybe we should raise an exception here?
# with self.assertRaises(Exception):
# mg.setSynchronization(AcqSynchType.Trigger,
# "_test_mt_1_3/position")
mg.setSynchronization(AcqSynchType.Gate, "_test_ct_ctrl_1",
"_test_2d_ctrl_1")
expected = [AcqSynchType.Gate, AcqSynchType.Gate,
AcqSynchType.Gate, AcqSynchType.Gate, None]
result = mg.getSynchronization()
self._assertMultipleResults(result, elements, expected)
mg.setSynchronization(AcqSynchType.Start, "_test_ct_ctrl_1",
"_test_2d_ctrl_1")
result = mg.getSynchronization()
expected = [AcqSynchType.Start, AcqSynchType.Start,
AcqSynchType.Start, AcqSynchType.Start, None]
self._assertMultipleResults(result, elements, expected)
with self.assertRaises(Exception):
mg.setSynchronization('asdf', "_test_ct_ctrl_1",
"_test_2d_ctrl_1")
# Check ret_full_name
v = TangoDeviceNameValidator()
counters = ["_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3",
'_test_2d_1_1']
full_names = [v.getNames(counter)[0] for counter in counters]
mg.setSynchronization(AcqSynchType.Trigger, "_test_ct_ctrl_1",
"_test_2d_ctrl_1")
result = mg.getSynchronization(*counters, ret_full_name=True)
self._assertResult(result, full_names, AcqSynchType.Trigger)
finally:
mg.cleanUp()
if os.name != "nt":
self.pool.DeleteElement(mg_name)
def test_Synchronizer(self,
elements=[
"_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3",
"_test_2d_1_1", "_test_mt_1_3/position"
]):
mg_name = str(uuid.uuid1())
argin = [mg_name] + elements
self.pool.CreateMeasurementGroup(argin)
try:
mg = Device(mg_name)
result = mg.getSynchronizer()
expected = ['software', 'software', 'software', 'software', None]
self._assertMultipleResults(result, elements, expected)
with self.assertRaises(Exception):
mg.setSynchronizer('_test_tg_1_2', "_test_mt_1_3/position")
mg.setSynchronizer('_test_tg_1_2', "_test_ct_ctrl_1",
"_test_2d_ctrl_1")
expected = [
'_test_tg_1_2', '_test_tg_1_2', '_test_tg_1_2', '_test_tg_1_2',
None
]
result = mg.getSynchronizer()
self._assertMultipleResults(result, elements, expected)
mg.setSynchronizer('software', "_test_ct_ctrl_1",
"_test_2d_ctrl_1")
result = mg.getSynchronizer()
expected = ['software', 'software', 'software', 'software', None]
self._assertMultipleResults(result, elements, expected)
with self.assertRaises(Exception):
mg.setSynchronizer('asdf', "_test_ct_ctrl_1",
"_test_2d_ctrl_1")
# Check ret_full_name
v = TangoDeviceNameValidator()
counters = [
"_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3", '_test_2d_1_1'
]
full_names = [v.getNames(counter)[0] for counter in counters]
mg.setSynchronizer('_test_tg_1_2', "_test_ct_ctrl_1",
"_test_2d_ctrl_1")
result = mg.getSynchronizer(*counters, ret_full_name=True)
self._assertResult(result, full_names, '_test_tg_1_2')
finally:
mg.cleanUp()
self.pool.DeleteElement(mg_name)
def prepare(self, integ_time, countable_elem, **opts):
self.print_value = False
if countable_elem is None:
try:
self.countable_elem_name = self.getEnv('ActiveMntGrp')
except UnknownEnv:
return
self.countable_elem = self.getObj(self.countable_elem_name)
else:
self.countable_elem_name = countable_elem.name
self.countable_elem = countable_elem
if self.countable_elem is None:
return
self.channels = []
self.values = []
if self.countable_elem.type == Type.MeasurementGroup:
names = self.countable_elem.getChannelLabels()
self.names = [[n] for n in names]
for channel_info in self.countable_elem.getChannels():
full_name = channel_info["full_name"]
channel = Device(full_name)
self.channels.append(channel)
value = channel.getValue(force=True)
self.values.append([value])
valueObj = channel.getValueObj_()
valueObj.subscribeEvent(self.counterChanged, channel)
else:
channel = self.countable_elem
self.names = [[channel.getName()]]
channel = Device(channel.full_name)
self.channels.append(channel)
value = channel.getValue(force=True)
self.values.append([value])
valueObj = channel.getValueObj_()
valueObj.subscribeEvent(self.counterChanged, channel)
def onDoorChanged(self, doorName):
self.setDoorName(doorName)
if self.doorName() == "":
self.doorStateLed.setModel(None)
return
self.doorStateLed.setModel(self.doorName() + "/State")
door = Device(doorName)
doorState = door.stateObj.rvalue
if doorState == PyTango.DevState.ON:
self.playMacroAction.setText("Start macro")
self.playMacroAction.setToolTip("Start macro")
elif doorState == PyTango.DevState.STANDBY:
self.playMacroAction.setText("Resume macro")
self.playMacroAction.setToolTip("Resume macro")
def onPauseSequence(self):
door = Device(self.doorName())
try:
doorState = door.state()
except TypeError:
# TODO: For Taurus 4 adaptation
doorState = door.getState()
if doorState == PyTango.DevState.RUNNING:
door.command_inout("PauseMacro")
else:
Qt.QMessageBox.warning(
self, "Error while pausing sequence",
"It was not possible to pause sequence, "
"because state of the door was different than RUNNING")
def count(self, elements):
mg_name = str(uuid.uuid1())
argin = [mg_name] + elements
self.pool.CreateMeasurementGroup(argin)
try:
mg = Device(mg_name)
_, values = mg.count(.1)
for channel_name, value in values.iteritems():
msg = "Value (%s) for %s is not numerical" % \
(value, channel_name)
self.assertTrue(is_numerical(value), msg)
finally:
mg.cleanUp()
self.pool.DeleteElement(mg_name)
def test_PlotType(self,
elements=[
"_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3",
"_test_2d_1_3", "_test_mt_1_3/position"
]):
mg_name = str(uuid.uuid1())
argin = [mg_name] + elements
self.pool.CreateMeasurementGroup(argin)
try:
mg = Device(mg_name)
plottype = mg.getPlotType()
self._assertResult(plottype, elements, 0)
mg.setPlotType("Image", elements[0])
mg.setPlotType("Spectrum", elements[1])
mg.setPlotType("No", elements[2])
mg.setPlotType("Image", elements[3])
mg.setPlotType("Image", elements[4])
plottype = mg.getPlotType()
expected_values = [2, 1, 0, 2, 2]
self._assertMultipleResults(plottype, elements, expected_values)
with self.assertRaises(ValueError):
mg.setPlotType("asdf", elements[2])
# Redefine elements
elements = ["_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3"]
# Set values using the controller instead of channels
mg.setPlotType("Image", "_test_ct_ctrl_1")
plottype = mg.getPlotType(*elements)
self._assertResult(plottype, elements, 2)
# Get values by controller
mg.setPlotType("Spectrum", *elements)
plottype = mg.getPlotType("_test_ct_ctrl_1")
self._assertResult(plottype, elements, 1)
# Check ret_full_name
v = TangoDeviceNameValidator()
full_names = [v.getNames(element)[0] for element in elements]
plottype = mg.getPlotType(*full_names)
self._assertResult(plottype, elements, 1)
mg.setPlotType("Image", *full_names)
plottype = mg.getPlotType(*elements, ret_full_name=True)
self._assertResult(plottype, full_names, 2)
finally:
mg.cleanUp()
self.pool.DeleteElement(mg_name)
def init_device(self):
try:
self.device = Device(self.taurusname)
except DevFailed as traceback:
last_error = traceback[-1]
logging.getLogger("HWR").error("%s: %s", str(self.name()),
last_error["desc"])
self.device = None
else:
try:
self.device.ping()
except ConnectionFailed:
self.device = None
raise ConnectionError
def fill_sardana_config(self, config):
import sardana.spock
profile = 'spockdoor'
if not config.Spock:
if hasattr(Qt.qApp, 'SDM'):
dm = Qt.qApp.SDM.getDataModelProxy('doorName')
if dm is not None:
door_name = dm.getData()
door = Device(door_name)
dalias, dname = door.getSimpleName(), door.getNormalName()
create_sardana_profile(dalias, dname)
profile = dalias
config.Spock.door_name = dname
sardana.spock.load_config(config)
return profile
def checkDoorState(self):
door = Device(self.doorName())
doorState = door.getState()
if doorState == PyTango.DevState.RUNNING:
self.playMacroAction.setEnabled(False)
self.pauseMacroAction.setEnabled(True)
self.stopMacroAction.setEnabled(True)
elif doorState == PyTango.DevState.ON or doorState == PyTango.DevState.ALARM:
self.playMacroAction.setEnabled(True)
self.pauseMacroAction.setEnabled(False)
self.stopMacroAction.setEnabled(False)
elif doorState == PyTango.DevState.STANDBY:
self.playMacroAction.setEnabled(True)
self.pauseMacroAction.setEnabled(False)
self.stopMacroAction.setEnabled(True)
def onStopSequence(self):
door = Device(self.doorName())
try:
doorState = door.state()
except TypeError:
# TODO: For Taurus 4 adaptation
doorState = door.getState()
if doorState in (PyTango.DevState.RUNNING, PyTango.DevState.STANDBY):
door.command_inout("StopMacro")
else:
Qt.QMessageBox.warning(
self, "Error while stopping sequence",
"It was not possible to stop sequence, "
"because state of the door was different than "
"RUNNING or STANDBY")
def test_Monitor(self,
elements=[
"_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3",
"_test_2d_1_1", '_test_2d_1_2',
"_test_mt_1_3/position"
]):
mg_name = str(uuid.uuid1())
argin = [mg_name] + elements
self.pool.CreateMeasurementGroup(argin)
try:
mg = Device(mg_name)
with self.assertRaises(Exception):
mg.setMonitor("_test_mt_1_3/position")
mg.setMonitor('_test_2d_1_2')
mg.setMonitor("_test_ct_1_3")
expected = [
"_test_ct_1_3", "_test_ct_1_3", "_test_ct_1_3", "_test_2d_1_2",
'_test_2d_1_2', None
]
result = mg.getMonitor()
self._assertMultipleResults(result, elements, expected)
expected = ["_test_ct_1_3", '_test_2d_1_2', None]
result = mg.getMonitor(ret_by_ctrl=True)
ctrls = ['_test_ct_ctrl_1', '_test_2d_ctrl_1', '__tango__']
self._assertMultipleResults(result, ctrls, expected)
# Check ret_full_name
v = TangoDeviceNameValidator()
counters = [
"_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3", '_test_2d_1_1',
'_test_2d_1_2'
]
full_names = [v.getNames(counter)[0] for counter in counters]
mg.setMonitor(v.getNames('_test_ct_1_1')[0])
mg.setMonitor(v.getNames('_test_2d_1_2')[0])
result = mg.getMonitor(*counters, ret_full_name=True)
expected = [
"_test_ct_1_1", "_test_ct_1_1", "_test_ct_1_1", "_test_2d_1_2",
'_test_2d_1_2'
]
self._assertMultipleResults(result, full_names, expected)
finally:
mg.cleanUp()
self.pool.DeleteElement(mg_name)
def test_Timer(self,
elements=[
"_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3",
"_test_mt_1_3/position"
]):
mg_name = str(uuid.uuid1())
argin = [mg_name] + elements
self.pool.CreateMeasurementGroup(argin)
try:
mg = Device(mg_name)
result = mg.getTimer("_test_mt_1_3/position")
with self.assertRaises(Exception):
mg.setTimer("_test_mt_1_3/position")
self._assertResult(result, ["_test_mt_1_3/position"], None)
mg.setTimer('_test_ct_1_3')
result = mg.getTimer(*elements)
expected = ['_test_ct_1_3', '_test_ct_1_3', '_test_ct_1_3', None]
self._assertMultipleResults(result, elements, expected)
mg.setTimer('_test_ct_1_2')
result = mg.getTimer(*elements)
expected = ['_test_ct_1_2', '_test_ct_1_2', '_test_ct_1_2', None]
self._assertMultipleResults(result, elements, expected)
result = mg.getTimer(*elements, ret_by_ctrl=True)
self._assertMultipleResults(result,
['_test_ct_ctrl_1', '__tango__'],
['_test_ct_1_2', None])
# Check ret_full_name
v = TangoDeviceNameValidator()
counters = ["_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3"]
full_names = [v.getNames(counter)[0] for counter in counters]
mg.setTimer(v.getNames('_test_ct_1_1')[0])
result = mg.getTimer()
expected = ['_test_ct_1_1', '_test_ct_1_1', '_test_ct_1_1', None]
self._assertMultipleResults(result, elements, expected)
# TODO ret_full_name gives controler name
mg.setTimer("_test_ct_1_2")
result = mg.getTimer(*counters, ret_full_name=True)
self._assertResult(result, full_names, "_test_ct_1_2")
finally:
mg.cleanUp()
self.pool.DeleteElement(mg_name)
def init_device(self):
self.door = Device(self.doorname)
self.door.set_timeout_millis(10000)
#
# DIRTY FIX to make compatible taurus listeners and existence of Tango channels/commands
# as defined in Command/Tango.py
#
# if self.door.__class__ == taurus.core.tango.tangodevice.TangoDevice:
# dp = self.door.getHWObj()
# try:
# dp.subscribe_event = dp._subscribe_event
# except AttributeError:
# pass
if self.macroStatusAttr is None:
self.macroStatusAttr = self.door.getAttribute("State")
self.macroStatusAttr.addListener(self.objectListener)
def onDoorChanged(self, doorName):
self.setDoorName(doorName)
if self.doorName() == "":
self.doorStateLed.setModel(None)
return
self.doorStateLed.setModel(self.doorName() + "/State")
door = Device(doorName)
try:
doorState = door.state()
except TypeError:
# TODO: For Taurus 4 adaptation
doorState = door.getState()
if doorState == PyTango.DevState.ON:
self.playMacroAction.setText("Start macro")
self.playMacroAction.setToolTip("Start macro")
elif doorState == PyTango.DevState.STANDBY:
self.playMacroAction.setText("Resume macro")
self.playMacroAction.setToolTip("Resume macro")
