Anda di halaman 1dari 8

A MATLAB Toolbox for Robotic Manipulators

D. N. Vila-Rosado and J. A. Domnguez-L pez o Centro de Investigaci n en Matem ticas (CIMAT), o a Guanajuato CP36240, MEXICO {dnvr30, axel} Abstract
MATLAB toolboxes have been very useful to teach and train without the need for the physical system. Especially in the robotics eld, using simulations avoids the considerable cost of building a full robot manipulator. For robotics, there was only one MATLAB toolbox, which has several limitations. These limitations have been cured in the toolbox reported in this paper. Also, there have been some additions to make the toolbox robust and more complete. Some of these improvements are using a closed-form solution for the inverse kinematics, a tough path and trajectory generation. In addition, an end effector (i.e., a two-ngered gripper) has been added, hence the user can simulate a robot which manipulates objects. The full toolbox and its documentation can be freely downloaded from internet. Keywords: Robotics, Matlab Toolbox, Closed Form Solution, Trajectory Design.


Since the rst master-slave anthropomorphic manipulator was developed in 1947, a considerable number of robotic systems have been developed by industry and academic organizations. The applications for manipulators have been growing because of the increased ability of robots to interact dynamically with their environment in a precise manner. In the same way, the interest in robotic manipulators has been raising. MATLAB [1] toolboxes have been very useful to teach and train without the need for the physical system, as they are sometimes very expensive and easily broken. Also, the MATLAB toolboxes are very useful to test designs before proceeding to build them. Therefore, the MATLAB toolboxes allow the users to rapidly create and test their system. Currently, there is only one MATLAB toolbox for robotics [2], which has three main limitations: the toolbox uses a numerical method to solve the inverse kinematics (i.e., to nd joint displacements given a position and orientation), the toolbox does not have a good path

and trajectory generation, and the toolbox includes no end effectors. Of the two main solution strategies for inverse kinematics, numerical methods are commonly discarded because of their computational complexity. In addition, the numerical method used in the current MATLAB toolbox frequently misses to nd a solution, despite that the inverse kinematic is solvable for the given positions and orientations. Accordingly, the toolbox described in this paper utilizes a closed form solution (i.e., algebraic solution). Thus, the displacement of the joints can be found faster and for all position and orientation in which the inverse kinematic problem is solvable. Moreover, for the multiple solutions case, the user can specify the criteria to choose a solution. For the path and trajectory generation is desirable to be able to specify trajectories with simple descriptions of the desired motions, and let the generation algorithm to solve the details. Besides the goal position and orientation of the end effector, and the via points (i.e., intermediate points), the user can specify both spatial and temporal information (e.g., velocities, accelerations, etc.) Also, the system should be able to decide the velocity and acceleration prole. When the end effector is a gripper, the control of the acceleration is vital to avoid slippage of the grasped object. Accordingly, the model of a two-ngered gripper is included to allow the user to test path and trajectory generation in a pick-up and place application. In addition, a grasping control is incorporated to our toolbox. Thus, the user can create a robot manipulator capable of manipulating objects.

Description and transformations of coordinate systems

Different co-ordinate systems are used to describe the locations,orientations and movements of the different manipulator components. There are two conventions to number the links, one proposed by Paul [3] and other proposed by Craig [4]. The former numbers the rst moving link as link 0, and so on. While the latter numbers the immobile

Proceedings of the Sixth Mexican International Conference on Computer Science (ENC05) 0-7695-2454-0/05 $20.00 2005


