Exemple #1
0
 def test_set_trajectory(self):
     mypar = emotion.get_axis("mypar")
     mymot = emotion.get_axis("mymot")
     par_list = range(100)
     pos_list = range(100)
     mypar.set_parameter(par_list)
     mypar.set_trajectory(mymot, pos_list)
Exemple #2
0
 def test_set_trajectory_wrongrange(self):
     mypar = emotion.get_axis("mypar")
     mymot = emotion.get_axis("mymot")
     par_list = range(100)
     pos_list = range(10)
     mypar.set_parameter(par_list)
     self.assertRaises(ValueError, mypar.set_trajectory, mymot, pos_list)
Exemple #3
0
 def test_axes_creation(self):
     #log.level(log.INFO)
     mymot  = emotion.get_axis("mot0")
     #log.level(log.ERROR)
     self.assertTrue(mymot)
     mymot2 = emotion.get_axis("mot1")
     self.assertTrue(mymot2)
Exemple #4
0
    def test_hardware_axes_preparation(self):

        # If motors are moving, the power can not be switched on
        # therefore hide exception
        mymot  = emotion.get_axis("mymot")
        mymot2 = emotion.get_axis("mymot2")
        #mymot.controller.log_level(emotion.log.INFO)
        mymot.controller.stop(mymot)
        mymot2.controller.stop(mymot2)
        #mymot.controller.log_level(emotion.log.ERROR)

        # NOTE MP: 2015Mar17: the current eMotion doesn't call the
        # controller stop() if it doesn't know that a motion is taking
        # place on the hardware. Therefore bypass eMotion
        while mymot.state() == 'MOVING':
            gevent.sleep(0.1)
        while mymot2.state() == 'MOVING':
            gevent.sleep(0.1)

        # the IcePAP will move, therefore put it close to the
        # target position to avoid long wait
        mymot.dial(0)
        mymot.position(0)
        mymot2.dial(0)
        mymot2.position(0)
Exemple #5
0
    def test_group_move(self):
        robz = emotion.get_axis("robz")
        robz_pos = robz.position()
        roby = emotion.get_axis("roby")
        roby_pos = roby.position()

        self.assertEqual(self.grp.state(), "READY")

        target_robz = robz_pos + 50
        target_roby = roby_pos + 50

        self.grp.move(
            robz, target_robz,
            roby, target_roby,
            wait=False)

        self.assertEqual(self.grp.state(), "MOVING")
        self.assertEqual(robz.state(), "MOVING")
        self.assertEqual(roby.state(), "MOVING")

        self.grp.wait_move()

        self.assertEqual(robz.state(), "READY")
        self.assertEqual(roby.state(), "READY")
        self.assertEqual(self.grp.state(), "READY")
Exemple #6
0
 def test_static_move(self):
     roby = emotion.get_axis("roby")
     robz = emotion.get_axis("robz")
     p0 = self.grp.position()
     self.grp.rmove({ robz: 0, roby: 1})
     self.assertEquals(self.grp.position()[robz], p0[robz])
     self.assertEquals(self.grp.position()[roby], p0[roby]+1)
Exemple #7
0
 def testRealAxisIsRightObject(self):
     s1f = emotion.get_axis('s1f')
     m0 = emotion.get_axis('m0')
     s1ho = emotion.get_axis("s1ho")
     controller = s1ho.controller
     self.assertEquals(s1f.controller, m0.controller)
     self.assertEquals(s1f, controller.axes['s1f'])
Exemple #8
0
    def test_group_creation(self):
        # group creation
        mymot = emotion.get_axis("mymot")
        mymot2= emotion.get_axis("mymot2")
        mygrp = emotion.Group(mymot, mymot2)

        self.assertTrue(mygrp)
Exemple #9
0
 def test_load_trajectory(self):
     mypar = emotion.get_axis("mypar")
     mymot = emotion.get_axis("mymot")
     par_list = range(100)
     pos_list = [ x *10 for x in range(100) ]
     mypar.set_parameter(par_list)
     mypar.set_trajectory(mymot, pos_list)
     mypar.load()
Exemple #10
0
 def test_get_encoder(self):
     enc = emotion.get_encoder("m0enc")
     self.assertTrue(enc)
     self.assertEquals(enc.steps_per_unit, 50)
     m0 = emotion.get_axis("m0")
     self.assertEquals(m0.encoder, enc)
     m1 = emotion.get_axis("m1")
     self.assertEquals(m1.encoder, None)
Exemple #11
0
 def testVelocity(self):
     a1 = emotion.get_axis("a1")
     self.assertEquals(a1.velocity(1), 1)
     config_velocity = a1.config.get("velocity", int)
     self.assertEquals(a1.velocity(config_velocity), config_velocity)
     a2 = emotion.get_axis("a2")
     config_velocity = a2.config.get("velocity", int)
     self.assertEquals(a2.velocity(config_velocity), config_velocity)
