class BLEnergy(Device): stateEnergy = { 'ALARM': 'error', 'FAULT': 'error', 'RUNNING': 'moving', 'MOVING': 'moving', 'STANDBY': 'ready', 'UNKNOWN': 'unknown', 'DISABLE': 'disable', 'EXTRACT': 'outlimits' } 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" ) try: self.mono_mt_rx_fine_statech = self.getChannelObject( "mono_mt_rx_fine_state") self.mono_mt_rx_fine_oncmd = self.getCommandObject( "mono_mt_rx_fine_on") except KeyError: logging.info( "Beware that mt_rx control is not properly defined for BLEnergy" ) self.get_energy_limits = self.getEnergyLimits self.get_wavelength_limits = self.getWavelengthLimits # 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) self.can_move_energy = self.canMoveEnergy self.move_energy = self.startMoveEnergy self.move_wavelength = self.startMoveWavelength def stateChanged(self, value): if (str(value) == 'MOVING'): self.moveEnergyCmdStarted() if self.prev_state == 'MOVING' or self.moving == True: if str(value) != 'MOVING': self.moveEnergyCmdFinished() self.prev_state = str(value) self.emit('stateChanged', BLEnergy.stateEnergy[str(value)]) # function called during polling def energyChanged(self, value): #logging.getLogger("HWR").debug("%s: BLEnergy.energyChanged: %.3f", self.name(), value) #logging.info(">>>>>>>> %s: BLEnergy.energyChanged: %.3f", self.name(), value) wav = self.monodevice.read_attribute("lambda").value if wav is not None: self.emit('energyChanged', (value, wav)) def connectNotify(self, signal): logging.getLogger("HWR").info("%s: BLEnergy.connectNotify, : %s", self.name(), signal) if signal == 'energyChanged': self.energyChanged(self.BLEnergydevice.energy) if signal == 'stateChanged': self.stateChanged(str(self.BLEnergydevice.State())) self.setIsReady(True) # called by brick : not useful def isSpecConnected(self): logging.getLogger("HWR").debug("%s: BLEnergy.isSpecConnected", self.name()) return True def isConnected(self): logging.getLogger("HWR").debug("%s: BLEnergy.isConnected", self.name()) return True def sConnected(self): logging.getLogger("HWR").debug("%s: BLEnergy.sConnected", self.name()) self.deviceOk = True self.emit('connected', ()) def sDisconnected(self): logging.getLogger("HWR").debug("%s: BLEnergy.sDisconnected", self.name()) self.deviceOk = False self.emit('disconnected', ()) def isDisconnected(self): logging.getLogger("HWR").debug("%s: BLEnergy.isDisconnected", self.name()) return True # Definit si la beamline est a energie fixe ou variable def canMoveEnergy(self): logging.getLogger("HWR").debug("%s: BLEnergy.canMoveEnergy", self.name()) return True def getPosition(self): return self.getCurrentEnergy() def getCurrentEnergy(self): if self.deviceOk: return self.BLEnergydevice.energy else: return None def getState(self): return self.BLEnergydevice.State().name def getEnergyComputedFromCurrentGap(self): logging.getLogger("HWR").debug("%s: BLEnergy.getCurrentEnergy", self.name()) if self.deviceOk: # PL. Rq: if the device is not redy, it send a NaN... return self.U20Energydevice.energy else: return None def getCurrentUndulatorGap(self): logging.getLogger("HWR").debug("%s: BLEnergy.getCurrentEnergy", self.name()) if self.deviceOk: return self.U20Energydevice.gap else: return None def getCurrentWavelength(self): logging.getLogger("HWR").debug("%s: BLEnergy.getCurrentWavelength", self.name()) # Pb with the attribute name "lamdda" which is a keyword for python if self.deviceOk: # using calculation of the device mono return self.monodevice.read_attribute("lambda").value else: return None def getEnergyLimits(self): logging.getLogger("HWR").debug("%s: BLEnergy.getEnergyLimits", self.name()) if self.deviceOk: # limits defined in tango enconfig = self.BLEnergydevice.get_attribute_config("energy") max = float(enconfig.max_value) min = float(enconfig.min_value) lims = (min, max) logging.getLogger("HWR").info("HOS : energy Limits: %.4f %.4f" % lims) return lims else: return None def getWavelengthLimits(self): logging.getLogger("HWR").debug("%s: BLEnergy.getWavelengthLimits", self.name()) if self.deviceOk: lims = [] # Recuperation des limites en energie energylims = self.getEnergyLimits() # Conversion de la limite inferieure en wavelength superieure (Utilisation des fonctions de conversion du device mono) self.monodevice.simEnergy = energylims[1] lims.append(self.monodevice.simLambda) # Conversion de la limite superieure en wavelength inferieure (Utilisation des fonctions de conversion du device mono) self.monodevice.simEnergy = energylims[0] lims.append(self.monodevice.simLambda) # logging.getLogger("HWR").info("HOS : wavelength Limits: %.4f %.4f" % lims) logging.getLogger("HWR").info("HOS : wavelength Limits: %s" % lims) return lims else: return None def startMoveEnergy(self, value, wait=False): logging.getLogger("HWR").debug("%s: BLEnergy.startMoveEnergy: %.3f", self.name(), float(value)) # MODIFICATION DE CETTE FONCTION POUR COMPENSER LE PROBLEME D'HYSTERESIS DE L"ONDULEUR # PAR CETTE METHODE ON APPLIQUE TOUJOURS UN GAP CROISSANT backlash = 0.1 # en mm gaplimite = 5.5 # en mm if self.mono_mt_rx_statech is not None and self.mono_mt_rx_oncmd is not None: while str(self.mono_mt_rx_statech.getValue()) == 'OFF': logging.getLogger("HWR").info( "BLEnergy : turning mono1-mt_rx on") self.mono_mt_rx_oncmd() time.sleep(0.2) if self.mono_mt_rx_fine_statech is not None and self.mono_mt_rx_fine_oncmd is not None: while str(self.mono_mt_rx_fine_statech.getValue()) == 'OFF': logging.getLogger("HWR").info( "BLEnergy : turning mono1-mt_rx_fine on") self.mono_mt_rx_fine_oncmd() time.sleep(0.2) if (str(self.BLEnergydevice.State()) != "MOVING" and self.deviceOk): if self.doBacklashCompensation: try: # Recuperation de la valeur de gap correspondant a l'energie souhaitee self.U20Energydevice.autoApplyComputedParameters = False self.U20Energydevice.energy = value newgap = self.U20Energydevice.computedGap actualgap = self.U20Energydevice.gap self.U20Energydevice.autoApplyComputedParameters = True # On applique le backlash que si on doit descendre en gap if newgap < actualgap + backlash: # Envoi a un gap juste en dessous (backlash) if newgap - backlash > gaplimite: self.U20Energydevice.gap = newgap - backlash else: self.U20Energydevice.gap = gaplimite self.U20Energydevice.gap = newgap + backlash time.sleep(1) except: logging.getLogger("HWR").error( "%s: Cannot move undulator U20 : State device = %s", self.name(), str(self.U20Energydevice.State())) try: # Envoi a l'energie desiree self.BLEnergydevice.energy = value except: logging.getLogger("HWR").error( "%s: Cannot move BLEnergy : State device = %s", self.name(), str(self.BLEnergydevice.State())) else: statusBLEnergydevice = self.BLEnergydevice.Status() logging.getLogger("HWR").error( "%s: Cannot move : State device = %s", self.name(), str(self.BLEnergydevice.State())) for i in statusBLEnergydevice.split("\n"): logging.getLogger().error("\t%s\n" % i) logging.getLogger().error("\tCheck devices") def startMoveWavelength(self, value, wait=False): logging.getLogger("HWR").debug( "%s: BLEnergy.startMoveWavelength: %.3f", self.name(), value) self.monodevice.simLambda = value self.startMoveEnergy(self.monodevice.simEnergy) # return self.startMoveEnergy(energy_val) def cancelMoveEnergy(self): logging.getLogger("HWR").debug("%s: BLEnergy.cancelMoveEnergy", self.name()) self.BLEnergydevice.Stop() self.moving = False def energyLimitsChanged(self, limits): logging.getLogger("HWR").debug( "%s: BLEnergy.energyLimitsChanged: %.3f", self.name(), value) self.monodevice.simEnergy = limits[0] wav_limits.append[self.monodevice.simLambda] self.monodevice.simEnergy = limits[1] wav_limits.append[self.monodevice.simLambda] self.emit('energyLimitsChanged', (limits, )) if wav_limits[0] != None and wav_limits[1] != None: self.emit('wavelengthLimitsChanged', (wav_limits, )) else: self.emit('wavelengthLimitsChanged', (None, )) def moveEnergyCmdReady(self): logging.getLogger("HWR").debug("%s: BLEnergy.moveEnergyCmdReady", self.name()) if not self.moving: self.emit('moveEnergyReady', (True, )) def moveEnergyCmdNotReady(self): logging.getLogger("HWR").debug("%s: BLEnergy.moveEnergyCmdNotReady", self.name()) if not self.moving: self.emit('moveEnergyReady', (False, )) def moveEnergyCmdStarted(self): logging.getLogger("HWR").debug("%s: BLEnergy.moveEnergyCmdStarted", self.name()) self.moving = True #self.emit('moveEnergyStarted',(BLEnergy.stateEnergy[str(self.BLEnergydevice.State())])) self.emit('moveEnergyStarted', ()) def moveEnergyCmdFailed(self): logging.getLogger("HWR").debug("%s: BLEnergy.moveEnergyCmdFailed", self.name()) self.moving = False self.emit('moveEnergyFailed', ()) def moveEnergyCmdAborted(self): self.moving = False logging.getLogger("HWR").debug("%s: BLEnergy.moveEnergyCmdAborted", self.name()) def moveEnergyCmdFinished(self): logging.getLogger("HWR").debug("%s: BLEnergy.moveEnergyCmdFinished", self.name()) self.moving = False print 'moveEnergyFinished' #self.emit('moveEnergyFinished',(BLEnergy.stateEnergy[str(self.BLEnergydevice.State())])) self.emit('moveEnergyFinished', ()) def getPreviousResolution(self): logging.getLogger("HWR").debug("%s: BLEnergy.getPreviousResolution", self.name()) return (None, None) def restoreResolution(self): logging.getLogger("HWR").debug("%s: BLEnergy.restoreResolution", self.name()) return (False, "Resolution motor not defined") 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()
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
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 TangoResolution(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, "1": 1, "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 = 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 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) self.emit('positionChanged', (res, )) def getState(self): return TangoResolution.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() 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(TangoResolution.stateDict[self.device.State]) elif signal == 'positionChanged': self.positionChanged(self.device.position) def stateChanged(self, state): self.emit('stateChanged', (TangoResolution.stateDict[str(state)], )) def getLimits(self, callback=None, error_callback=None): positionChan = self.getChannelObject("position") info = positionChan.getInfo() high = float(info.max_value) low = float(info.min_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") rhigh = self.dist2res(low) rlow = self.dist2res(high) #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,