def ConfigureCapability(self, argin):
# PROTECTED REGION ID(SKASubarray.ConfigureCapability) ENABLED START #
command_name = 'ConfigureCapability'
dp = DeviceProxy(self.get_name())
obstate_labels = list(dp.attribute_query('obsState').enum_labels)
obs_configuring = obstate_labels.index('CONFIGURING')
capabilities_instances, capability_types = argin
self._validate_capability_types(command_name, capability_types)
self._validate_input_sizes(command_name, argin)
# Set obsState to 'CONFIGURING'.
self._obs_state = obs_configuring
# Perform the configuration.
for capability_instances, capability_type in izip(
capabilities_instances, capability_types):
self._configured_capabilities[capability_type] += capability_instances
# Change the obsState to 'READY'.
obs_ready = obstate_labels.index('READY')
self._obs_state = obs_ready
class TangoMotorZoomPX2(Device):
stateDict = {
"UNKNOWN": 0,
"ALARM": 1,
"FAULT": 1,
"STANDBY": 2,
"RUNNING": 4,
"MOVING": 4,
"ON": 2,
'2': 2}
def __init__(self, name):
Device.__init__(self, name)
self.GUIstep = 0.1
def _init(self):
self.MOVESTARTED = 0
self.NOTINITIALIZED = 0
self.UNUSABLE = 0
self.READY = 2
self.MOVING = 4
self.ONLIMIT = 1
#self.device = SimpleDevice(self.getProperty("tangoname"), verbose=False)
#self.device.timeout = 6000 # Setting timeout to 6 sec
self.device = DeviceProxy(self.getProperty("tangoname"))
self.device.waitMoves = False
logging.getLogger("HWR").info("TangoMotorZoomPX2._init of device %s" % self.device.name)
self.setIsReady(True)
print "TangoMotorZoomPX2._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)
#focus_positionChan = self.getChannelObject("focus_position")
#focus_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)
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2._init, %s", self.name(), '')
def positionChanged(self, value):
try:
logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.positionChanged: %.3f", self.name(), value)
except:
logging.getLogger("HWR").error("%s: TangoMotor not responding, %s", self.name(), '')
self.emit('positionChanged', (value,))
def isReady(self):
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.isReady", self.name())
return str(self.device.State()) == 'STANDBY'
def connectNotify(self, signal):
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.connectNotify, : %s", self.name(), signal)
if signal == 'hardwareObjectName,stateChanged':
self.motorStateChanged(TangoMotorZoomPX2.stateDict[str(self.device.State())])
elif signal == 'limitsChanged':
self.motorLimitsChanged()
#print "Not implemented yet."PhiTableXAxisPosition
elif signal == 'positionChanged':
#self.motorPositionChanged(self.device.position)
print 'MS debug 18.10.2012'
#print self.device
print self.device.read_attribute("ZoomLevel").value
self.motorPositionChanged(self.device.read_attribute("ZoomLevel").value) #MS debug 18.10.2012
self.setIsReady(True)
def motorState(self):
return TangoMotorZoomPX2.stateDict[str(self.device.State())]
def motorStateChanged(self, state):
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.motorStateChanged, %s", self.name(), state)
#self.setIsReady(state == 'STANDBY')
self.setIsReady(True)
#print "motorStateChanged", str(state)
self.emit('stateChanged', (TangoMotorZoomPX2.stateDict[str(self.device.State())], ))
def getState(self):
state = str(self.device.State())
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.getState, %s", self.name(), state)
return TangoMotorZoomPX2.stateDict[str(self.device.State())]
def getLimits(self):
#limits = self.device.getLimits("positiopositionChan.connectSignal("update", self.positionChanged)n")
# MS 18.09.2012 adapted for use without SimpleDevice
position_info = self.device.attribute_query("ZoomLevel")
rlow = 1 # position_info.min_value
rhigh = 10 #position_info.max_value
#logging.getLogger("HWR").info("TangoMotorZoomPX2.getLimits: %.4f %.4f" % limits)
return rlow, rhigh
def motorLimitsChanged(self):
#self.emit('limitsChanged', (self.getLimits(), ))
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.limitsChanged", self.name())
self.emit('limitsChanged', (self.getLimits(), ))
def motorMoveDone(self, channelValue):
#SpecMotorA.motorMoveDone(self, channelValue)
#logging.getLogger("HWR").info("TangoMotorZoomPX2.motorMoveDone")
if str(self.device.State()) == 'STANDBY':
#self.emit('moveDone', (self.specversion, self.specname, ))
self.emit('moveDone', ("EH3","toto" ))
def motorPositionChanged(self, absolutePosition):
self.emit('positionChanged', (absolutePosition, ))
def syncQuestionAnswer(self, specSteps, controllerSteps):
return '0' #NO ('1' means YES)
def getPosition(self):
pos = self.device.read_attribute("ZoomLevel").value #self.device.position
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.getPosition, pos = %.3f", self.name(), pos)
return pos
def syncMove(self, position):
#print 'about to start moving', self.motorState
t0 = time.time()
prev_position = self.getPosition()
self.device.position = position
print 'move started from %s to %s, state is %s' % (prev_position, position, str(self.device.State()))
while str(self.device.State()) == "RUNNING" or str(self.device.State()) == "MOVING": # or str(self.device.State()) == SpecMotor.MOVESTARTED:
#print 'processing events...', self.motorState
qApp.processEvents(100)
print 'move done (%s s), state is %s' % (time.time()-t0, str(self.device.State()))
def moveRelative(self, position):
old_pos = self.device.position
self.device.position = old_pos + position
#self.moveRelahardwareObjectName,tive(position)
while str(self.device.State()) == "RUNNING" or str(self.device.State()) == "MOVING":
qApp.processEvents(100)
def syncMoveRelative(self, position):
old_pos = self.device.position
self.device.position = old_pos + position
#self.moveRelahardwareObjectName,tive(position)
while str(self.device.State()) == "RUNNING" or str(self.device.State()) == "MOVING":
qApp.processEvents(100)
def getMotorMnemonic(self):
return self.specName
def move(self, absolutePosition):
"""Move the motor to the required position
Arguments:
absolutePosition -- position to move to
"""
if type(absolutePosition) != float and type(absolutePosition) != int:
logging.getLogger("TangoClient").error("Cannot move %s: position '%s' is not a number", self.device.name, absolutePosition)
#self.__changeMotorState(MOVESTARTED)
#c = self.connection.getChannel(self.chanNamePrefix % 'start_one')
logging.getLogger("HWR").info("TangoMotorZoomPX2.move to absolute position: %.3f" % absolutePosition)
self.device.position = absolutePosition
def stop(self):
logging.getLogger("HWR").info("TangoMotorZoomPX2.stop")
self.device.Stop()
def isSpecConnected(self):
logging.getLogger().debug("%s: TangoMotorZoomPX2.isSpecConnected()" % self.name())
return TruehardwareObjectName,
class TangoResolutionComplex(BaseHardwareObjects.Equipment):
# resoState = {
# None: 'unknown',
# 'UNKNOWN': 'unknown',
# 'CLOSE': 'closed',
# 'OPEN': 'opened',
# 'MOVING': 'moving',
# 'FAULT': 'fault',
# 'DISABLE': 'disabled',
# 'OFF': 'fault',
# 'ON': 'unknown'
# }
stateDict = {
"UNKNOWN": 0,
"OFF": 1,
"ALARM": 1,
"STANDBY": 2,
"RUNNING": 4,
"MOVING": 4,
"2": 2,
"1": 1}
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 = SimpleDevice(self.getProperty("tangoname"), waitMoves = False, verbose=False)
self.device = DeviceProxy(self.getProperty("tangoname"))
#self.device.timeout = 3000 # Setting timeout to 3 sec
#self.monodevice = SimpleDevice(self.getProperty("tangoname2"), waitMoves = False, verbose=False)
hobj = self.getProperty("BLEnergy")
logging.getLogger("HWR").debug('TangoResolution: load specify the %s hardware object' % hobj)
self.blenergyHO = None
if hobj is not None:
try:
self.blenergyHO=HardwareRepository.HardwareRepository().getHardwareObject(hobj)
except:
logging.getLogger("HWR").error('TangoResolutionComplex: BLEnergy is not defined in resolution equipment %s', str(self.name()))
if self.blenergyHO is not None:
#self.connect(self.blenergyHO, "energyChanged",self.energyChanged)
self.blenergyHO.connect("energyChanged",self.energyChanged)
else:
logging.info('TANGORESOLUTION : BLENERGY is not defined in TangoResolution equipment %s', str(self.name()))
#self.connect(self.blenergyHO,, "energyChanged",self.energyChanged)
#self.connect(self.beam_info_hwobj,
# "beamPosChanged",
# self.beam_position_changed)
#self.blenergyHO.connectSignal('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 init(self):
#self.detm = self.getDeviceByRole("detm")
#self.dtox = self.getDeviceByRole("dtox")
#self.dist2res = self.getCommandObject("dist2res")
#self.res2dist = self.getCommandObject("res2dist")
self.__resLimitsCallback = None
self.__resLimitsErrCallback = None
self.__resLimits = {}
#self.connect(self.device, "stateChanged", self.detmStateChanged)
#self.dist2res.connectSignal("commandReplyArrived", self.newResolution)
#self.res2dist.connectSignal("commandReplyArrived", self.newDistance)
def positionChanged(self, value):
res = self.dist2res(value)
try:
logging.getLogger("HWR").debug("%s: TangoResolution.positionChanged: %.3f", self.name(), res)
except:
logging.getLogger("HWR").error("%s: TangoResolution not responding, %s", self.name(), '')
self.emit('positionChanged', (res,))
def getState(self):
return TangoResolutionComplex.stateDict[str(self.device.State())]
def equipmentReady(self):
self.emit("deviceReady")
def equipmentNotReady(self):
self.emit("deviceNotReady")
def get_value(self):
return self.getPosition()
def getPosition(self):
#if self.currentResolution is None:
self.recalculateResolution()
return self.currentResolution
def energyChanged(self, energy,wave=None):
#logging.getLogger("HWR").debug(" %s energychanged : %.3f wave is %.3f", self.name(), energy,wave)
if self.currentEnergy is None:
self.currentEnergy = energy
if type(energy) is not float:
logging.getLogger("HWR").error("%s: TangoResolution Energy not a float: %s", energy, '')
return
if abs(self.currentEnergy - energy) > 0.0002:
self.currentEnergy = energy # self.blenergyHO.getCurrentEnergy()
self.wavelengthChanged(self.blenergyHO.getCurrentWavelength())
def wavelengthChanged(self, wavelength):
self.currentWavelength = wavelength
self.recalculateResolution()
def recalculateResolution(self):
self.currentDistance = self.device.position
self.currentResolution = self.dist2res(self.currentDistance)
if self.currentResolution is None:
return
self.newResolution(self.currentResolution)
def newResolution(self, res):
if self.currentResolution is None:
self.currentResolution = self.recalculateResolution()
logging.getLogger().info("new resolution = %.3f" % res)
self.currentResolution = res
self.emit("positionChanged", (res, ))
def connectNotify(self, signal):
#logging.getLogger("HWR").debug("%s: TangoResolution.connectNotify, : %s", \
# self.name(), signal)
if signal == "stateChanged":
self.stateChanged(self.getState())
#elif signal == 'limitsChanged':
# self.motorLimitsChanged()
elif signal == 'positionChanged':
self.positionChanged(self.device.position)
# self.setIsReady(True)
def stateChanged(self, state):
#logging.getLogger("HWR").debug("%s: TangoResolution.stateChanged: %s"\
# % (self.name(), state))
try:
self.emit('stateChanged', (TangoResolutionComplex.stateDict[str(state)], ))
except KeyError:
self.emit('stateChanged', (TangoResolutionComplex.stateDict['UNKNOWN'], )) #ms 2015-03-26 trying to get rid of the fatal error with connection to detector ts motor
def getLimits(self, callback=None, error_callback=None):
#low, high = self.device.getLimits("position")
# MS 18.09.2012 adapted for use without SimpleDevice
position_info = self.device.attribute_query("position")
low = float(position_info.min_value)
high = float(position_info.max_value)
logging.getLogger("HWR").debug("%s: DetectorDistance.getLimits: [%.2f - %.2f]"\
% (self.name(), low, high))
if callable(callback):
self.__resLimitsCallback = callback
self.__resLimitsErrCallback = error_callback
self.__resLimits = {}
rlow = self.dist2res(low, callback=self.__resLowLimitCallback, \
error_callback=self.__resLimitsErrCallback)
rhigh = self.dist2res(high, callback=self.__resHighLimitCallback,\
error_callback=self.__resLimitsErrCallback)
else:
#rlow, rhigh = map(self.dist2res, self.device.getLimits("position"))
# MS 18.09.2012 adapted for use without SimpleDevice
#rhigh = self.device.attribute_query("positon").max_value
rlow = self.dist2res(low)
rhigh = self.dist2res(high)
#position_info = self.device.attribute_query("position")
#rlow = float(position_info.min_value)
#rhigh = float(position_info.max_value)
logging.getLogger("HWR").debug("%s: TangoResolution.getLimits: [%.3f - %.3f]"\
% (self.name(), rlow, rhigh))
return (rlow, rhigh)
def isSpecConnected(self):
#logging.getLogger().debug("%s: TangoResolution.isSpecConnected()" % self.name())
return True
def __resLowLimitCallback(self, rlow):
self.__resLimits["low"]=float(rlow)
if len(self.__resLimits) == 2:
if callable(self.__resLimitsCallback):
self.__resLimitsCallback((self.__resLimits["low"], self.__resLimits["high"]))
self.__resLimitsCallback = None
self.__dist2resA1 = None
self.__dist2resA2 = None
def __resHighLimitCallback(self, rhigh):
self.__resLimits["high"]=float(rhigh)
if len(self.__resLimits) == 2:
if callable(self.__resLimitsCallback):
self.__resLimitsCallback((self.__resLimits["low"], self.__resLimits["high"]))
self.__resLimitsCallback = None
self.__dist2resA1 = None
self.__dist2resA2 = None
def __resLimitsErrCallback(self):
if callable(self.__resLimitsErrCallback):
self.__resLimitsErrCallback()
self.__resLimitsErrCallback = None
self.__dist2resA1 = None
self.__dist2resA2 = None
def move(self, res, mindist=114, maxdist=1000):
self.currentWavelength = self.blenergyHO.getCurrentWavelength()
distance = self.res2dist(res)
if distance >= mindist and distance <= maxdist:
self.device.position = distance
elif distance < mindist:
logging.getLogger("user_level_log").warning("TangoResolution: requested resolution is above limit for specified energy, moving to maximum allowed resolution")
self.device.position = mindist
elif distance > maxdist:
logging.getLogger("user_level_log").warning("TangoResolution: requested resolution is below limit for specified energy, moving to minimum allowed resolution")
self.device.position = maxdist
def newDistance(self, dist):
self.device.position = dist
def motorIsMoving(self):
return self.device.state().name in ['MOVING', 'RUNNING']
def stop(self):
try:
self.device.Stop()
except:
logging.getLogger("HWR").err("%s: TangoResolution.stop: error while trying to stop!", self.name())
pass
def dist2res(self, Distance, callback=None, error_callback=None):
#Distance = float(Distance)# MS 2015-03-26 moving statement inside try loop
try:
Distance = float(Distance)
#Wavelength = self.monodevice._SimpleDevice__DevProxy.read_attribute("lambda").value
if self.currentWavelength is None:
self.currentWavelength = self.blenergyHO.getCurrentWavelength()
thetaangle2 = math.atan(DETECTOR_DIAMETER/2./Distance)
Resolution = 0.5*self.currentWavelength /math.sin(thetaangle2/2.)
if callable(callback):
callback(Resolution)
return Resolution
except:
if callable(error_callback):
error_callback()
def dist2resWaveLenght(self,wavelength, Distance, callback=None, error_callback=None):
#Distance = float(Distance)# MS 2015-03-26 moving statement inside try loop
try:
#Distance = Distance
#Wavelength = self.monodevice._SimpleDevice__DevProxy.read_attribute("lambda").value
thetaangle2 = math.atan(DETECTOR_DIAMETER/2./Distance)
Resolution = 0.5*wavelength /math.sin(thetaangle2/2.)
if callable(callback):
callback(Resolution)
return Resolution
except:
if callable(error_callback):
error_callback()
def res2dist(self, Resolution):
#print "********* In res2dist with ", Resolution
Resolution = float(Resolution)
#Wavelength = self.monodevice._SimpleDevice__DevProxy.read_attribute("lambda").value
if self.currentWavelength is None:
self.currentWavelength = self.blenergyHO.getCurrentWavelength()
thetaangle=math.asin(self.currentWavelength / 2. / Resolution)
Distance=DETECTOR_DIAMETER/2./math.tan(2.*thetaangle)
#print "********* Distance ", Distance
return Distance
def _is_command_allowed(self, command_name):
"""Determine whether the command specified by the command_name parameter should
be allowed to execute or not.
Parameters
----------
command_name: str
The name of the command which is to be executed.
Returns
-------
True or False: boolean
A True is returned when the device is in the allowed states and modes to
execute the command. Returns False if the command name is not in the list of
commands with rules specified for them.
Raises
------
PyTango.DevFailed: If the device is not in the allowed states and/modes to
execute the command.
"""
dp = DeviceProxy(self.get_name())
obstate_labels = list(dp.attribute_query('obsState').enum_labels)
obs_idle = obstate_labels.index('IDLE')
obs_ready = obstate_labels.index('READY')
admin_labels = list(dp.attribute_query('adminMode').enum_labels)
admin_online = admin_labels.index('ON-LINE')
admin_maintenance = admin_labels.index('MAINTENANCE')
admin_offline = admin_labels.index('OFF-LINE')
admin_not_fitted = admin_labels.index('NOT-FITTED')
current_admin_mode = self.read_adminMode()
if command_name in ["ReleaseResources", "AssignResources"]:
if current_admin_mode in [admin_offline, admin_not_fitted]:
Except.throw_exception("Command failed!", "Subarray adminMode is"
" 'OFF-LINE' or 'NOT-FITTED'.",
command_name, ErrSeverity.ERR)
if self.read_obsState() == obs_idle:
if current_admin_mode in [admin_online, admin_maintenance]:
return True
else:
Except.throw_exception("Command failed!", "Subarray adminMode not"
"'ON-LINE' or not in 'MAINTENANCE'.",
command_name, ErrSeverity.ERR)
else:
Except.throw_exception("Command failed!", "Subarray obsState not 'IDLE'.",
command_name, ErrSeverity.ERR)
elif command_name in ['ConfigureCapability', 'DeconfigureCapability',
'DeconfigureAllCapabilities']:
if self.get_state() == DevState.ON and self.read_adminMode() == admin_online:
if self.read_obsState() in [obs_idle, obs_ready]:
return True
else:
Except.throw_exception(
"Command failed!", "Subarray obsState not 'IDLE' or 'READY'.",
command_name, ErrSeverity.ERR)
else:
Except.throw_exception(
"Command failed!", "Subarray State not 'ON' and/or adminMode not"
" 'ON-LINE'.", command_name, ErrSeverity.ERR)
return False
class TangoMotor3(Device):
stateDict = {
"UNKNOWN": 0,
"ALARM": 1,
"FAULT": 1,
"STANDBY": 2,
"RUNNING": 4,
"MOVING": 4,
"ON": 2,
'2': 2}
def __init__(self, name):
Device.__init__(self, name)
self.GUIstep = 0.1
def _init(self):
self.MOVESTARTED = 0
self.NOTINITIALIZED = 0
self.UNUSABLE = 0
self.READY = 2
self.MOVING = 4
self.ONLIMITS = 1
self.device = DeviceProxy(self.getProperty("tangoname"))
self.device.waitMoves = False
self.setIsReady(True)
print("TangoMotor._init of device %s" % self.device.name)
self.positionChan = self.getChannelObject("attributeName") # utile seulement si statechan n'est pas defini dans le code
self.positionChan.connectSignal("update", self.positionChanged)
self.stateChan = self.getChannelObject("state") # utile seulement si statechan n'est pas defini dans le code
self.stateChan.connectSignal("update", self.stateChanged)
#
# logging.getLogger("HWR").info("%s: TangoMotor._init, %s", self.name(), '')
def positionChanged(self, value):
try:
logging.getLogger("HWR").info("%s: TangoMotor.positionChanged: %.3f", self.name(), value)
except:
logging.getLogger("HWR").error("%s: TangoMotor not responding, %s", self.name(), '')
self.emit('positionChanged', (value,))
def isReady(self):
#logging.getLogger("HWR").info("%s: TangoMotor.isReady", self.name())
return self.motorState() == TangoMotor3.stateDict["STANDBY"]
def connectNotify(self, signal):
#logging.getLogger("HWR").info("%s: TangoMotor.connectNotify, : %s", \
# self.name(), signal)
if signal == 'hardwareObjectName,stateChanged':
self.motorStateChanged(self.motorState())
elif signal == 'limitsChanged':
self.motorLimitsChanged()
#print "Not implemented yet."
elif signal == 'positionChanged':
self.motorPositionChanged(self.positionChan.getValue())
self.setIsReady(True)
def motorState(self):
return self.getState()
def stateChanged(self, state):
logging.getLogger("HWR").info("State Changed, %s / %s" % (self.name(), str(state)))
self.motorStateChanged(state)
def motorStateChanged(self, state):
logging.getLogger("HWR").info("%s: TangoMotor.motorStateChanged, %s", self.name(), state)
#self.setIsReady(state == 'STANDBY')
self.setIsReady(True)
print("motorStateChanged", str(state),self.motorState())
self.emit('stateChanged', (self.motorState(), ))
def getState(self):
state = str(self.device.State())
#logging.getLogger("HWR").info("%s: TangoMotor.getState, %s", self.name(), state)
#return self.motorState()
return TangoMotor3.stateDict[ state ]
def getLimits(self):
#limits = self.device.getLimits(str(self.positionChan.attributeName))
try:
atprops = self.device.attribute_query(str(self.positionChan.attributeName))
limits = list(map(float, [atprops.min_value, atprops.max_value]))
logging.getLogger("HWR").info("TangoMotor3 getLimits returning %.4f %.4f" % (limits[0], limits[1]))
return limits
except IndexError:
logging.getLogger("HWR").info("TangoMotor3 cannot getLimits returning -1,1" )
return (-1,1)
def motorLimitsChanged(self):
#self.emit('limitsChanged', (self.getLimits(), ))
#logging.getLogger("HWR").info("%s: TangoMotor.limitsChanged", self.name())
self.emit('limitsChanged', (self.getLimits(), ))
def motorMoveDone(self, channelValue):
#SpecMotorA.motorMoveDone(self, channelValue)
#logging.getLogger("HWR").info("TangoMotor.motorMoveDone")
if str(self.device.State()) == 'STANDBY':
#self.emit('moveDone', (self.specversion, self.specname, ))
self.emit('moveDone', ("EH3","toto" ))
def motorPositionChanged(self, absolutePosition):
self.motorStateChanged(self.device.State())
self.emit('positionChanged', (absolutePosition, ))
def syncQuestionAnswer(self, specSteps, controllerSteps):
return '0' #NO ('1' means YES)
def getPosition(self):
pos = self.positionChan.getValue()
#logging.getLogger("HWR").info("%s: TangoMotor.getPosition, pos = %.3f", self.name(), pos)
return pos
def syncMove(self, position):
#print 'about to start moving', self.motorState
import time; t0=time.time()
prev_position = self.getPosition()
self.positionChan.value = position
print('move started from %s to %s, state is %s' % (prev_position, position, self.getState()))
while self.getState() == "RUNNING" or self.getState() == "MOVING": # or str(self.device.State()) == SpecMotor.MOVESTARTED:
#print 'processing events...', self.motorState
qApp.processEvents(100)
print('move done (%s s), state is %s' % (time.time()-t0, str(self.device.State())))
def syncMoveRelative(self, position):
old_pos = self.positionChan.getValue()
self.positionChan.value = old_pos + position
#self.moveRelahardwareObjectName,tive(position)
while self.getState() == "RUNNING" or self.getState() == "MOVING":
qApp.processEvents(100)
def moveRelative(self, position):
old_pos = self.positionChan.getValue()
self.positionChan.value = old_pos + position
#self.moveRelahardwareObjectName,tive(position)
self.syncMove(self.positionChan.value)
def getMotorMnemonic(self):
return self.specName
def move(self, absolutePosition):
"""Move the motor to the required position
Arguments:
absolutePosition -- position to move to
"""
if type(absolutePosition) != float and type(absolutePosition) != int:
logging.getLogger("TangoClient").error("Cannot move %s: position '%s' is not a number", self.device.name, absolutePosition)
#self.__changeMotorState(MOVESTARTED)
#c = self.connection.getChannel(self.chanNamePrefix % 'start_one')
logging.getLogger("HWR").info("TangoMotor.move to absolute position: %.3f" % absolutePosition)
self.positionChan.value = absolutePosition
print(self.positionChan.value)
nom_attribut=self.positionChan.attributeName
setattr(self.device,nom_attribut,absolutePosition)
self.motorPositionChanged(absolutePosition)
def stop(self):
logging.getLogger("HWR").info("TangoMotor.stop")
self.device.Stop()
def isSpecConnected(self):
logging.getLogger().debug("%s: TangoMotor.isSpecConnected()" % self.name())
return TruehardwareObjectName,
class TangoMotor3(Device):
stateDict = {
"UNKNOWN": 0,
"ALARM": 1,
"FAULT": 1,
"STANDBY": 2,
"RUNNING": 4,
"MOVING": 4,
"ON": 2,
'2': 2}
def __init__(self, name):
Device.__init__(self, name)
self.GUIstep = 0.1
def _init(self):
self.MOVESTARTED = 0
self.NOTINITIALIZED = 0
self.UNUSABLE = 0
self.READY = 2
self.MOVING = 4
self.ONLIMITS = 1
self.device = DeviceProxy(self.getProperty("tangoname"))
self.device.waitMoves = False
self.setIsReady(True)
print "TangoMotor._init of device %s" % self.device.name
self.positionChan = self.getChannelObject("attributeName") # utile seulement si statechan n'est pas defini dans le code
self.positionChan.connectSignal("update", self.positionChanged)
self.stateChan = self.getChannelObject("state") # utile seulement si statechan n'est pas defini dans le code
self.stateChan.connectSignal("update", self.stateChanged)
#
# logging.getLogger("HWR").info("%s: TangoMotor._init, %s", self.name(), '')
def positionChanged(self, value):
try:
logging.getLogger("HWR").info("%s: TangoMotor.positionChanged: %.3f", self.name(), value)
except:
logging.getLogger("HWR").error("%s: TangoMotor not responding, %s", self.name(), '')
self.emit('positionChanged', (value,))
def isReady(self):
#logging.getLogger("HWR").info("%s: TangoMotor.isReady", self.name())
return self.motorState() == TangoMotor3.stateDict["STANDBY"]
def connectNotify(self, signal):
#logging.getLogger("HWR").info("%s: TangoMotor.connectNotify, : %s", \
# self.name(), signal)
if signal == 'hardwareObjectName,stateChanged':
self.motorStateChanged(self.motorState())
elif signal == 'limitsChanged':
self.motorLimitsChanged()
#print "Not implemented yet."
elif signal == 'positionChanged':
self.motorPositionChanged(self.positionChan.getValue())
self.setIsReady(True)
def motorState(self):
return self.getState()
def stateChanged(self, state):
logging.getLogger("HWR").info("State Changed, %s / %s" % (self.name(), str(state)))
self.motorStateChanged(state)
def motorStateChanged(self, state):
logging.getLogger("HWR").info("%s: TangoMotor.motorStateChanged, %s", self.name(), state)
#self.setIsReady(state == 'STANDBY')
self.setIsReady(True)
print "motorStateChanged", str(state),self.motorState()
self.emit('stateChanged', (self.motorState(), ))
def getState(self):
state = str(self.device.State())
#logging.getLogger("HWR").info("%s: TangoMotor.getState, %s", self.name(), state)
#return self.motorState()
return TangoMotor3.stateDict[ state ]
def getLimits(self):
#limits = self.device.getLimits(str(self.positionChan.attributeName))
try:
atprops = self.device.attribute_query(str(self.positionChan.attributeName))
limits = map(float, [atprops.min_value, atprops.max_value])
logging.getLogger("HWR").info("TangoMotor3 getLimits returning %.4f %.4f" % (limits[0], limits[1]))
return limits
except IndexError:
logging.getLogger("HWR").info("TangoMotor3 cannot getLimits returning -1,1" )
return (-1,1)
def motorLimitsChanged(self):
#self.emit('limitsChanged', (self.getLimits(), ))
#logging.getLogger("HWR").info("%s: TangoMotor.limitsChanged", self.name())
self.emit('limitsChanged', (self.getLimits(), ))
def motorMoveDone(self, channelValue):
#SpecMotorA.motorMoveDone(self, channelValue)
#logging.getLogger("HWR").info("TangoMotor.motorMoveDone")
if str(self.device.State()) == 'STANDBY':
#self.emit('moveDone', (self.specversion, self.specname, ))
self.emit('moveDone', ("EH3","toto" ))
def motorPositionChanged(self, absolutePosition):
self.motorStateChanged(self.device.State())
self.emit('positionChanged', (absolutePosition, ))
def syncQuestionAnswer(self, specSteps, controllerSteps):
return '0' #NO ('1' means YES)
def getPosition(self):
pos = self.positionChan.getValue()
#logging.getLogger("HWR").info("%s: TangoMotor.getPosition, pos = %.3f", self.name(), pos)
return pos
def syncMove(self, position):
#print 'about to start moving', self.motorState
import time; t0=time.time()
prev_position = self.getPosition()
self.positionChan.value = position
print 'move started from %s to %s, state is %s' % (prev_position, position, self.getState())
while self.getState() == "RUNNING" or self.getState() == "MOVING": # or str(self.device.State()) == SpecMotor.MOVESTARTED:
#print 'processing events...', self.motorState
qApp.processEvents(100)
print 'move done (%s s), state is %s' % (time.time()-t0, str(self.device.State()))
def syncMoveRelative(self, position):
old_pos = self.positionChan.getValue()
self.positionChan.value = old_pos + position
#self.moveRelahardwareObjectName,tive(position)
while self.getState() == "RUNNING" or self.getState() == "MOVING":
qApp.processEvents(100)
def moveRelative(self, position):
old_pos = self.positionChan.getValue()
self.positionChan.value = old_pos + position
#self.moveRelahardwareObjectName,tive(position)
self.syncMove(self.positionChan.value)
def getMotorMnemonic(self):
return self.specName
def move(self, absolutePosition):
"""Move the motor to the required position
Arguments:
absolutePosition -- position to move to
"""
if type(absolutePosition) != float and type(absolutePosition) != int:
logging.getLogger("TangoClient").error("Cannot move %s: position '%s' is not a number", self.device.name, absolutePosition)
#self.__changeMotorState(MOVESTARTED)
#c = self.connection.getChannel(self.chanNamePrefix % 'start_one')
logging.getLogger("HWR").info("TangoMotor.move to absolute position: %.3f" % absolutePosition)
self.positionChan.value = absolutePosition
print self.positionChan.value
nom_attribut=self.positionChan.attributeName
setattr(self.device,nom_attribut,absolutePosition)
self.motorPositionChanged(absolutePosition)
def stop(self):
logging.getLogger("HWR").info("TangoMotor.stop")
self.device.Stop()
def isSpecConnected(self):
logging.getLogger().debug("%s: TangoMotor.isSpecConnected()" % self.name())
return TruehardwareObjectName,
class TangoResolutionComplex(BaseHardwareObjects.Equipment):
# resoState = {
# None: 'unknown',
# 'UNKNOWN': 'unknown',
# 'CLOSE': 'closed',
# 'OPEN': 'opened',
# 'MOVING': 'moving',
# 'FAULT': 'fault',
# 'DISABLE': 'disabled',
# 'OFF': 'fault',
# 'ON': 'unknown'
# }
stateDict = {
"UNKNOWN": 0,
"ALARM": 1,
"STANDBY": 2,
"RUNNING": 4,
"MOVING": 4,
"2": 2}
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 = SimpleDevice(self.getProperty("tangoname"), waitMoves = False, verbose=False)
self.device = DeviceProxy(self.getProperty("tangoname"))
#self.device.timeout = 3000 # Setting timeout to 3 sec
#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 init(self):
#self.detm = self.getDeviceByRole("detm")
#self.dtox = self.getDeviceByRole("dtox")
#self.dist2res = self.getCommandObject("dist2res")
#self.res2dist = self.getCommandObject("res2dist")
self.__resLimitsCallback = None
self.__resLimitsErrCallback = None
self.__resLimits = {}
#self.connect(self.device, "stateChanged", self.detmStateChanged)
#self.dist2res.connectSignal("commandReplyArrived", self.newResolution)
#self.res2dist.connectSignal("commandReplyArrived", self.newDistance)
def positionChanged(self, value):
res = self.dist2res(value)
try:
logging.getLogger("HWR").debug("%s: TangoResolution.positionChanged: %.3f", self.name(), res)
except:
logging.getLogger("HWR").error("%s: TangoResolution not responding, %s", self.name(), '')
self.emit('positionChanged', (res,))
def getState(self):
return TangoResolutionComplex.stateDict[str(self.device.State())]
def equipmentReady(self):
self.emit("deviceReady")
def equipmentNotReady(self):
self.emit("deviceNotReady")
def getPosition(self):
if self.currentResolution is None:
self.recalculateResolution()
return self.currentResolution
def energyChanged(self, energy):
if self.currentEnergy is None:
self.currentEnergy = energy
if type(energy) is not float:
logging.getLogger("HWR").error("%s: TangoResolution Energy not a float: %s", energy, '')
return
if abs(self.currentEnergy - energy) > 0.0002:
self.currentEnergy = energy # self.blenergyHO.getCurrentEnergy()
self.wavelengthChanged(self.blenergyHO.getCurrentWavelength())
def wavelengthChanged(self, wavelength):
self.currentWavelength = wavelength
self.recalculateResolution()
def recalculateResolution(self):
self.currentDistance = self.device.position
self.currentResolution = self.dist2res(self.currentDistance)
if self.currentResolution is None:
return
self.newResolution(self.currentResolution)
def newResolution(self, res):
if self.currentResolution is None:
self.currentResolution = self.recalculateResolution()
logging.getLogger().info("new resolution = %.3f" % res)
self.currentResolution = res
self.emit("positionChanged", (res, ))
def connectNotify(self, signal):
#logging.getLogger("HWR").debug("%s: TangoResolution.connectNotify, : %s", \
# self.name(), signal)
if signal == "stateChanged":
self.stateChanged(self.getState())
#elif signal == 'limitsChanged':
# self.motorLimitsChanged()
elif signal == 'positionChanged':
self.positionChanged(self.device.position)
# self.setIsReady(True)
def stateChanged(self, state):
#logging.getLogger("HWR").debug("%s: TangoResolution.stateChanged: %s"\
# % (self.name(), state))
self.emit('stateChanged', (TangoResolutionComplex.stateDict[str(state)], ))
def getLimits(self, callback=None, error_callback=None):
#low, high = self.device.getLimits("position")
# MS 18.09.2012 adapted for use without SimpleDevice
position_info = self.device.attribute_query("position")
low = float(position_info.min_value)
high = float(position_info.max_value)
logging.getLogger("HWR").debug("%s: DetectorDistance.getLimits: [%.2f - %.2f]"\
% (self.name(), low, high))
if callable(callback):
#logging.getLogger("HWR").debug("getLimits with callback: %s" % callback)
self.__resLimitsCallback = callback
self.__resLimitsErrCallback = error_callback
self.__resLimits = {}
rlow = self.dist2res(low, callback=self.__resLowLimitCallback, \
error_callback=self.__resLimitsErrCallback)
rhigh = self.dist2res(high, callback=self.__resHighLimitCallback,\
error_callback=self.__resLimitsErrCallback)
else:
#logging.getLogger("HWR").debug("getLimits with no callback")
#rlow, rhigh = map(self.dist2res, self.device.getLimits("position"))
# MS 18.09.2012 adapted for use without SimpleDevice
#rhigh = self.device.attribute_query("positon").max_value
position_info = self.device.attribute_query("position")
rlow = float(position_info.min_value)
rhigh = float(position_info.max_value)
logging.getLogger("HWR").debug("%s: TangoResolution.getLimits: [%.3f - %.3f]"\
% (self.name(), rlow, rhigh))
return (rlow, rhigh)
def isSpecConnected(self):
#logging.getLogger().debug("%s: TangoResolution.isSpecConnected()" % self.name())
return True
def __resLowLimitCallback(self, rlow):
self.__resLimits["low"]=float(rlow)
if len(self.__resLimits) == 2:
if callable(self.__resLimitsCallback):
self.__resLimitsCallback((self.__resLimits["low"], self.__resLimits["high"]))
self.__resLimitsCallback = None
self.__dist2resA1 = None
self.__dist2resA2 = None
def __resHighLimitCallback(self, rhigh):
self.__resLimits["high"]=float(rhigh)
if len(self.__resLimits) == 2:
if callable(self.__resLimitsCallback):
self.__resLimitsCallback((self.__resLimits["low"], self.__resLimits["high"]))
self.__resLimitsCallback = None
self.__dist2resA1 = None
self.__dist2resA2 = None
def __resLimitsErrCallback(self):
if callable(self.__resLimitsErrCallback):
self.__resLimitsErrCallback()
self.__resLimitsErrCallback = None
self.__dist2resA1 = None
self.__dist2resA2 = None
def move(self, res):
self.currentWavelength = self.blenergyHO.getCurrentWavelength()
self.device.position = self.res2dist(res)
def newDistance(self, dist):
self.device.position = dist
def stop(self):
try:
self.device.Stop()
except:
logging.getLogger("HWR").err("%s: TangoResolution.stop: error while trying to stop!", self.name())
pass
def dist2res(self, Distance, callback=None, error_callback=None):
Distance = float(Distance)
try:
#Wavelength = self.monodevice._SimpleDevice__DevProxy.read_attribute("lambda").value
if self.currentWavelength is None:
self.currentWavelength = self.blenergyHO.getCurrentWavelength()
thetaangle2 = math.atan(DETECTOR_DIAMETER/2./Distance)
Resolution = 0.5*self.currentWavelength /math.sin(thetaangle2/2.)
if callable(callback):
callback(Resolution)
return Resolution
except:
if callable(error_callback):
error_callback()
def res2dist(self, Resolution):
#print "********* In res2dist with ", Resolution
Resolution = float(Resolution)
#Wavelength = self.monodevice._SimpleDevice__DevProxy.read_attribute("lambda").value
if self.currentWavelength is None:
self.currentWavelength = self.blenergyHO.getCurrentWavelength()
thetaangle=math.asin(self.currentWavelength / 2. / Resolution)
Distance=DETECTOR_DIAMETER/2./math.tan(2.*thetaangle)
#print "********* Distance ", Distance
return Distance
class TangoMotorZoomPX2(Device):
stateDict = {
"UNKNOWN": 0,
"ALARM": 1,
"FAULT": 1,
"STANDBY": 2,
"RUNNING": 4,
"MOVING": 4,
"ON": 2,
'2': 2
}
def __init__(self, name):
Device.__init__(self, name)
self.GUIstep = 0.1
def _init(self):
self.MOVESTARTED = 0
self.NOTINITIALIZED = 0
self.UNUSABLE = 0
self.READY = 2
self.MOVING = 4
self.ONLIMITS = 1
#self.device = SimpleDevice(self.getProperty("tangoname"), verbose=False)
#self.device.timeout = 6000 # Setting timeout to 6 sec
self.device = DeviceProxy(self.getProperty("tangoname"))
self.device.waitMoves = False
logging.getLogger("HWR").info("TangoMotorZoomPX2._init of device %s" %
self.device.name)
self.setIsReady(True)
print("TangoMotorZoomPX2._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)
#focus_positionChan = self.getChannelObject("focus_position")
#focus_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)
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2._init, %s", self.name(), '')
def positionChanged(self, value):
try:
logging.getLogger("HWR").info(
"%s: TangoMotorZoomPX2.positionChanged: %.3f", self.name(),
value)
except:
logging.getLogger("HWR").error("%s: TangoMotor not responding, %s",
self.name(), '')
self.emit('positionChanged', (value, ))
def isReady(self):
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.isReady", self.name())
return str(self.device.State()) == 'STANDBY'
def connectNotify(self, signal):
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.connectNotify, : %s", self.name(), signal)
if signal == 'hardwareObjectName,stateChanged':
self.motorStateChanged(TangoMotorZoomPX2.stateDict[str(
self.device.State())])
elif signal == 'limitsChanged':
self.motorLimitsChanged()
#print "Not implemented yet."PhiTableXAxisPosition
elif signal == 'positionChanged':
#self.motorPositionChanged(self.device.position)
print('MS debug 18.10.2012')
#print self.device
print(self.device.read_attribute("ZoomLevel").value)
self.motorPositionChanged(
self.device.read_attribute(
"ZoomLevel").value) #MS debug 18.10.2012
self.setIsReady(True)
def motorState(self):
return TangoMotorZoomPX2.stateDict[str(self.device.State())]
def motorStateChanged(self, state):
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.motorStateChanged, %s", self.name(), state)
#self.setIsReady(state == 'STANDBY')
self.setIsReady(True)
#print "motorStateChanged", str(state)
self.emit('stateChanged',
(TangoMotorZoomPX2.stateDict[str(self.device.State())], ))
def getState(self):
state = str(self.device.State())
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.getState, %s", self.name(), state)
return TangoMotorZoomPX2.stateDict[str(self.device.State())]
def getLimits(self):
#limits = self.device.getLimits("positiopositionChan.connectSignal("update", self.positionChanged)n")
# MS 18.09.2012 adapted for use without SimpleDevice
position_info = self.device.attribute_query("ZoomLevel")
rlow = 1 # position_info.min_value
rhigh = 10 #position_info.max_value
#logging.getLogger("HWR").info("TangoMotorZoomPX2.getLimits: %.4f %.4f" % limits)
return rlow, rhigh
def motorLimitsChanged(self):
#self.emit('limitsChanged', (self.getLimits(), ))
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.limitsChanged", self.name())
self.emit('limitsChanged', (self.getLimits(), ))
def motorMoveDone(self, channelValue):
#SpecMotorA.motorMoveDone(self, channelValue)
#logging.getLogger("HWR").info("TangoMotorZoomPX2.motorMoveDone")
if str(self.device.State()) == 'STANDBY':
#self.emit('moveDone', (self.specversion, self.specname, ))
self.emit('moveDone', ("EH3", "toto"))
def motorPositionChanged(self, absolutePosition):
self.emit('positionChanged', (absolutePosition, ))
def syncQuestionAnswer(self, specSteps, controllerSteps):
return '0' #NO ('1' means YES)
def getPosition(self):
pos = self.device.read_attribute(
"ZoomLevel").value #self.device.position
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.getPosition, pos = %.3f", self.name(), pos)
return pos
def syncMove(self, position):
#print 'about to start moving', self.motorState
t0 = time.time()
prev_position = self.getPosition()
self.device.position = position
print('move started from %s to %s, state is %s' %
(prev_position, position, str(self.device.State())))
while str(self.device.State()) == "RUNNING" or str(
self.device.State()
) == "MOVING": # or str(self.device.State()) == SpecMotor.MOVESTARTED:
#print 'processing events...', self.motorState
qApp.processEvents(100)
print('move done (%s s), state is %s' %
(time.time() - t0, str(self.device.State())))
def moveRelative(self, position):
old_pos = self.device.position
self.device.position = old_pos + position
#self.moveRelahardwareObjectName,tive(position)
while str(self.device.State()) == "RUNNING" or str(
self.device.State()) == "MOVING":
qApp.processEvents(100)
def syncMoveRelative(self, position):
old_pos = self.device.position
self.device.position = old_pos + position
#self.moveRelahardwareObjectName,tive(position)
while str(self.device.State()) == "RUNNING" or str(
self.device.State()) == "MOVING":
qApp.processEvents(100)
def getMotorMnemonic(self):
return self.specName
def move(self, absolutePosition):
"""Move the motor to the required position
Arguments:
absolutePosition -- position to move to
"""
if type(absolutePosition) != float and type(absolutePosition) != int:
logging.getLogger("TangoClient").error(
"Cannot move %s: position '%s' is not a number",
self.device.name, absolutePosition)
#self.__changeMotorState(MOVESTARTED)
#c = self.connection.getChannel(self.chanNamePrefix % 'start_one')
logging.getLogger("HWR").info(
"TangoMotorZoomPX2.move to absolute position: %.3f" %
absolutePosition)
self.device.position = absolutePosition
def stop(self):
logging.getLogger("HWR").info("TangoMotorZoomPX2.stop")
self.device.Stop()
def isSpecConnected(self):
logging.getLogger().debug("%s: TangoMotorZoomPX2.isSpecConnected()" %
self.name())
return TruehardwareObjectName,
