Esempio n. 1
0
    def initialize_axis(self, axis):
        """Axis initialization"""
        self.log_info("initialize_axis() called for axis %r" % axis.name)

        # Get axis config from emotion config
        # address form is XY : X=rack {0..?} Y=driver {1..8}
        axis.address = axis.config.get("address", int)

        # Create an IcePAP lib axis object
        device = self.libdevice
        address = axis.address
        name = axis.name
        axis.libaxis = libicepap.Axis(device, address, name)

        # Add the axis to the default IcePAP lib group
        self.libgroup.add_axis(axis.libaxis)

        # Initialiaze hardware
        # if set_power fails, display exception but let axis
        # be created properly
        try:
            self.libgroup.set_power(libicepap.ON, axis.libaxis)
        except:
            sys.excepthook(*sys.exc_info())

        # Add new axis oject methods
        add_axis_method(axis, self.get_identifier, types_info=("None", "str"))
Esempio n. 2
0
    def initialize_axis(self, axis):

        axis.channel = axis.config.get("channel")

        if axis.channel == "X":
            self.ctrl_axis = axis

        axis.target_radius = axis.config.get("target_radius", int)
        axis.target_time = axis.config.get("target_time", int)
        axis.min_dead_zone = axis.config.get("min_dead_zone", int)
        axis.max_dead_zone = axis.config.get("max_dead_zone", int)
        axis.smoothing = axis.config.get("smoothing", int)
        axis.deceleration = axis.config.get("deceleration", float)

        add_axis_method(axis, self.get_id)

        # Enabling servo mode.
        self._flexdc_query("%sMO=1" % axis.channel)

        # Sets "point to point" motion mode.
        # 0 -> point to point
        # ( 1 -> jogging ;    2 -> position based gearing    )
        # ( 5 -> position based ECAM ;    8 -> Step command (no profile) )
        self._flexdc_query("%sMM=0" % axis.channel)

        # Special motion mode attribute parameter
        # 0 -> no special mode
        # ( 1 -> repetitive motion )
        self._flexdc_query("%sSM=0" % axis.channel)

        # Defines smoothing (typically 4).
        self._flexdc_query("%sWW=%d" % (axis.channel, axis.smoothing))

        # Target Time (settling time?)
        self.flexdc_parameter(axis, "TT", axis.target_time)

        # Target Radius (target window ?)
        self.flexdc_parameter(axis, "TR", axis.target_radius)

        # Checks if closed loop parameters have been set.
        _ans = self._flexdc_query("%sTT" % axis.channel)
        if _ans == "0":
            elog.error("Missing closed loop param TT (Target Time)!!")

        _ans = self._flexdc_query("%sTR" % axis.channel)
        if _ans == "0":
            elog.error("Missing closed loop param TR (Target Radius)!!")

        # Minimum dead zone
        self.flexdc_parameter(axis, "CA[36]", axis.min_dead_zone)

        # Maximum dead zone
        self.flexdc_parameter(axis, "CA[37]", axis.max_dead_zone)
Esempio n. 3
0
    def initialize_axis(self, axis):
        """

        :type self: object
        """
        # To get rid of cache coherency problems.
        add_axis_method(axis, self.sync, name="sync", types_info=(None, None))
        add_axis_method(axis, self.set_log_level, name="SetLogLevel", types_info=(int, None))

        # Reads sensors coefficients (previously calibrated...) for the current piezo axis
        # from the PI E712
        self.piezo.coeffs = self.piezo.controller.get_sensor_coeffs(self.piezo)
Esempio n. 4
0
    def initialize_axis(self, axis):
        """Axis initialization"""
        tacomaxe_info("initialize_axis() called for axis \"%s\"" % axis.name)

        # Get axis config from emotion config
        axis.channel = axis.config.get("channel", int)
        axis.myvelocity = axis.config.get("velocity", int)
        axis.mybacklash = axis.config.get("backlash", int)
        axis.myacceleration = axis.config.get("acceleration", int)
        axis.steps_per_u = axis.config.get("steps_per_unit", int)

	add_axis_method(axis, self.custom_read_firststeprate,types_info=("None","float"))
	add_axis_method(axis, self.custom_set_firststeprate,types_info=("float","None"))
