def __init__(self, model, parent=None): QWidget.__init__(self, parent) uic.loadUi("MotorWidget.ui", self) self.connect(self.configButton, SIGNAL("clicked()"), self.openConfig) self.connect(self.goButton, SIGNAL("clicked()"), self.go) self.connect(self.moveNegButton, SIGNAL("clicked()"), self.moveNeg) self.connect(self.movePosButton, SIGNAL("clicked()"), self.movePos) self.connect(self.disableButton, SIGNAL("toggled(bool)"), self.disable) self.stateLabel.setModel("%s/state" % model) self.positionLCD.setModel("%s/position" % model) self.motor = DeviceProxy(str(model)) try: self.nameLabel.setText(self.motor.alias()) except Exception: match = re.search(r"((?:[^/]+/){2}[^/]+)$", model) if not match: self.nameLabel.setText(model) else: self.nameLabel.setText(match.group(1)) pos = AttributeProxy("%s/position" % model) try: self.unitLabel.setText(pos.get_config().unit) except Exception: self.unitLabel.setText("") self.absMotionEdit.setText(str(self.motor.position))
def test_alarm_propagation(self): device_name = '%s/sub1/1' % self.DOMAIN_NAME members_template = ['%s/capability/sub1cap1', '%s/capability/sub1cap2'] members = [member % self.DOMAIN_NAME for member in members_template] self.add_members(device_name, 'tiles', members) dp = DeviceProxy(device_name) self.assertNotEqual(dp.state(), AttrQuality.ATTR_ALARM) member_dp = DeviceProxy(members[0]) alarm_data = json.dumps({ 'name': 'an_attr', 'min_alarm': '20', 'max_alarm': '50' }) member_dp.command_inout('set_attribute_alarm', alarm_data) member_dp.an_attr = 10 attr = AttributeProxy(members[0] + '/an_attr') self.assertEqual(attr.read().quality, AttrQuality.ATTR_ALARM) self.assertEqual(member_dp.state(), PyTango._PyTango.DevState.ALARM) i = 0 while (dp.state() != PyTango._PyTango.DevState.ALARM) and i < 3: sleep(1) i += 1 self.assertEqual(dp.state(), PyTango._PyTango.DevState.ALARM)
def power_on(self): motors = [] motors = motors + self.get_pool_motors('hfm_y') motors = motors + self.get_pool_motors('vfm_x1') motors = motors + self.get_pool_motors('vfm_x2') attrs = [] all_on = True for mot in motors: try: power_attr = AttributeProxy(mot.name + '/PowerOn') attrs.append(power_attr) if power_attr.read().value == False: power_attr.write(True) all_on = False except PyTango.DevFailed as e: self._log.warning( "Motor {} doesn't have a PowerOn attribute".format( mot.name)) starttime = time.time() while all_on == False: if time.time() - starttime > 2: raise PyTango.DevFailed( "Timeout while waiting for motors to power on") all_on = True time.sleep(0.1) for attr in attrs: if attr.read().value == False: all_on = False
def get_limits(attrib_name): attr_proxy = AttributeProxy(attrib_name) attr_config = attr_proxy.get_config() lower_limit = attr_config.min_value upper_limit = attr_config.max_value lower_warning = attr_config.alarms.min_warning upper_warning = attr_config.alarms.max_warning lower_alarm = attr_config.alarms.min_alarm upper_alarm = attr_config.alarms.max_alarm return [lower_limit, lower_alarm, lower_warning], [upper_limit, upper_alarm, upper_warning]
def setEncoderSource(self, axis, value): self.attributes[axis]['encoder_source'] = value self.attributes[axis]['encoder_source_tango_attribute'] = None if value == '': return try: # check if it is an internal attribute enc_src_name = 'encoder_source_tango_attribute' if value.lower().startswith('attr://'): # 2012/03/27 Improve attr:// syntax to # allow reading of other axis of the same # system without # having to access them via tango:// value_contents = value[7:] if ':' not in value_contents: self.attributes[axis][enc_src_name] = \ FakedAttributeProxy(self, axis, value) else: other_axis, other_value = \ value_contents.split(':') other_axis = int(other_axis) other_value = 'attr://' + other_value self.attributes[axis][enc_src_name] = \ FakedAttributeProxy(self, other_axis, other_value) else: self.attributes[axis][enc_src_name] = \ AttributeProxy(value) except Exception as e: self._log.error('SetAxisExtraPar(%d,%s).\nException:\n%s' % (axis, 'EncoderSource', str(e))) self.attributes[axis]['use_encoder_source'] = False
def calculate_motion(self, new_positions, items=None): user_elements = self.get_user_elements() if items is None: items = {} calculated = {} for new_position, element in zip(new_positions, user_elements): calculated[element] = new_position # TODO: get the configuration for an specific sardana class and # get rid of AttributeProxy. config = AttributeProxy(element.name + '/position').get_config() try: high = float(config.max_value) except ValueError: high = None try: low = float(config.min_value) except ValueError: low = None if high is not None: if float(new_position) > high: msg = "requested movement of %s is above its upper limit"\ % element.name raise RuntimeError(msg) if low is not None: if float(new_position) < low: msg = "requested movement of %s is below its lower limit"\ % element.name raise RuntimeError(msg) for new_position, element in zip(new_positions, user_elements): element.calculate_motion(new_position, items=items, calculated=calculated) return items
class EventsTest(Device): """ Switches beetwen valid and invalid attribute`s values. """ __metaclass__ = DeviceMeta # PROTECTED REGION ID(EventsTest.class_variable) ENABLED START # # PROTECTED REGION END # // EventsTest.class_variable # ----------------- # Device Properties # ----------------- DeviceName = device_property(dtype='str', ) # ---------- # Attributes # ---------- Max = attribute(dtype='double', ) # --------------- # General methods # --------------- def init_device(self): Device.init_device(self) # PROTECTED REGION ID(EventsTest.init_device) ENABLED START # self.set_state(DevState.ON) self.proxy = AttributeProxy(self.DeviceName) # PROTECTED REGION END # // EventsTest.init_device def always_executed_hook(self): # PROTECTED REGION ID(EventsTest.always_executed_hook) ENABLED START # pass # PROTECTED REGION END # // EventsTest.always_executed_hook def delete_device(self): # PROTECTED REGION ID(EventsTest.delete_device) ENABLED START # pass # PROTECTED REGION END # // EventsTest.delete_device # ------------------ # Attributes methods # ------------------ def read_Max(self): # PROTECTED REGION ID(EventsTest.Attribute1_read) ENABLED START # value = self.proxy.read().value maximums = [] for row in value: maximums.append(max(row)) value = max(maximums) attr_quality = AttrQuality.ATTR_ALARM self.push_change_event("Max", float(value), time(), attr_quality) self.push_archive_event("Max", float(value), time(), attr_quality) return float(value), time(), attr_quality
def test_Attributes(self): self._total = 0 for number in self._attrs: self._writes = 0 device = self._devices[number] devAttrs = [] for attrName in list(device.get_attribute_list()): attr = AttributeProxy("%s/%s" % (device.name(), attrName)) if attr.get_config().writable == AttrWriteType.READ_WRITE: devAttrs.append(attrName) otherAttrs = [] for attrName, attrDesc in self._attrs[number].iteritems(): if isinstance(attrDesc, Descriptor): if attrDesc.hasSubAttrs(): for subAttrDesc in attrDesc.subAttrs(): if subAttrDesc.writable: subAttrName = "%s_%s" % (attrName, subAttrDesc.name) self._checkAttrsLists(subAttrName, devAttrs, otherAttrs) # TODO: ignore, they will have their own test elif attrDesc.writable: self._checkAttrsLists(attrName, devAttrs, otherAttrs) self.assertAttibute(attrName, attrDesc, device) for attrName, attrDesc in self._deviceStaticAttrs().iteritems(): if isinstance(attrDesc, Descriptor) and attrDesc.writable: self._checkAttrsLists(attrName, devAttrs, otherAttrs) self.assertAttibute(attrName, attrDesc, device) self._subtotal = self._writes self._total += self._subtotal self._logger.info("plc%d: %d attributes write tested" % (number, self._subtotal)) if len(devAttrs) > 0: self._logger.warning("Unchecked device write attributes: %s" % (devAttrs)) if len(otherAttrs) > 0: self._logger.warning("Described write attributes not present: " "%s" % (otherAttrs)) self._logger.info("Total %d write attributes tested" % (self._total)) self._logger.info("Attributes write test succeed")
def init_device(self): Device.init_device(self) # PROTECTED REGION ID(EventsTest.init_device) ENABLED START # self.set_state(DevState.ON) self.proxy = AttributeProxy(self.DeviceName)
def calculate_motion(self, new_position, items=None, calculated=None): # if items already contains the positions for this pseudo motor # underlying motors it means the motion has already been calculated # by a sibling if items is not None and len(items): physical_elements = self.get_physical_elements_set() s_items = set(items) if s_items == physical_elements: if calculated is not None and self in calculated: return user_elements = self.get_user_elements() positions = self.get_siblings_positions(use=calculated, write_pos=self.drift_correction) positions[self] = new_position pseudo_positions = len(positions) * [None] for pseudo, position in positions.items(): pseudo_positions[pseudo.axis - 1] = position curr_physical_positions = self._position.get_physical_positions() physical_positions = self.controller.calc_all_physical(pseudo_positions, curr_physical_positions) if physical_positions.error: raise PoolException("Cannot calculate motion: " "calc_all_physical raises exception", exc_info=physical_positions.exc_info) else: if physical_positions.value is None: raise PoolException("Cannot calculate motion: " "calc_all_physical returns None") if items is None: items = {} positions = physical_positions.value if not hasattr(positions , "__iter__"): positions = [positions] for new_position, element in zip(positions, user_elements): if new_position is None: raise PoolException("Cannot calculate motion: %s reports " "position to be None" % element.name) # TODO: get the configuration for an specific sardana class and # get rid of AttributeProxy - see sardana-org/sardana#663 config = AttributeProxy(element.name + '/position').get_config() try: high = float(config.max_value) except ValueError: high = None try: low = float(config.min_value) except ValueError: low = None if high is not None: if float(new_position) > high: msg = "requested movement of %s is above its upper limit"\ % element.name raise RuntimeError(msg) if low is not None: if float(new_position) < low: msg = "requested movement of %s is below its lower limit"\ % element.name raise RuntimeError(msg) element.calculate_motion(new_position, items=items, calculated=calculated)