Forward kinematics (FK) is the pose of the end-effector given the joint coordinates.It can be computed for robots of theDHRobot orERobot class

T = robot.fkine(q)

whereT is anSE3 instance.

T = robot.fkine_all(q)

whereT is anSE3 instance with multiple values, the pose of each link frame, from the baseT[0] to the end-effectorT[-1].

Inverse kinematics (IK) is the joint coordinates required to achieve a given end-effector pose. The function is not unique, and there may be no solution.

All methods take optional method-specific arguments and return a named tuple

sol = ikine_XX(T)

The elements of the tuplesol include at least:

These IK solvers minimise a scalar measure of error between the current and the desired end-effector pose. The measure is the squared-norm of a 6-vector comprising:

• translational error (a 3-vector)
• the orientation error as an Euler vector (angle/axis form encoded as a 3-vector)

The SciPy based mimimizers are slow because they use a scalar cost measure and must numerically compute a Jacobian in order to solve.

puma=rtb.models.DH.Puma560()T=puma.fkine(puma.qn)sol=puma.ikine_XX(T)print("residual = ",np.linalg.norm(T-puma.fkine(sol.q)))

Forikine_min without joint limits we can request different optimization methods (the default isSLSQP) to be used

The methodsNewton-CG,dogleg,trust-ncg,trust-exact,trust-krylov all require a Jacobian matrix to be passed.

Forikine_minwith joint limits we can request different optimization methods (the default istrust-constr) to be used

Interesting attempting constrained optimisation using methodsNelder-Mead,CG,BFGS does not raise an error, they just silently ignore the constraints. Once again, the methodsNewton-CG,dogleg,trust-ncg,trust-exact,trust-krylov all require a Jacobian matrix to be passed.

puma=Panda()T=SE3(0.7,0.2,0.1)*SE3.OA([0,1,0], [0,0,-1])sol=puma.ikine_XX(T)print("residual = ",np.linalg.norm(T-puma.fkine(sol.q)))

Only theDH/Puma560 robot model has an analytic solution methodikine_a(T, config).

Such a method could be added to any other robot class, including anycustom class that you might write.

For the class of robots that have 6 joints and a spherical wrist, the Toolbox provides additional support. First define a method in your class

def ikine_a(self, T, config):    return self.ikine_6s(T, config, func)

where:

• ikine_6s is a method of theDHRobot class
• func is a local functionfunc(robot, T, config) that solves for the first three joints, givenT which is the pose of the wrist centre with respect to the base.
• config is a pose configuration string. For example, the Puma robot defines this as

but you can choose whatever is appropriate for your robot.

All robot classes support abase transform. This defines the pose of the robot's base with respect to the world frame and is by default null transform (identity matrix).

DHRobot objects support atool transform. This defines the tip of the robot's end-effector with respect to the final link frame, which is typically inside the spherical wrist. By default this is a null transform (identity matrix).Note that some robot models describe the tool transform using DH parameters, seeSection 5 of this tutorial.

DHRobot support a joint offset which is important since often the required zero-angle configuration is not what the user or robot controller considers the zero-angle configuration, due to the constraints imposed by DH notation.

For forward kinematics the joint offsets are added to yield the "kinematic" joint angles, and then the forward kinematics are computed. This occurs within theA method of theDHLink class. This means that the offsets are the kinematic joints angles corresponding to the user's zero-angle configuration.

Jacobian calculation use theA method so joint offsets are taken into consideration.

Numerical inverse kinematics use thefkine method so joint offsets are taken into consideration. Analytical inverse kinematics explicitlysubtract the offset in theikine_6s method.

This is just speculation so far...

T = robot.fkine(q, link)

wherelink is either a reference to a Link subclass object, or the name of the link.

q = robot.ikine_XX(T, link)

wherelink is either a reference to a Link subclass object, or the name of the link.

Ideally we would be able to express other constraints by passing in a callable

q = robot.ikine_XX(T, lambda q: 0.1 * q[2]**2)

which adds a cost for elbow bend, for example.