Esempio n. 5
0
    def initialize_axis(self, axis):
        """
        - Reads specific config
        - Adds specific methods
        - Switches piezo to ONLINE mode so that axis motion can be caused
        by move commands.

        Args:
            - <axis>
        Returns:
            - None
        """

        add_axis_method(axis, self.read_offset, name = "ReadOffset", types_info = (None, float))
        add_axis_method(axis, self.set_offset, name = "SetOffset", types_info = (float, None))

        add_axis_method(axis, self.read_factor, name = "ReadFactor", types_info = (None, float))
        add_axis_method(axis, self.set_factor, name = "SetFactor", types_info = (float, None))
        add_axis_method(axis, self.sync, name = "sync", types_info = (None, None))
Esempio n. 6
0
    def initialize_axis(self, axis):
        """
        - Reads specific config
        - Adds specific methods
        """
        # can be "X" or "Y"
        axis.chan_letter = axis.config.get("chan_letter")

        add_axis_method(axis, self.get_id, types_info=(None, str))

        axis.config.config_dict.update({"steps_per_unit": {"value": axis.config.get("steps_per_unit")}})

        ini_pos = self.read_position(axis)
        if ini_pos < 0:
            elog.info("reseting VSCANNER negative position to 0 !!")
            _cmd = "V%s 0" % (axis.chan_letter)
            self.send_no_ans(axis, _cmd)

        if ini_pos > 10:
            elog.info("reseting VSCANNER >10-position to 10 !!")
            _cmd = "V%s 10" % (axis.chan_letter)
            self.send_no_ans(axis, _cmd)
Esempio n. 7
0
    def initialize_axis(self, axis):
        """
        - Reads specific config
        - Adds specific methods
        - Switches piezo to ONLINE mode so that axis motion can be caused
        by move commands.

        Args:
            - <axis>
        Returns:
            - None
        """
        axis.channel = axis.config.get("channel", int)
        axis.chan_letter = axis.config.get("chan_letter")

        add_axis_method(axis, self.get_id, types_info=(None, str))

        '''Closed loop'''
        add_axis_method(axis, self.open_loop, types_info=(None, None))
        add_axis_method(axis, self.close_loop, types_info=(None, None))

        '''DCO'''
        add_axis_method(axis, self.activate_dco, types_info=(None, None))
        add_axis_method(axis, self.desactivate_dco, types_info=(None, None))

        '''GATE'''
        # to enable automatic gating (ex: zap)
        add_axis_method(axis, self.enable_auto_gate, types_info=(bool, None))

        # to trig gate from external device (ex: HPZ with setpoint controller)
        add_axis_method(axis, self.set_gate, types_info=(bool, None))

        if axis.channel == 1:
            self.ctrl_axis = axis

        # NO automatic gating by default.
        self.auto_gate_enabled = False

        '''end of move event'''
        event.connect(axis, "move_done", self.move_done_event_received)

        # Enables the closed-loop.
        # self.sock.write("SVO 1 1\n")

        self.send_no_ans(axis, "ONL %d 1" % axis.channel)

        # VCO for velocity control mode ?
        # self.send_no_ans(axis, "VCO %d 1" % axis.channel)

        # Updates cached value of closed loop status.
        self.closed_loop = self._get_closed_loop_status(axis)

        # Reads high/low limits of the piezo to use in set_gate
        self.low_limit  = self._get_low_limit(axis)
        self.high_limit = self._get_high_limit(axis)
Esempio n. 8
0
    def initialize_axis(self, axis):
        """
        - Reads specific config
        - Adds specific methods
        - Switches piezo to ONLINE mode so that axis motion can be caused
        by move commands.

        Args:
            - <axis>
        Returns:
            - None
        """
        elog.info("initialize_axis() called for axis %r" % axis.name)

        self._hw_status = AxisState("READY")


        """ Documentation uses the word AxisID instead of channel
            Note: any function used as axis method must accept axis as an argument! Otherwise
                  you will see:
                  TypeError: check_power_cut() takes exactly 1 argument (2 given)
        """
        axis.channel = axis.config.get("channel", int)

        add_axis_method(axis, self.raw_com, name = "RawCom", types_info = (str, str))

        add_axis_method(axis, self.check_power_cut, name = "CheckPowerCut", types_info = (None, None))
        add_axis_method(axis, self._get_tns, name = "Get_TNS", types_info = (None, float))
        add_axis_method(axis, self._get_tsp, name = "Get_TSP", types_info = (None, float))
        add_axis_method(axis, self._get_offset, name = "Get_Offset", types_info = (None, float))
        add_axis_method(axis, self._put_offset, name = "Put_Offset", types_info = (float, None))
        add_axis_method(axis, self._get_tad, name = "Get_TAD", types_info = (None, float))
        add_axis_method(axis, self._get_closed_loop_status, name = "Get_Closed_Loop_Status", types_info = (None, bool))
        add_axis_method(axis, self._set_closed_loop, name = "Set_Closed_Loop", types_info = (bool, None))
        #add_axis_method(axis, self._get_on_target_status, name = "Get_On_Target_Status", types_info = (None, bool))
        add_axis_method(axis, self._get_pos, name = "Get_Pos", types_info = (None, float))

        try:
            axis.paranoia_mode = axis.config.get("paranoia_mode")  # check error after each command
        except KeyError :
            axis.paranoia_mode = False

        self._gate_enabled = False

        # Updates cached value of closed loop status.
        axis.closed_loop = self._get_closed_loop_status(axis)
        self.check_power_cut(axis)

        elog.debug("axis = %r" % axis.name)