base of the arm as link 0, the rst moving body is link 1, and so on. When Craigs convention is used, it is opportune, for simplicity, that the reference system origin (S0 ) coincides with S1 because this will lead to a0 = 0, 0 = 0 and d1 = 0 if joint 1 is revolute or 1 = 0 if the joint is prismatic. The toolbox has full support for both conventions. The convention used to number the joints is as follows: joint i is the geometric point where links i 1 and i are connected. In addition, co-ordinate systems are assigned to each link. A reference co-ordinate system is needed. For convenience, it is usually xed to the manipulator base. The positions of all other systems are described in terms of this frame. A co-ordinate system is assigned to each link. The link coordinate systems are enumerated as the link number. At the end of the last link, an extra system is xed which coincides with the location and orientation of the end effector. The rotation matrix, Q, is used to the new co-ordinate frame when the system rotates around any axis. When the system translates without any rotation, Q is equal to the identity matrix, I, so to get the new co-ordinate frame is obtained by Equation 1. In order to facilitate the writing of compact equations, the rotations and translations are combined into a single matrix named the homogeneous matrix, Bi , which transforms the co-ordinates of Si to Si1 : Bi (qi ) = Qi (qi ) 0 i Ri1 1

Reference [5] introduced a systematic method to describe the kinematic relationships in a manipulator to facilitate the modelling. This notation is based on the fact that any robot link can be described kinematically by four quantities: Two quantities describe the link itself while the other two describe the links connection to an adjacent link. These values are ai , i , i and di . Three of them are constant, the variable is i if the joint is revolute or di if the joint is prismatic. The convention for using these quantities is named Denavit-Hartenberg (DH) notation. Observe, that there are two different forms of DH representation: Classical form (based in the original work of [5]) and a modied form (introduced by [4]). The toolbox has full support for both conventions. For the modied convention, the general homogeneous matrix, Bi , which has 4 DHtransformation, is given by: Bc i = Bz (i ) Bz (di ) Bx (ai ) Bx (i ) = Bz (di ) Bz (i ) Bx (i ) Bx (ai ) Ci Si = 0 0 Si Ci Ci Ci Si 0 Si Si Ci Si Ci 0 ai Ci ai Si di 1

where qi is the ith variable and is equal to i if the joint is revolute or di if the joint is prismatic. Note that there is only one variable. If we wish to do a rotation and a translation, we will then have two B matrices, one for each movement. P 0 = P 1 + Ri1

where C and S stands for cos and sin, respectively. For the classical convention, the homogeneous matrix is given by: Bm i = Bx (ai ) Bx (i ) Bz (i ) Bz (di ) = Bx (i ) Bx (ai ) Bz (di ) Bz (i ) Notice that the both homogeneous matrices are not equal (i.e., Bc = Bm ): in the classical convention we i i rstly make all the movements in the z-axis and then in the x-axis while in the modied we initially move in the x-axis and then in the z-axis. Thus, at the moment of constructing every robot link, it is important to bear in mind and to state which convention is being used. The Eslabon command constructs each robot link given the Denavit-Hartenberg parameters. The JointType parameter determines if the joint is either revolute or prismatic. Eslabon([alpha, a, theta, d, JointType],Weight, Material,Convention) //a revolute joint >>L{1}=Eslabon([pi/2 0.3 0 0 0]); //a prismatic joint >>L{2}=Eslabon([0 0.1 0 0 1]);


Another useful matrix is the homogenous transformation matrix Tj , which transforms the co-ordinates of a system i Sj to a system Si . It is given by: Bi+1 Bi+2 ... Bj1 Bj j I Ti = (Tj )1 i if i < j if i = j if i > j


The commands used for the transformations are listed next: trasl2hom translation to homogeneous matrix rotx2hom rotation about x-axis to homogeneous matrix roty2hom rotation about y-axis to homogeneous matrix rotz2hom rotation about z-axis to homogeneous matrix hom2eul homogeneous matrix to Euler angles eul2hom Euler angles to homogeneous matrix hom2rpy homogeneous matrix to roll/pitch/yaw angles rpy2hom roll/pitch/yaw angles to homogeneous matrix

Proceedings of the Sixth Mexican International Conference on Computer Science (ENC05) 0-7695-2454-0/05 $20.00 2005


Once, all the links have been constructed, the robot is created using the robot command using all the links: Robot(Links, Name) >>MyRobot=Robot(L,My First Robot)

