def attenuation(self, x=None): '''Read or set the attenuation''' if self.test: return 0 from PyTango import DeviceProxy Attenuator = DeviceProxy('i11-ma-c05/ex/att.1') labels = [ '00 None', '01 Carbon 200um', '02 Carbon 250um', '03 Carbon 300um', '04 Carbon 500um', '05 Carbon 1mm', '06 Carbon 2mm', '07 Carbon 3mm', '10 Ref Fe 5um', '11 Ref Pt 5um' ] if x == None: status = Attenuator.Status() print 'status', status status = status[:status.index(':')] value = status return value NumToLabel = dict([(int(l.split()[0]), l) for l in labels]) Attenuator.write_attribute(NumToLabel[x], True) self.wait(Attenuator)
def run(self): """ Starts a process :return: """ self.debug("Starting a pytango runner ({}/{}/{})".format( self.device, self.attr, self.value)) try: d = DeviceProxy(self.device) d.ping() state = d.state() if state == DevState.FAULT: raise DevFailed d.write_attribute(self.attr, self.value) except DevFailed: self.error("Error with the pytango runner ({}/{}/{})".format( self.device, self.attr, self.value))
def attenuation(self, x=None): '''Read or set the attenuation''' if self.test: return 0 from PyTango import DeviceProxy Attenuator = DeviceProxy('i11-ma-c05/ex/att.1') labels = ['00 None', '01 Carbon 200um', '02 Carbon 250um', '03 Carbon 300um', '04 Carbon 500um', '05 Carbon 1mm', '06 Carbon 2mm', '07 Carbon 3mm', '10 Ref Fe 5um', '11 Ref Pt 5um'] if x == None: status = Attenuator.Status() print 'status', status status = status[:status.index(':')] value = status return value NumToLabel = dict([(int(l.split()[0]), l) for l in labels]) Attenuator.write_attribute(NumToLabel[x], True) self.wait(Attenuator)
def attenuation(x = None): '''Read or set the attenuation''' Attenuator = DeviceProxy('i11-ma-c05/ex/att.1') labels = [ '00 Extract', '01 Carbon 200um', '02 Carbon 250um', '03 Carbon 300um', '04 Carbon 500um', '05 Carbon 1mm', '06 Carbon 2mm', '07 Carbon 3mm', '10 Ref Fe 5um', '11 Ref Pt 5um' ] if x == None: status = Attenuator.Status() status = status[:status.index(':')] value = status return value NumToLabel = dict([(int(l.split()[0]), l) for l in labels]) Attenuator.write_attribute(NumToLabel[x], True)
class AttenuatorsPX2(Device): stateAttenuator = {'ALARM' : 0,'EXTRACT' : 1,'INSERT' : 1,'UNKNOWN' : 3, 'ALARM' : 'error','OFF' : 'error', 'RUNNING' : 'moving','MOVING' : 'moving', 'STANDBY' : 'ready', 'UNKNOWN': 'changed', 'EXTRACT': 'outlimits'} def __init__(self, name): Device.__init__(self, name) self.labels = [] self.bits = [] self.attno = 0 self.deviceOk = True self.NumToLabel = {} def init(self): #cmdToggle = self.getCommandObject('toggle') #cmdToggle.connectSignal('connected', self.connected) #cmdToggle.connectSignal('disconnected', self.disconnected) # Connect to device Attenuator defined "tangoname" in the xml file try : #self.Attenuatordevice = SimpleDevice(self.getProperty("tangoname"), verbose=False) self.Attenuatordevice = DeviceProxy(self.getProperty("tangoname")) self.Attenuatordevice.waitMoves = False self.Attenuatordevice.timeout = 5000 except : self.errorDeviceInstance(self.getProperty("tangoname")) if self.deviceOk: #self.connected() #self.chanAttState = self.getChannelObject('State') #print "self.chanAttState : ", self.chanAttState #self.chanAttState.connectSignal('update', self.attStateChanged) ##self.chanAttFactor = self.getChannelObject('appliedTransmission') ##self.chanAttFactor = self.getChannelObject('computedTransmission') ##self.chanAttFactor.connectSignal('update', self.attFactorChanged) ##self.chanAttToggle = self.getChannelObject('filtersCombination') ##self.chanAttToggle.connectSignal('update', self.attToggleChanged) #self.getAtteConfig() self.connected() self.chanAttState = self.getChannelObject('State') print "self.chanAttState : ", self.chanAttState self.chanAttState.connectSignal('update', self.attStateChanged) #self.chanAttFactor = self.getChannelObject('appliedTransmission') self.chanAttFactor = self.getChannelObject('Status') self.chanAttFactor.connectSignal('update', self.attFactorChanged) self.chanAttToggle = self.getChannelObject('State') self.chanAttToggle.connectSignal('update', self.attToggleChanged) self.getAtteConfig() logging.getLogger().debug("AttenuatorsPX2: self.labels, self.bits, self.attno, %s, %s, %s" %( self.labels, self.bits, self.attno)) def getAtteConfig(self): pass def getAtteConfig_OLD(self): logging.getLogger().debug("HOS Attenuator: passe dans getAtteConfig") self.attno = len( self['atte'] ) for att_i in range( self.attno ): obj = self['atte'][att_i] self.labels.append( obj.label ) self.bits.append( obj.bits ) self.NumToLabel = dict([(int(l.split()[0]), l) for l in self.labels]) def getAttState(self): logging.getLogger().debug("HOS Attenuator: passe dans getAttState") logging.getLogger().debug("Attenuator state read from the device %s",self.Attenuatordevice.State().name) try: #print "HEYO", self.Attenuatordevice.StatefiltersCombination print self.Attenuatordevice.Status() value= AttenuatorsPX2.stateAttenuator[self.Attenuatordevice.State().name] except: logging.getLogger("HWR").error('%s: received value on channel is not a integer value', str(self.name())) value=None return value def getAttFactor(self): logging.getLogger().debug("HOS Attenuator: passe dans getAttFactor") print 'self.Attenuatordevice.Status()', self.Attenuatordevice.Status() try: #value = float(self.Attenuatordevice.appliedTransmission) status = self.Attenuatordevice.Status() status = status[:status.index(':')] print 'status', status value = status #self.Attenuatordevice.Status() #1. #float(self.Attenuatordevice.computedTransmission) except: logging.getLogger("HWR").error('%s: received value on channel is not a float value', str(self.name())) value=None return value def connected(self): self.setIsReady(True) def disconnected(self): self.setIsReady(False) def attStateChanged(self, channelValue): logging.getLogger("HWR").debug("%s: AttenuatorsPX2.attStateChanged: %s", self.name(), channelValue) self.emit('attStateChanged', (AttenuatorsPX2.stateAttenuator[str(channelValue)], )) def attFactorChanged(self, channelValue): print 'attFactorChanged', channelValue print 'self.Attenuatordevice.Status()', self.Attenuatordevice.Status() try: status = self.Attenuatordevice.Status() status = status[:status.index(':')] print 'status', status value = status #value = float(channelValue) except: logging.getLogger("HWR").error('%s: received value on channel is not a float value', str(self.name())) else: logging.getLogger("HWR").info('%s: AttenuatorsPX2, received value on channel', str(self.name())) self.emit('attFactorChanged', (value, )) def attToggleChanged(self, channelValue): # print "Dans attToggleChanged channelValue = %s" %channelValue logging.getLogger().debug("HOS Attenuator: passe dans attToggleChanged") try: value = int(channelValue) except: logging.getLogger("HWR").error('%s: received value on channel is not a float value', str(self.name())) else: self.emit('toggleFilter', (value, )) def setTransmission(self, value) : logging.getLogger("HWR").debug("%s: AttenuatorsPX2.setTransmission: %s", self.name(), value) print value self.Attenuatordevice.write_attribute(self.NumToLabel[value], True) #.computedAttenuation = 1.0/(value/100.0) #try: #self.Attenuatordevice.write_attribute(value, True) #.computedAttenuation = 1.0/(value/100.0) #except: #logging.getLogger("HWR").error('%s: received value on channel is not valid', str(self.name())) #value=None return value def toggle(self, value) : print "Toggle value = %s" %value logging.getLogger().debug("HOS Attenuator: passe dans toggle") self.Attenuatordevice.write_attribute(value, True) # old_value = self.Attenuatordevice.filtersCombination # try: # self.Attenuatordevice.filtersCombination = old_value "sys/database/dbds1")+ (2**(value-1)) # except: # logging.getLogger("HWR").error('%s: the filter doesn\'t exist', str(self.name())) # value=None return value def errorDeviceInstance(self,device) : #db = SimpleDevice("sys/database/dbds1") db = DeviceProxy("sys/database/dbds1") logging.getLogger().error("Check Instance of Device server %s" % db.DbGetDeviceInfo(device)[1][3]) self.sDisconnected()
class AttenuatorsPX2(Device): stateAttenuator = { 'ALARM': 0, 'EXTRACT': 1, 'INSERT': 1, 'UNKNOWN': 3, 'ALARM': 'error', 'OFF': 'error', 'RUNNING': 'moving', 'MOVING': 'moving', 'STANDBY': 'ready', 'UNKNOWN': 'changed', 'EXTRACT': 'outlimits' } def __init__(self, name): Device.__init__(self, name) self.labels = [] self.bits = [] self.attno = 0 self.deviceOk = True self.NumToLabel = {} def init(self): #cmdToggle = self.getCommandObject('toggle') #cmdToggle.connectSignal('connected', self.connected) #cmdToggle.connectSignal('disconnected', self.disconnected) # Connect to device Attenuator defined "tangoname" in the xml file try: #self.Attenuatordevice = SimpleDevice(self.getProperty("tangoname"), verbose=False) self.Attenuatordevice = DeviceProxy(self.getProperty("tangoname")) self.Attenuatordevice.waitMoves = False self.Attenuatordevice.timeout = 5000 except: self.errorDeviceInstance(self.getProperty("tangoname")) if self.deviceOk: #self.connected() #self.chanAttState = self.getChannelObject('State') #print "self.chanAttState : ", self.chanAttState #self.chanAttState.connectSignal('update', self.attStateChanged) ##self.chanAttFactor = self.getChannelObject('appliedTransmission') ##self.chanAttFactor = self.getChannelObject('computedTransmission') ##self.chanAttFactor.connectSignal('update', self.attFactorChanged) ##self.chanAttToggle = self.getChannelObject('filtersCombination') ##self.chanAttToggle.connectSignal('update', self.attToggleChanged) #self.getAtteConfig() self.connected() self.chanAttState = self.getChannelObject('State') print "self.chanAttState : ", self.chanAttState self.chanAttState.connectSignal('update', self.attStateChanged) #self.chanAttFactor = self.getChannelObject('appliedTransmission') self.chanAttFactor = self.getChannelObject('Status') self.chanAttFactor.connectSignal('update', self.attFactorChanged) self.chanAttToggle = self.getChannelObject('State') self.chanAttToggle.connectSignal('update', self.attToggleChanged) self.getAtteConfig() logging.getLogger().debug( "AttenuatorsPX2: self.labels, self.bits, self.attno, %s, %s, %s" % (self.labels, self.bits, self.attno)) def getAtteConfig(self): pass def getAtteConfig_OLD(self): logging.getLogger().debug("HOS Attenuator: passe dans getAtteConfig") self.attno = len(self['atte']) for att_i in range(self.attno): obj = self['atte'][att_i] self.labels.append(obj.label) self.bits.append(obj.bits) self.NumToLabel = dict([(int(l.split()[0]), l) for l in self.labels]) def getAttState(self): logging.getLogger().debug("HOS Attenuator: passe dans getAttState") logging.getLogger().debug("Attenuator state read from the device %s", self.Attenuatordevice.State().name) try: #print "HEYO", self.Attenuatordevice.StatefiltersCombination print self.Attenuatordevice.Status() value = AttenuatorsPX2.stateAttenuator[ self.Attenuatordevice.State().name] except: logging.getLogger("HWR").error( '%s: received value on channel is not a integer value', str(self.name())) value = None return value def getAttFactor(self): logging.getLogger().debug("HOS Attenuator: passe dans getAttFactor") print 'self.Attenuatordevice.Status()', self.Attenuatordevice.Status() try: #value = float(self.Attenuatordevice.appliedTransmission) status = self.Attenuatordevice.Status() status = status[:status.index(':')] print 'status', status value = status #self.Attenuatordevice.Status() #1. #float(self.Attenuatordevice.computedTransmission) except: logging.getLogger("HWR").error( '%s: received value on channel is not a float value', str(self.name())) value = None return value def connected(self): self.setIsReady(True) def disconnected(self): self.setIsReady(False) def attStateChanged(self, channelValue): logging.getLogger("HWR").debug( "%s: AttenuatorsPX2.attStateChanged: %s", self.name(), channelValue) self.emit('attStateChanged', (AttenuatorsPX2.stateAttenuator[str(channelValue)], )) def attFactorChanged(self, channelValue): print 'attFactorChanged', channelValue print 'self.Attenuatordevice.Status()', self.Attenuatordevice.Status() try: status = self.Attenuatordevice.Status() status = status[:status.index(':')] print 'status', status value = status #value = float(channelValue) except: logging.getLogger("HWR").error( '%s: received value on channel is not a float value', str(self.name())) else: logging.getLogger("HWR").info( '%s: AttenuatorsPX2, received value on channel', str(self.name())) self.emit('attFactorChanged', (value, )) def attToggleChanged(self, channelValue): # print "Dans attToggleChanged channelValue = %s" %channelValue logging.getLogger().debug( "HOS Attenuator: passe dans attToggleChanged") try: value = int(channelValue) except: logging.getLogger("HWR").error( '%s: received value on channel is not a float value', str(self.name())) else: self.emit('toggleFilter', (value, )) def setTransmission(self, value): logging.getLogger("HWR").debug( "%s: AttenuatorsPX2.setTransmission: %s", self.name(), value) print value self.Attenuatordevice.write_attribute( self.NumToLabel[value], True) #.computedAttenuation = 1.0/(value/100.0) #try: #self.Attenuatordevice.write_attribute(value, True) #.computedAttenuation = 1.0/(value/100.0) #except: #logging.getLogger("HWR").error('%s: received value on channel is not valid', str(self.name())) #value=None return value def toggle(self, value): print "Toggle value = %s" % value logging.getLogger().debug("HOS Attenuator: passe dans toggle") self.Attenuatordevice.write_attribute(value, True) # old_value = self.Attenuatordevice.filtersCombination # try: # self.Attenuatordevice.filtersCombination = old_value "sys/database/dbds1")+ (2**(value-1)) # except: # logging.getLogger("HWR").error('%s: the filter doesn\'t exist', str(self.name())) # value=None return value def errorDeviceInstance(self, device): #db = SimpleDevice("sys/database/dbds1") db = DeviceProxy("sys/database/dbds1") logging.getLogger().error("Check Instance of Device server %s" % db.DbGetDeviceInfo(device)[1][3]) self.sDisconnected()
class _DeviceHelper(object): __CMD_FILTER = set(("init", "state", "status")) __ATTR_FILTER = set(("state", "status")) def __init__(self, dev_name, *args, **kwargs): self.dev_name = dev_name self.device = Device(dev_name, *args, **kwargs) self.slots = weakref.WeakKeyDictionary() def connect(self, signal, slot, event_type=PyTango.EventType.CHANGE_EVENT): i = self.device.subscribe_event(signal, event_type, slot) self.slots[slot] = i return i def disconnect(self, signal, slot): i = self.slots.pop(slot) self.device.unsubscribe_event(i) def get_attr_cache(self, refresh=False): try: cache = self.__attr_cache if not cache: refresh = True except AttributeError: refresh = True if refresh: cache = {} dev = self.device try: for attr_info in dev.attribute_list_query_ex(): attr_name = attr_info.name if attr_name.lower() in self.__ATTR_FILTER: continue cache[attr_name] = attr_info except PyTango.DevFailed: pass self.__attr_cache = cache return cache def get_attr_info(self, name): cache = self.get_attr_cache() result = cache.get(name) if result: return result else: cache = self.get_attr_cache(refresh=True) return cache.get(name) def get_cmd_cache(self, refresh=False): try: cache = self.__cmd_cache if not cache: refresh = True except AttributeError: refresh = True if refresh: cache = {} dev = self.device try: for cmd_info in dev.command_list_query(): cmd_name = cmd_info.cmd_name if cmd_name.lower() in self.__CMD_FILTER: continue cmd_func = functools.partial(_command, dev, cmd_info) cmd_func.__name__ = cmd_name cmd_func.__doc__ = cmd_info.in_type_desc cmd_info.func = cmd_func cache[cmd_name] = cmd_info except PyTango.DevFailed: pass self.__cmd_cache = cache return cache def get_cmd_info(self, name): cache = self.get_cmd_cache() result = cache.get(name) if result: return result else: cache = self.get_cmd_cache(refresh=True) return cache.get(name) def is_cmd(self, name): return name.lower() in self.get_cmd_cache() def members(self): result = self.get_attr_cache().keys() result.extend(self.get_cmd_cache().keys()) return result def get(self, name): dev = self.device result = self.get_attr_info(name) if result: result = dev.read_attribute(name) value = result.value if result.type == PyTango.DevEncoded: result = loads(*value) else: result = value return result result = self.get_cmd_info(name) if result is None: raise KeyError("Unknown %s" % name) return result def set(self, name, value): result = self.get_attr_info(name) if result is None: raise KeyError("Unknown attribute %s" % name) if result.data_type == PyTango.DevEncoded: self.device.write_attribute(name, dumps(value)) else: self.device.write_attribute(name, value) def get_info(self): try: return self.__info except AttributeError: pass try: info = self.device.info() self.__dict__["__info"] = info return info except PyTango.DevFailed: return None def __str__(self): return self.dstr() def __repr__(self): return str(self) def dstr(self): info = self.get_info() klass = "Device" if info: klass = info.dev_class return "{0}({1})".format(klass, self.dev_name)
def run(self, energy): if energy == -999: self.output("Usage:") self.output("me <energy>") self.output("Move energy. Diffractometer wavelength is set") return try: energyfmb_device = self.getObj("mnchrmtr") energyfmb_device_name = "mnchrmtr" except Exception: self.warning("mnchrmtr device does not exist.") self.warning("Trying to get the fmb device name from the " "EnergyFMB environment variable") try: energyfmb_device_name = self.getEnv('EnergyFMB') except Exception: self.error("EnergyFMB not defined. Macro exiting") return try: energyfmb_device = self.getObj(energyfmb_device_name) except Exception: self.error("Unable to get fmb device %s. Macro exiting" % energyfmb_device_name) return try: energy_device = self.getObj("mnchrmtr") energy_device_name = "mnchrmtr" except Exception: self.warning("mnchrmtr device does not exist.") self.warning("Trying to get the energy device name from the " "EnergyDevice environment variable") try: energy_device_name = self.getEnv('EnergyDevice') except Exception: self.error("EnergyDevice not defined. Macro exiting") return try: energy_device = self.getObj(energy_device_name) except Exception: self.error("Unable to get energy device %s. Macro exiting" % energy_device_name) return fmb_tango_device = DeviceProxy(energyfmb_device.TangoDevice) try: fmb_tango_device.write_attribute("PseudoChannelCutMode", 0) except Exception: pass flag_diffrac = 0 try: diffrac_name = self.getEnv('DiffracDevice') diffrac_device = self.getDevice(diffrac_name) initial_autoenergy = diffrac_device.read_attribute( "autoenergyupdate").value diffrac_device.write_attribute("autoenergyupdate", 0) flag_diffrac = 1 lambda_to_e = 12398.424 # Amstrong * eV wavelength = lambda_to_e / energy diffrac_device.write_attribute("wavelength", wavelength) except Exception: pass self.execMacro("mv", [[energy_device, energy]]) if flag_diffrac: diffrac_device.write_attribute("autoenergyupdate", initial_autoenergy)
class _DeviceHelper(object): __CMD_FILTER = set(("init", "state", "status")) __ATTR_FILTER = set(("state", "status")) def __init__(self, dev_name, *args, **kwargs): self.dev_name = dev_name self.device = Device(dev_name, *args, **kwargs) self.slots = weakref.WeakKeyDictionary() def connect(self, signal, slot, event_type=PyTango.EventType.CHANGE_EVENT): i = self.device.subscribe_event(signal, event_type, slot) self.slots[slot] = i return i def disconnect(self, signal, slot): i = self.slots.pop(slot) self.device.unsubscribe_event(i) def get_attr_cache(self, refresh=False): try: cache = self.__attr_cache if not cache: refresh = True except AttributeError: refresh = True if refresh: cache = {} dev = self.device try: for attr_info in dev.attribute_list_query_ex(): attr_name = attr_info.name if attr_name.lower() in self.__ATTR_FILTER: continue cache[attr_name] = attr_info except PyTango.DevFailed: pass self.__attr_cache = cache return cache def get_attr_info(self, name): cache = self.get_attr_cache() result = cache.get(name) if result: return result else: cache = self.get_attr_cache(refresh=True) return cache.get(name) def get_cmd_cache(self, refresh=False): try: cache = self.__cmd_cache if not cache: refresh = True except AttributeError: refresh = True if refresh: cache = {} dev = self.device try: for cmd_info in dev.command_list_query(): cmd_name = cmd_info.cmd_name if cmd_name.lower() in self.__CMD_FILTER: continue cmd_func = functools.partial(_command, dev, cmd_info) cmd_func.__name__ = cmd_name cmd_func.__doc__ = cmd_info.in_type_desc cmd_info.func = cmd_func cache[cmd_name] = cmd_info except PyTango.DevFailed: pass self.__cmd_cache = cache return cache def get_cmd_info(self, name): cache = self.get_cmd_cache() result = cache.get(name) if result: return result else: cache = self.get_cmd_cache(refresh=True) return cache.get(name) def is_cmd(self, name): return name.lower() in self.get_cmd_cache() def members(self): result = self.get_attr_cache().keys() result.extend(self.get_cmd_cache().keys()) return result def get(self, name): dev = self.device result = self.get_attr_info(name) if result: result = dev.read_attribute(name) value = result.value if result.type == PyTango.DevEncoded: result = loads(*value) else: result = value return result result = self.get_cmd_info(name) if result is None: raise KeyError("Unknown %s" % name) return result def set(self, name, value): result = self.get_attr_info(name) if result is None: raise KeyError("Unknown attribute %s" % name) if result.data_type == PyTango.DevEncoded: self.device.write_attribute(name, dumps(value)) else: self.device.write_attribute(name, value) def get_info(self): try: return self.__info except AttributeError: pass try: info = self.device.info() self.__dict__["__info"] = info return info except PyTango.DevFailed: return None def __str__(self): return self.dstr() def __repr__(self): return str(self) def dstr(self): info = self.get_info() klass = "Device" if info: klass = info.dev_class return "{0}({1})".format(klass, self.dev_name)
class TangoConnector(Connector): value_changed = pyqtSignal(str, name="valueChanged") def __init__(self, uri=None, attributes=[], policy=UpdatePolicy.POLLING, interval=1.0): #QThread.__init__(self) self.alive = False self.connected = False self.poll_attributes = {} self.thread = threading.Thread(target=self.run, name=uri) try: self.proxy = DeviceProxy(uri) self.connected = True except: self.attributes["state"]["value"] = State.UNKNOWN self.janus.utils["logger"].error("TangoConnector(" + self.uri + ").__init__() " + "connection failed") self.janus.utils["logger"].debug("", exc_info=True) Connector.__init__(self, uri, attributes, policy, interval) def add_attribute(self, attribute=None): Connector.add_attribute(self, attribute=attribute) if type(attribute) is not dict or "attr" not in attribute: return if "mode" in attribute and attribute["mode"] == "execute": return if "name" in attribute: name = attribute["name"] else: name = attribute["attr"].lower() self.poll_attributes[attribute["attr"]] = name def update_policy(self, policy=UpdatePolicy.POLLING, interval=1.0): self.interval = interval if policy != UpdatePolicy.POLLING and self.isRunning(): self.stop() elif policy != UpdatePolicy.EVENTBASED: for attr in self.attributes.keys(): if "event" not in self.attributes[attr]: continue try: self.proxy.unsubscribe_event( self.attributes[attr]["event"]) except: self.janus.utils["logger"].error( "TangoConnector(" + self.uri + ").update_policy() " + "failed to unsubscribe from tango event") self.janus.utils["logger"].debug("", exc_info=True) del self.attributes[attr]["event"] if policy == UpdatePolicy.POLLING and not self.thread.is_alive(): self.thread.start() elif policy == UpdatePolicy.EVENTBASED: for attr in self.attributes.keys: try: self.attributes[attr]["event"] = \ self.proxy.subscribe_event(EventType.CHANGE_EVENT, \ self.on_tango_event, [], False) except: self.janus.utils["logger"].error( "TangoConnector(" + self.uri + ").update_policy() " + "failed to subscribe to tango event") self.janus.utils["logger"].debug("", exc_info=True) self.policy = policy def on_tango_event(self, event): try: name = event.attr_name value = event.attr_value.value except: self.janus.utils["logger"].warning("TangoConnector(" + self.uri + ").on_tango_event() " + "invalid tango event type") self.janus.utils["logger"].debug("", exc_info=True) self.attributes[self.poll_attributes[name]]["value"] = value self.value_changed.emit(self.poll_attributes[name]) def stop_device(self): self.stop() def stop(self): self.alive = False self.thread.join() pass def run(self): print("thread started: {} ({})".format( threading.get_ident(), threading.currentThread().getName())) self.alive = True while self.alive: #remember when we started timestamp = time.time() #try to poll attributes try: attrs = self.proxy.read_attributes( list(self.poll_attributes.keys())) except: self.attributes["state"]["value"] = State.UNKNOWN self.janus.utils["logger"].error( "TangoConnector(" + self.uri + ").run() " + "reading tango attributes failed") self.janus.utils["logger"].debug("", exc_info=True) attrs = [] #assign attribute values and fire change signal if necessary for attr in attrs: name = self.poll_attributes[attr.name] changed = False if "delta" in self.attributes[name]: if self.attributes[name]["value"] is None or \ abs(self.attributes[name]["value"] - attr.value) > \ self.attributes[name]["delta"]: changed = True elif name == "state" and \ int(self.attributes[name]["value"]) != int(attr.value): changed = True elif name == "image_8": changed = True elif self.attributes[name]["value"] != attr.value: changed = True if changed: if name == "state": self.attributes[name]["value"] = State(int(attr.value)) else: self.attributes[name]["value"] = attr.value self.value_changed.emit(name) if not self.alive: break #wait for the rest of the polling interval interval = int((self.interval - (time.time() - timestamp))) while interval > 0: if interval > 0.05: time.sleep(0.05) interval -= 0.05 else: time.sleep(interval) interval = 0 if not self.alive: break print("closing thread: {} ({})".format( threading.get_ident(), threading.currentThread().getName())) def state(self, refresh=False): if refresh: try: self.attributes["state"]["value"] = State( int(self.proxy.state())) except: self.attributes["state"]["value"] = State.UNKNOWN self.janus.utils["logger"].error("TangoConnector(" + self.uri + ").state() " + "reading tango state failed") self.janus.utils["logger"].debug("", exc_info=True) return self.attributes["state"]["value"] def read(self, attribute=None, refresh=False, alt=None): if refresh or self.attributes[attribute]["value"] is None: try: self.attributes[attribute]["value"] = \ self.proxy.read_attribute(self.attributes[attribute]["attr"]).value except: self.janus.utils["logger"].error( "TangoConnector(" + self.uri + ")" + ".read(" + attribute + ") " + "reading tango attribute failed") self.janus.utils["logger"].debug("", exc_info=True) if self.attributes[attribute]["value"] is None \ and alt is not None: return alt return self.attributes[attribute]["value"] def write(self, attribute=None, value=None): try: self.proxy.write_attribute(self.attributes[attribute]["attr"], value) return True except: self.janus.utils["logger"].error("TangoConnector(" + self.uri + ")" + ".write(" + attribute + ") " + "writing tango attribute failed") self.janus.utils["logger"].debug("", exc_info=True) return False def execute(self, command=None, *values): try: if len(values) == 0: value = self.proxy.command_inout( self.attributes[command]["attr"]) else: value = self.proxy.command_inout( self.attributes[command]["attr"], values) except Exception as e: self.janus.utils["logger"].error("TangoConnector(" + self.uri + ")" + ".execute(" + command + ") " + "executing tango command failed") self.janus.utils["logger"].debug("", exc_info=True) return None return value