Exemple #12
0
    def test_get_parameter_velocity(self):
        mypar = emotion.get_axis("mypar")
        mymot = emotion.get_axis("mymot")
        par_list = range(100)
        pos_list = range(100)
        mypar.set_parameter(par_list)
        mypar.set_trajectory(mymot, pos_list)
        mypar.load()

        vel = mypar.velocity()
Exemple #13
0
 def test_stop(self):
     roby = emotion.get_axis("roby")
     robz = emotion.get_axis("robz")
     self.assertEqual(robz.state(), "READY")
     self.grp.move({robz: 0, roby: 0}, wait=False)
     self.assertEqual(self.grp.state(), "MOVING")
     self.grp.stop()
     self.assertEqual(self.grp.state(), "READY")
     self.assertEqual(robz.state(), "READY")
     self.assertEqual(roby.state(), "READY")
Exemple #14
0
    def test_get_parameter_acctime(self):
        mypar = emotion.get_axis("mypar")
        mymot = emotion.get_axis("mymot")
        par_list = range(100)
        pos_list = range(100)
        mypar.set_parameter(par_list)
        mypar.set_trajectory(mymot, pos_list)
        mypar.load()

        acc = mypar.acctime()
Exemple #15
0
    def testPseudoAxisMove(self):
        s1b  = emotion.get_axis("s1b")
        s1f  = emotion.get_axis("s1f")
        s1hg = emotion.get_axis("s1hg")

        s1f.move(0)
        s1b.move(0)

        hgap = 0.5
        s1hg.move(hgap)
        self.assertAlmostEquals(hgap, s1hg.position(), places=6)
Exemple #16
0
    def test_set_parameter_acctime(self):
        mypar = emotion.get_axis("mypar")
        mymot = emotion.get_axis("mymot")
        par_list = range(100)
        pos_list = range(100)
        mypar.set_parameter(par_list)
        mypar.set_trajectory(mymot, pos_list)
        mypar.load()

        acc = 0.250
        self.assertEqual(mypar.acctime(acc), acc)
Exemple #17
0
    def test_group_get_position(self):
        # group creation
        mymot = emotion.get_axis("mymot")
        mymot2= emotion.get_axis("mymot2")
        mygrp = emotion.Group(mymot, mymot2)

        #mymot.controller.log_level(3)
        pos_list = mygrp.position()
        #mymot.controller.log_level(3)
        for axis in pos_list:
            self.assertEqual(axis.position(), pos_list[axis])
 def testMovePseudo(self):
     m1 = emotion.get_axis("m1")
     m0 = emotion.get_axis("m0")
     p1 = m1.position()
     p0 = m0.position()
     m1.rmove(2)
     self.assertEquals(p1 + 2, m1.position())
     self.assertEquals(m0.position(), p0 + 1)
     m1.rmove(-2)
     self.assertEquals(p0, m0.position())
     self.assertEquals(m1.position(), p1)
Exemple #19
0
 def test_ctrlc(self):
     roby = emotion.get_axis("roby")
     robz = emotion.get_axis("robz")
     self.assertEqual(robz.state(), "READY")
     self.grp.rmove({robz: -10, roby: -10}, wait=False)
     time.sleep(0.01)
     self.grp._Group__move_task.kill(KeyboardInterrupt, block=False)
     self.assertRaises(KeyboardInterrupt, self.grp.wait_move)
     self.assertEqual(self.grp.state(), "READY")
     self.assertEqual(robz.state(), "READY")
     self.assertEqual(roby.state(), "READY")
 def testMoveReal(self):
     m1 = emotion.get_axis("m1")
     m0 = emotion.get_axis("m0")
     p1 = m1.position()
     p0 = m0.position()
     m0.rmove(1)
     self.assertEquals(p0 + 1, m0.position())
     self.assertEquals(m1.position(), p1 + 2)
     m0.rmove(-1)
     self.assertEquals(p0, m0.position())
     self.assertEquals(m1.position(), p1)
Exemple #21
0
    def test_group_move(self):
        # group creation
        mymot = emotion.get_axis("mymot")
        mymot2= emotion.get_axis("mymot2")
        mygrp = emotion.Group(mymot, mymot2)

        pos_list = mygrp.position()
        pos_list[mymot] += 0.1

        # waits for the end of motions
        mygrp.move(pos_list) 
        self.assertEqual(mygrp.state(), "READY")
Exemple #22
0
    def testPosition(self):
        a1 = emotion.get_axis("a1")
        a2 = emotion.get_axis("a2")
        self.assertAlmostEqual(a2.position(), 0.2, places=5)

        for a in (a1, a2):
            p0 = a.position()
            target = p0 + 0.1
            a.move(target)
            self.assertAlmostEqual(a.position(), target, places=5)
            a.move(p0 - 0.1)
            self.assertAlmostEqual(a.position(), p0 - 0.1, places=5)