specify a the joint angles or the joint offsets: cinema_dir(Robot, [joint angles]) cinema_dir(Robot, [joint offsets]) >>cinema_dir(MyRobot, [0 0 pi/2]) x=30 y=45 z=0 The calculation of the inverse kinematics can be specifying either only the positions or both position and orientation. The inverse kinematics command for a given position: cinema_inv(Robot, [Position]) >>cinema_inv(MyRobot, [0 30 45]) (T=Theta) T1=0 T2=0 T3=1.5707 and the inverse kinematics command for a given position and orientation: cinema_inv(Robot, [Position], [Orientation]) >>cinema_inv(MyRobot,[0 30 45], [0 0 pi/2]) (T=Theta) T1=0 T2=0 T3=1.5707

Forward and inverse kinematics

Forward kinematics allow us to determine the position and orientation of the end effector. If we desire to put the end effector in a specic position and orientation, we need to know the displacement of the joints. This problem is named inverse kinematics and its solution is called the arm solution. The inverse kinematics problem is said to be solvable if all sets of joints values for a given position and orientation can be determined using an algorithm. So, if there were multiple solutions, the algorithm should be able to solve all of them. There are two main solution strategies: closed form and numerical. The latter is much slower than the former. Consequently, numerical methods are commonly discarded because of their computational complexity. The closed form methods are divided into two: algebraic and geometric. Both are very similar and the only difference is in their approach. The algebraic method uses the forward kinematic equations as a system of non-linear equations regardless of the robot geometric structure. With the geometric method, the robot geometric structure is used to guide the approach to solve the non-linear equations. Closed form techniques are only useful to solve manipulators with a simple mechanical structure and with less than 6 DOF [4]. Although, if a 6 DOF manipulator has three consecutive revolute joints with their joint axes intersecting at a single point, the manipulator is solvable [6]. To simplify the inverse kinematics algebraic solution, the problem is divided in two parts: to nd the wrist co-ordinate system and to solve the joint angles. The following equations represent the two subproblems, respectively. T4 = 0

Path and trajectory generation


Tn+1 = 4


Trajectory generation describes a time history of position, velocity and acceleration for each link of the robot which moves from a start position and orientation to an end position (goal position) with a specic orientation. Trajectory generation can be a complex problem depending on the constraints and desired accuracy of the system. For instance, in addition to the start and goal points, we might want the system to pass through intermediate points (via points) and with a specic elapsed time between these via points. Moreover, we might want to specify the velocity and acceleration with which the end effector should move. Other common requirement is smooth motions, as uneven movements increase mechanism wear and cause vibrations [4]. Some of these considerations can be considered automatically by the trajectory generation algorithm. Thus, the user has to provided simple descriptions of the desired motion. Our toolbox considers several kinds of trajectory generation which can be combined. They are: Asynchrony Point-To-Point Synchrony Point-To-Point Straight line

where n is the number of robot joints. To commands cinema_dir and cinema_inv compute the forward and inverse kinematics, respectively. To compute the forward kinematics, it is necessary to

Proceedings of the Sixth Mexican International Conference on Computer Science (ENC05) 0-7695-2454-0/05 $20.00 2005


With constant end effector orientation With intermediate orientation With intermediate point The traj command is used to specify a trajectory generation in joint space (Point-To-Point motions). We can specify only the StartPoint and GoalPoint. In addition to these specications, the user can indicate any of the following requirements: the elapse time (t), nal orientation (FinalOrientation), constant orientation (ConstantOrientation), intermediate orientations (ViaOrientation) and points (ViaPoints). The intermediate orientation and points are matrixes of those via orientations and points while the elapse time, nal and constant orientations are vectors. >>traj([StartPoint], [GoalPoint]) >>traj([StartPoint], [GoalPoint], Synchrony) >>traj([StartPoint], [GoalPoint], Line) >>traj([StartPoint], [GoalPoint], t) >>traj([StartPoint], [GoalPoint], FinalOrientation) >>traj([StartPoint], [GoalPoint], ConstantOrientation, Constant) >>traj([StartPoint], [GoalPoint], ViaOrientation, Orientations) >>traj([StartPoint], [GoalPoint], ViaPoints, Points) >>traj([StartPoint], [GoalPoint], t, FinalOrientation, Line) v = J where v = [x y z]T is the end effector velocity vector and = [1 ... n ]T is the joint velocities of a manipulator of n joints. From a robot with n degrees of freedom, there are two main Jacobian to consider: in the base and the end effector co-ordinates. Their commands are, respectively: JBase(MyRobot,[Velocities-Joint Space]); JEnd(MyRobot,[Velocities-JointSpace]); When we wish to move the end effector at a desired velocity, we need to nd the corresponding individual joint velocities. To get that transformation, the inverse Jacobian, J1 , is used: = J1 v (3)

