def motorMoveDone(self, channelValue): SpecMotorA.motorMoveDone(self, channelValue) # print "motor state is ready ? %s (%s)" % # ((self.getState()==SpecMotor.READY), self.getState()) if self.getState() == SpecMotor.READY: self.emit("moveDone", (self.specversion, self.specname))
def init_device(self): self.__log = logging.getLogger(self.get_name()) Device.init_device(self) self.set_change_event("State", True, True) self.set_change_event("Status", True, True) self.set_change_event("Position", True, False) self.set_change_event("StepSize", True, False) switch_state(self, DevState.INIT, "Pending connection to " + self.SpecMotor) self.__spec_motor = None self.__spec_motor_name = None self.__spec_version_name = None self.__step_size = 1 spec_info = find_spec_name(self, self.SpecMotor) if spec_info is None: return spec_version, motor = spec_info self.__spec_version_name = spec_version self.__spec_motor_name = motor cb=dict(connected=self.__motorConnected, disconnected=self.__motorDisconnected, motorPositionChanged=self.__motorPositionChanged, motorStateChanged=self.__motorStateChanged) #motorLimitsChanged=self.__motorLimitsChanged) try: self.__log.debug("Start creating Spec motor %s", motor) self.__spec_motor = SpecMotorA(callbacks=cb) except SpecClientError as spec_error: status = "Error creating Spec motor {0}".format(motor) switch_state(self, DevState.FAULT, status) else: self.__motorConnect() self.__log.debug("End creating Spec motor %s", motor)
def __init__(self, name): Device.__init__(self, name) SpecMotorA.__init__(self)
def _init(self): SpecMotorA.connectToSpec(self, self.specname, self.specversion)
class SpecMotor(Device): """A TANGO SPEC motor device based on SpecClient.""" __metaclass__ = DeviceMeta SpecMotor = device_property(dtype=str, default_value="", doc="Name of spec session and motor " "e.g. host:spec:m0. (if running " "along with a Spec it can be " "just the motor name") Position = float_rw_mem_attr(doc="motor position", unit="mm", display_unit="mm", standard_unit="mm") DialPosition = attribute(dtype=float, access=AttrWriteType.READ, doc="motor dial position", display_level=DispLevel.EXPERT) Sign = attribute(dtype=int, access=AttrWriteType.READ_WRITE, display_level=DispLevel.EXPERT, doc="motor sign") Offset = float_rw_mem_attr(display_level=DispLevel.EXPERT, doc="motor offset") AccelerationTime = float_rw_mem_attr(unit="s", display_level=DispLevel.EXPERT, doc="motor acceleration time") Backlash = float_rw_mem_attr(display_level=DispLevel.EXPERT, doc="motor backlash") #TODO: steps_per_unit, StepSize = float_rw_mem_attr(hw_memorized=True, doc="motor step size (used by " "StepDown and StepUp)") Limit_Switches = attribute(dtype=(bool,), max_dim_x=3, access=AttrWriteType.READ, display_level=DispLevel.EXPERT, doc="limit switches (home, upper, " "lower)") @property def spec_motor(self): return self.__spec_motor def get_spec_version_name(self): return self.__spec_version_name def get_spec_motor_name(self): return self.__spec_motor_name get_spec_name = get_spec_motor_name def delete_device(self): Device.delete_device(self) self.__spec_motor = None def init_device(self): self.__log = logging.getLogger(self.get_name()) Device.init_device(self) self.set_change_event("State", True, True) self.set_change_event("Status", True, True) self.set_change_event("Position", True, False) self.set_change_event("StepSize", True, False) switch_state(self, DevState.INIT, "Pending connection to " + self.SpecMotor) self.__spec_motor = None self.__spec_motor_name = None self.__spec_version_name = None self.__step_size = 1 spec_info = find_spec_name(self, self.SpecMotor) if spec_info is None: return spec_version, motor = spec_info self.__spec_version_name = spec_version self.__spec_motor_name = motor cb=dict(connected=self.__motorConnected, disconnected=self.__motorDisconnected, motorPositionChanged=self.__motorPositionChanged, motorStateChanged=self.__motorStateChanged) #motorLimitsChanged=self.__motorLimitsChanged) try: self.__log.debug("Start creating Spec motor %s", motor) self.__spec_motor = SpecMotorA(callbacks=cb) except SpecClientError as spec_error: status = "Error creating Spec motor {0}".format(motor) switch_state(self, DevState.FAULT, status) else: self.__motorConnect() self.__log.debug("End creating Spec motor %s", motor) def __motorConnect(self): motor = self.__spec_motor_name try: self.__spec_motor.connectToSpec(motor, self.__spec_version_name, timeout=.25) except SpecClientError as spec_error: status = "Error connecting to Spec motor {0}".format(motor) switch_state(self, DevState.FAULT, status) raise def __motorConnected(self): state = DevState.ON if self.get_state() != state: status = "Motor is now {0}".format(state) switch_state(self, state, status) def __motorDisconnected(self): state = DevState.OFF if self.get_state() != state: status = "Motor is now %s".format(state) switch_state(self, state, status) def __motorPositionChanged(self, position): state = self.get_state() if state == DevState.MOVING: self.push_change_event("Position", position, time.time(), AttrQuality.ATTR_CHANGING) else: self.push_change_event("Position", position) def __motorStateChanged(self, spec_state): old_state = self.get_state() state = SpecMotorState_2_TangoState[spec_state] # Fire a position event with VALID quality if old_state == DevState.MOVING and state != DevState.MOVING: position = self.__spec_motor.getPosition() self.push_change_event("Position", position) # switch tango state and status attributes and send events switch_state(self, state, "Motor is now {0}".format(state)) def __motorLimitsChanged(self): try: self.__updateLimits() except: self.__log.warning("Failed to update limits") self.__log.debug("Details", exc_info=1) def __updateLimits(self): if not self.__spec_motor: return limits = self.__spec_motor.getLimits() multi_prop = MultiAttrProp() multi_attr = self.get_device_attr() position_attr = multi_attr.get_attr_by_name("position") multi_prop = position_attr.get_properties(multi_prop) multi_prop.min_value = str(limits[0]) multi_prop.max_value = str(limits[1]) position_attr.set_properties(multi_prop) def read_Position(self): position = self.__spec_motor.getPosition() state = self.get_state() if state == DevState.MOVING: return position, time.time(), AttrQuality.ATTR_CHANGING return position def write_Position(self, position): self.__spec_motor.move(position) def read_DialPosition(self): return self.__spec_motor.getDialPosition() def read_Sign(self): return self.__spec_motor.getSign() def write_Sign(self, sign): self.__spec_motor.setSign(sign) def read_Offset(self): return self.__spec_motor.getOffset() def write_Offset(self, offset): self.__spec_motor.setOffset(offset) def read_AccelerationTime(self): return self.__spec_motor.getParameter("acceleration") @DebugIt() def write_AccelerationTime(self, acceleration_time): self.__spec_motor.setParameter("acceleration", acceleration_time) def read_Backlash(self): return self.__spec_motor.getParameter("backlash") @DebugIt() def write_Backlash(self, backlash): self.__spec_motor.setParameter("backlash", backlash) def read_StepSize(self): return self.__step_size @DebugIt() def write_StepSize(self, step_size): self.__step_size = step_size self.push_change_event("StepSize", step_size) def read_Limit_Switches(self): m = self.__spec_motor return False, m.getParameter('high_lim_hit'), \ m.getParameter('low_lim_hit') @command def Stop(self): """ Stop the motor (allowing deceleration time) """ self.__spec_motor.stop() @command def Abort(self): """ Stop the motor immediately """ self.__spec_motor.stop() @command(dtype_in=float) def Move(self, abs_position): """ Move the motor to the given absolute position :param abs_position: absolute destination position :type abs_position: float """ self.__spec_motor.move(abs_position) @command(dtype_in=float) def MoveRelative(self, rel_position): """ Move the motor by the given displacement. :param rel_position: displacement :type rel_position: float """ self.__spec_motor.moveRelative(rel_position) @command def StepUp(self): """ Move the motor up by the currently configured step size """ self.__spec_motor.moveRelative(self.__step_size) @command def StepDown(self): """ Move the motor down by the currently configured step size """ self.__spec_motor.moveRelative(-self.__step_size)