Exemple #23
0
 def testSimultaneousMove(self):
     a1 = emotion.get_axis("a1")
     a2 = emotion.get_axis("a2")
     p1 = a1.position()
     p2 = a2.position()
     a1.rmove(0.1, wait=False)
     self.assertRaises(RuntimeError, a2.rmove, 0.1, wait=False)
     a1.wait_move()
     a2.wait_move()
     self.assertEquals(a1.position(), p1 + 0.1)
     self.assertEquals(a2.position(), p2)
     a1.rmove(-0.1)
     self.assertEquals(a1.position(), p1)
Exemple #24
0
 def test_bad_startone(self):
     roby = emotion.get_axis("roby")
     robz = emotion.get_axis("roby")
     roby.dial(0); roby.position(0)
     robz.dial(0); robz.position(0)
     try:
         roby.controller.set_error(True) 
         self.assertRaises(RuntimeError, self.grp.move, { robz: 1, roby: 2 }) 
         self.assertEquals(self.grp.state(), "READY")
         self.assertEquals(roby.position(), 0)
         self.assertEquals(robz.position(), 0)
     finally:
         roby.controller.set_error(False)
Exemple #25
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)
Exemple #26
0
    def test_maxee(self):
        m1 = emotion.get_axis("m1")
        m1.move(1)
        self.assertEquals(m1.position(), 1)

        m0 = emotion.get_axis("m0")
        m0.dial(0); m0.position(0)

        self.assertRaises(RuntimeError, m0.move, 1)

        enc = emotion.get_encoder("m0enc")
        enc.set(2)
        m0.move(2)
        self.assertEquals(m0.position(), 2)
Exemple #27
0
 def test_bad_startall(self):
     robz = emotion.get_axis("robz")
     robz2 = emotion.get_axis("robz2")
     robz2.dial(0); robz2.position(0)
     robz.dial(0); robz.position(0)
     grp = emotion.Group(robz, robz2)
     try:
         robz.controller.set_error(True)
         self.assertRaises(RuntimeError, grp.move, { robz: 1, robz2: 2})
         self.assertEquals(grp.state(), "READY")
         self.assertEquals(robz2.position(), 0)
         self.assertEquals(robz.position(), 0)
     finally:
         robz.controller.set_error(False) 
Exemple #28
0
    def test_group_stop(self):
        # group creation
        mymot = emotion.get_axis("mymot")
        mymot2= emotion.get_axis("mymot2")
        mygrp = emotion.Group(mymot, mymot2)

        pos_list = mygrp.position()
        pos_list[mymot] -= 0.1

        # non blocking call
        mygrp.move(pos_list, wait=False) 

        # waits for the end of motions
        mygrp.stop() 
        self.assertEqual(mygrp.state(), "READY")
Exemple #29
0
    def test_move_done_event(self):
        res = {"ok": False}

        def callback(move_done, res=res):
            if move_done:
                res["ok"] = True
        roby = emotion.get_axis("roby")
        roby_pos = roby.position()
        robz = emotion.get_axis("robz")
        robz_pos = robz.position()
        event.connect(self.grp, "move_done", callback)
        self.grp.rmove({robz: 2, roby: 3})
        self.assertEquals(res["ok"], True)
        self.assertEquals(robz.position(), robz_pos+2)
        self.assertEquals(roby.position(), roby_pos+3)
 def test_axis_get_measured_position(self):
     roby = emotion.get_axis("roby")
     roby.custom_simulate_measured(True)
     _meas_pos = -1.2345
     self.assertAlmostEqual(
         roby.measured_position(), _meas_pos, places=4, msg=None)
     roby.custom_simulate_measured(False)
Exemple #31
0
    def init(self):
        self.motorState = EmotionMotor.NOTINITIALIZED
        self.username = self.motor_name

        EmotionMotor.load_config(self.config_file)
        self.motor = emotion.get_axis(self.motor_name)
        self.connect(self.motor, "position", self.positionChanged)
        self.connect(self.motor, "state", self.updateState)
        self.connect(self.motor, "move_done", self._move_done)
Exemple #32
0
    def init(self):
        self.motorState = EmotionMotor.NOTINITIALIZED
        self.username = self.motor_name

        try:
            EmotionMotor.load_config(self.config_file)
        except AttributeError:
            emotion.config.set_backend("beacon")

        self.motor = emotion.get_axis(self.motor_name)
        self.connect(self.motor, "position", self.positionChanged)
        self.connect(self.motor, "state", self.updateState)
        self.connect(self.motor, "move_done", self._move_done)