For the inverse Jacobian to exist, it should be nonsingular at the current arm conguration. The Jacobian is singular when its determinant is zero. When that happens, Equation 3 is unsolvable for these values of , which are named singularities. In a singularity, the end effector cannot be moved in at least one direction. All manipulators have singularities at their workspace boundary or when some joint axes are lining up. Again, we have two main Jacobian. The former command is for the base co-ordinates while the latter is for the end effector co-ordinates: inv(JBase(MyRobot))* [Velocities-Cartesian] inv(JEnd(MyRobot))* [Velocities-Cartesian]

The moveto command is similar to the traj, but the StartPoint for move is the current position. Thus, no StartPoint has to be declared: >>moveto([GoalPoint]); other parameters, like t and FinalOrientation can be used with this command too. To move the end effector to a goal point with a specic speed, it is necessary to calculate the corresponding motion of each joint. The motion of the end effector is dened in Cartesian space. So a way is needed to translate from Cartesian space to joint space and vice versa. The Jacobian matrix, J, is a quantity matrix that maps velocities in joint space to velocities in Cartesian space:


The normal industrial grippers used for material handling are two-ngered grippers with the two ngers working on opposition [7, 8]. Thus, a two-ngered gripper is included to the toolbox to allow the robot to manipulate objects (e.g., pick-and-place action). To achieve satisfactory grasp, optimal force control is required to ensure the integrity of the grasped object. The gravity, the end effector acceleration and external disturbances would try to make the load slip. Hence, the gripper has to compensate such perturbations. The minimum force that the gripper must apply to the load in order to avoid slippage is given by FT . However, it is recommended to apply a little more force to

Proceedings of the Sixth Mexican International Conference on Computer Science (ENC05) 0-7695-2454-0/05 $20.00 2005


End Effector Vertical Acceleration (m/s2)

be absolutely sure that there will be no slip [7]. The required force when the object is gripped vertically, v FT , is given by:
v FT



2m(g + a) sin g 2m(g + a)Lg sin g + d


where g is the angle between the gripping surface and the horizon, m is the load mass, g is the acceleration due to gravity, a is the vertical acceleration of the end effector, d is the width of the pressure pad and Lg is the distance from the center of gravity to the torque axis. When the object is gripped horizontally, the required force, h FT , is given by:
h FT






Time (s)

where R is the arm length and is the angular velocity of the end effector. However, if the applied force and the applied actuator energy (e.g., applied motor voltage) are high, it means that it is not possible to grip tightly without risk of crushing the object or slippage. Accordingly, an approach to reducing the possibility of damaging the object is to restrict the end effector acceleration [9, 10]. Therefore, the toolbox trajectory generation function includes a framework to control the maximum end effector acceleration when a gripper is attached to the robot. Notice that the end effector vertical acceleration is measured along the grippers z axis of the grippers coordinate frame, zg , rather than in the worlds coordinate frame. The following commands include the gripper and an object of 5 Kg: >>gripper(Rmotor , KT ); >>load(5); %5Kg. where Rmotor and KT are motor resistance and the motor torque constant, respectively. The actuator of the gripper included in the toolbox is a DC motor. The following command generates a trajectory (from the current position) with acceleration limiter:

Figure 1. Behaviour of the end effector vertical acceleration: (solid) desired acceleration, and (dashed) suggested acceleration. Notice that the end effector vertical acceleration is measured along the grippers z axis of the grippers coordinate frame, zg , rather than in the worlds coordinate frame.