Esempio n. 9
0
    def initialize_axis(self, axis):
        def set_pos(move_done, axis=axis):
            if move_done:
                self.set_position(axis, axis.dial()*axis.steps_per_unit)

        self._axis_moves[axis] = {
            "measured_simul": False,
            "measured_noise": 0.0,
            "end_t": 0,
            "end_pos": 0,
            "move_done_cb": set_pos }

        event.connect(axis, "move_done", set_pos)

        # this is to test axis are initialized only once
        axis.settings.set('init_count', axis.settings.get('init_count') + 1)

        # Add new axis oject methods as tango commands.
        add_axis_method(axis, self.custom_park, types_info=("None", "None"))
        add_axis_method(axis, self.custom_get_forty_two, types_info=("None", "int"))
        add_axis_method(axis, self.custom_get_twice, types_info=("int", "int"))
        add_axis_method(axis, self.custom_get_chapi, types_info=("str", "str"))
        add_axis_method(axis, self.custom_send_command, types_info=("str", "None"))
        add_axis_method(axis, self.custom_command_no_types, types_info=("None", "None"))
        add_axis_method(axis, self.custom_set_measured_noise, types_info=("float", "None"))

        add_axis_method(axis, self.put_discrepancy, types_info=("int", "None"))


        if axis.encoder:
            self.__encoders.setdefault(axis.encoder, {})["axis"] = axis
Esempio n. 10
0
    def initialize_axis(self, axis):
        CalcController.initialize_axis(self, axis)

        add_axis_method(axis, self.command_perso)
Esempio n. 11
0
    def initialize_axis(self, axis):
        """Axis initialization"""
        self.log_info("initialize_axis() called for axis %r" % axis.name)

        # Get the list of IcePAP axes
        axes_names = axis.config.get("axislist").split()
        if len(axes_names) == 0:
            raise ValueError('missing mandatory config parameter "axislist"')

        # Check the list of IcePAP axes
        dev = None
        for axis_name in axes_names:

            # Get EMotion axis object
            hw_axis = emotion.get_axis(axis_name)

            # Check that it's an IcePAP controlled one
            if type(hw_axis.controller).__name__ is not 'IcePAP':
                raise ValueError('invalid axis "%s", not an IcePAP'%axis_name)

            # Get underlying libicepap object
            axis_dev = hw_axis.controller.libdevice
            if dev is None:
                dev = axis_dev

            # Let's impone that the trajectories work only on the same system
            if axis_dev.hostname() != dev.hostname():
                raise ValueError( 
                    'invalid axis "%s", not on the same IcePAP'%axis_name)

        # At this point we have configuration
        # Create an empty libicepap trajectory object
        self.libtraj[axis] = libicepap.Trajectory(axis.name)

        # Keep a record of axes
        for axis_name in axes_names:
            self.axes_names.append(axis_name)
            hw_axis = emotion.get_axis(axis_name)
            self.axis_list[axis_name] = hw_axis

        # Keep a record of the IcePAP system for faster access
        self.libdevice = dev

        # Add new axis oject methods
        add_axis_method(axis, self.set_parameter)
        add_axis_method(axis, self.get_parameter)
        add_axis_method(axis, self.set_trajectory)
        add_axis_method(axis, self.drain)
        add_axis_method(axis, self.load)
        add_axis_method(axis, self.sync)