frame.) At 7 s the limiter controller predicts that the gripper would be unable to cope with more acceleration and sets a maximum acceleration. This acceleration limit eliminates the risk of object slippage [10]. Nevertheless, this improvement has the cost of a delay to complete the trajectory. Thus, the user has to determine which case is better for the application: (a) no delays but with risk of slippage or (b) delays with null slippage.


There are four sources of torques and forces which act on the manipulator: dynamic torques (inertial, centripetal, Coriolis) from motion; static torques from friction; gravity torques; and external forces and torques [11]. The actuators have to balance these torques. There are dif>>traj([StartPoint],[GoalPoint],t,limit) ferent approaches to represent the manipulator dynamics: Newtons laws together with the concept of virtual work, Slip (area)= 0 DAlemberts principle, Lagranges equation, Hamiltons Delay (s)= 0.7 equations, and Hamiltons principle. As manipulators represent a complicated dynamic system, Lagrangian mewhere t is a vector which species the elapsed time. Startchanics are used because this method allows us to obtain Point and GoalPoint are vector which determine the starting the dynamic equations in the simplest way [3]. These and goal points, respectively. The command moveto can equations relate forces and torques to positions, velocities also be used with the acceleration limiter. and accelerations. So, the dynamic behaviour of a robot is Figure 1 shows the behaviour of the acceleration limdescribed in terms of how the arm conguration changes iter (dashed) for a pre-determined acceleration behaviour in time in relation to the torques and forces exerted by (solid). (Notice that the end effector vertical acceleration the actuators [11]. The solution to the forward dynamic is measured along the grippers z axis of the grippers equations gives the equation of motion of the manipulator coordinate frame, zg , rather than in the worlds coordinate

Proceedings of the Sixth Mexican International Conference on Computer Science (ENC05) 0-7695-2454-0/05 $20.00 2005


(position, velocity and acceleration). To determine the required torques and forces to provide that motion, inverse dynamic equations have to be solved. The Lagrangian, L, formulation is based in terms of the kinetic energy, K, and the potential energy, P , of the manipulator in any co-ordinate system. Kinetics relates the forces that cause motion to the resulting motion: L=K P
1 2 2


Building a PUMA robot


where K = m v and P = m g d cos(). The masses of the links are assumed to be negligible in comparison to the masses of the joints, so the dynamic equations can be determined easily. The dynamic equations are in terms of the kinetic and potential energy as well as the co-content of the system dissipators: Fi = d L L C + , dt qi qi qi i = 1, ..., n (5)

For the construction of a PUMA robot (a 6R mechanism), it is necessary to use the Eslabon command for each row of the DH parameters. To illustrate that our toolbox is indeed capable of working with both forms of DH representation, rstly, the PUMA robot will be built twice, one for each convention, and then to prove that both robots are identical, kinematics commands are going to be used (this proof will take place in Section 7.2).The DH parameters for the classical convention are given in Table 1. Accordingly, the PUMA robot is obtained by the following set of commands: //values are assigned to the constants a2=0.8; a3=0.1; d3=0.1; d4=0.5; //then each link is created L{1}=Eslabon([pi/2 0 0 0],1); L{2}=Eslabon([0 a2 0 0],1); L{3}=Eslabon([-pi/2 a3 d3 0],1); L{4}=Eslabon([pi/2 0 d4 0],1); L{5}=Eslabon([-pi/2 0 0 0],1); L{6}=Eslabon([0 0 0 0],1); //finally the robot is constructed PUMA1=Robot(L,PUMA - classical) PUMA1= Name: PUMA -classical Joints: 6 Gravity vector = [0.00 0.00 -9.81] Convention: DH standard
alpha 1.5707 0.0000 1.5707 1.5707 1.5707 0.0000 a 0.0000 0.8000 0.1000 0.0000 0.0000 0.0000 theta 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 d 0.0000 0.0000 0.1000 0.5000 0.0000 0.0000 Joint type Revolute (DHS) Revolute (DHS) Revolute (DHS) Revolute (DHS) Revolute (DHS) Revolute (DHS)

where n is the number of DOF, qi is the co-ordinate in which the ith kinetic and potential are expressed and, qi and Fi are the corresponding velocity and force or torque, respectively. If qi is a linear co-ordinate, Fi is force, while if qi is an angular co-ordinate, Fi is torque. Thus, we are interested in determining the motion of the manipulator arose from torques applied by the actuators or from external forces applied to the manipulator. The toolbox include the torque, ext_force and accel commands. The torque command calculates the required torques to produce the specied position, velocities and accelerations. Then, the ext_force computes the velocities and accelerations due to external forces. And the accel determine the resulting acceleration for the input vector of torques. The format of these commands are as follows: torque(Robot, [desired trajectory]) >>torque(MyRobot,traj([StartPoint], [GoalPoint])); ext_force(Robot, [forces]) >>ext_force(MyRobot, [gravity]); accel(Robot, [torques])

Practical examples

Presently, the DH parameters for the modied form are given in Table 2. Subsequently, the PUMA robot construction for this form is given by: //values are assigned to the constants a2=0.8; a3=0.1; d3=0.1; d4=0.5; //then each link is created L{1}=Eslabon([0 0 0 0],1,,DHM);

Some practical examples are presented in this section to illustrate the use of the toolbox in different applications. Firstly, we will construct a robot using both conventions for DH representation. Secondly, we will illustrate the use of forward kinematics commands. Finally, we will exemplify the creation of trajectories.

Proceedings of the Sixth Mexican International Conference on Computer Science (ENC05) 0-7695-2454-0/05 $20.00 2005


Table 1. DH parameters for the PUMA robot using the classical convention

z x

i 1 2 3 4 5 6

i1 90 0 90 90 90 0

ai1 0 a2 a3 0 0 0

di 0 0 d3 d4 0 0

i 1 2 3 4 5 6


Figure 2. Graphical representation of the SCARA robot (home position). Table 2. DH parameters for the PUMA robot using the modied convention i 1 2 3 4 5 6 i1 0 90 0 90 90 90 ai1 0 0 a2 a3 0 0 di 0 0 d3 d4 0 0 i 1 2 3 4 5 6 Table 3. DH parameters for the SCARA robot using the classical convention i 1 2 3 i1 0 0 0 ai1 a1 a2 0 di 0 0 a3 + d3 i 1 2 0

L{2}=Eslabon([-pi/2 0 0 0],1,,DHM); L{3}=Eslabon([0 a2 d3 0],1,,DHM); L{4}=Eslabon([-pi/2 a3 d4 0],1,,DHM); L{5}=Eslabon([pi/2 0 0 0],1,,DHM); L{6}=Eslabon([-pi/2 0 0 0],1,,DHM); //finally the robot is constructed PUMA2=Robot(L,PUMA - modified);

The forward kinematics of both robots were compared for 5 sets of joint angles. Although not shown explicitly here, for each set of joint angles, the obtained homogeneous transformation matrix of PUMA1 was identical to PUMA2s.


Trajectories for the SCARA robot


Forward kinematics of a PUMA robot

As said previously, forward kinematics are going to be used to proof that PUMA1 is identical to PUMA2. At the same time, the operation of the cinema_dir command will be illustrated. The output of the cinema_dir command is the homogeneous transformation matrix, Accordingly, the homogeneous transformation Tn . 0 matrix of PUMA1 has to be identical to PUMA2s. The forward kinematics for the PUMA1 with joint angles={0, 0, 0, 0, 0, 0} is given by: cinema_dir(PUMA1, [0 0 0 0 0 0])
1.000 0 0 0 0 1.000 0.000 0 0 0.000 1.000 0 0.900 0.100 0.500 1

As shown above, we rstly construct the SCARA robot (a RRP mechanism). The DH parameters of the SCARA robot are given in Table 3 (using the classical convention). Figure 2 shows the graphical representation for the SCARA robot. In the rst example, the SCARA robot is moved from [0, 0, 0] to [-1.061, 1.369, -1] using the synchrony point-to-point trajectory generation: p0=[0 0 0]; pf=[-1.061 1.369 -1];
//10 steps are used to reach the goal point

traj(p0,pf,10) ans= 0 0 0 -0.0122 0.0158 -0.0115 ... -1.0610 1.3690 -1

Proceedings of the Sixth Mexican International Conference on Computer Science (ENC05) 0-7695-2454-0/05 $20.00 2005


In the second example, the SCARA robot is moved from [0, 0, 0] to [-1.061, 1.369, -1] using Cartesian-space trajectory generation. The start and goal points are converted to homogenous matrix. p0=trasl2hom(0,0,0); pf=trasl2hom(-1.061,1.369,-1);
//10 steps are used to reach the goal point

The toolbox for robot manipulators and its manual are freely available at or All the toolbox functions are described in detail in the manual.

[1] The MathWorks Inc. Matlab Users Guide. Natick, MA, 1990. [2] P.I. Corke. A robotics toolbox for MATLAB. IEEE Robotics and Automation Magazine, 3(1):24 32, March 1996. [3] Richard P. Paul. Robot Manipulators: Mathematics, Programming, and Control. The MIT Press, Cambridge, MA, 1981. [4] JohnJ. Craig. Introduction to Robotics Mechanics and Control. Addison-Wesley, Reading, MA, 1986. [5] J. Denavit and R.S. Hartenberg. A kinematic notation for lower-pair mechanisms based on matrices. Journal of Applied Mechanics, 22(2):215221, 1955. [6] D. Pieper. The Kinematics of Manipulators under Computer Control. PhD thesis, University of Stanford, Palo Alto, CA, 1968. [7] Anthony C. McDonald. Robot Technology: Theory, Design and Applications. Prentice-Hall, Englewoods Cliffs, NJ, 1986. [8] Richard M. Crowder. An anthropomorphic robotic end effector. Robotics and Autonomous Systems, 7(4):253268, 1991. [9] J. A. Domnguez-L pez. Intelligent Neurofuzzy Con o trol in Robotic Manipulators. PhD thesis, University of Southampton, Southampton, UK, 2004. [10] J. A. Domnguez-L pez, R. I. Damper, R. M. Crow o der, and C. J. Harris. Adaptive neurofuzzy control of a robotic gripper with external disturbances. In IEEE International Conference on Systems, Man and Cybernetics, pages 31933198, The Hague, Netherlands, October 2004. [11] Phillip John McKerrow. Introduction to Robotics. Addison-Wesley, Sydney, Australia, 1991.

tc=ctraj(p0,pf,10) tc(:,:,1) = 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 ... tc(:,:,5) = 1.0000 0 0 0 1.0000 0 0 0 1.0000 0 0 0 ... tc(:,:,10) = 1.0000 0 0 0 1.0000 0 0 0 1.0000 0 0 0

-0.4716 0.6084 -0.4444 1.0000

-1.0610 1.3690 -1.0000 1.0000


The reported toolbox is a robust and very complete instrument for academic and research purposes. Utilizing closed-form solutions to solve the inverse kinematic problem has shown to be a fast and reliable methodology. Comparing this approach with the numerical solution, the latter has frequently problems to nd an arm solution, despite the fact that the inverse kinematic problem is solvable. The toolbox has increased the number of trajectory options, giving to the user the freedom to choose from a simple trajectory to a more complex but sophisticated trajectory. Including, the option to select a behaviour in the end effector orientation. Robot manipulations need a end effector capable of gripping dexterity. Robotic end effectors are commonly required to hold and manipulate various objects. Therefore, the addition of a two-ngered gripper to the toolbox allows to simulate and evaluate the grasping operation of a object. The trajectory generation could affect the the gripping action. So, there has to be a interaction between the gripper controller and the trajectory generation. The acceleration controller has shown that by limiting the acceleration, the system performance can be improved.

Proceedings of the Sixth Mexican International Conference on Computer Science (ENC05) 0-7695-2454-0/05 $20.00 2005