Is it better to use Jacobians to compute IK when a closed form for IK is available?

Question

I hope that my question is not too stupid ... but I have a hard time to understand why Jacobians computed from forward kinematics would allow a better and smoother control than using pure inverse kinematics equations when they exist.

I understand that Jacobian may map linearly cartesian coordinates to joints coordinates but why we could'nt get the same result whith small increments of inverse kinematics ?

With the example of a 3 joints robot having to reach the pose (x , y, z) from the current pose (u, v, w), if this new pose requires to increase its joints state from (q0, q1, q2) to (q0 + 10, q1 -20, q2 + 40) and if I order to my robot these joint goals computed form inverse kinematic equations with velocities (v0, v1, v2) proportional to the ordered angular motion (v0, v1 = v0 x 2, v2 = v0 x 4), why this would not provide the same result than those with jacobian control ?

Thanks for helping my understanding.

---

Ugo,

Many thanks for your detailed explanation. I understand from your reply that Jacobian is used for a large set of tasks I probably don't know. I realized that my questiion is not accurate enough. Practically, I am working on a demonstrator to get a proof of concept on microsurgery. I have designed a 4 DOF slave for which I have found FK and IK closed form equations. This slave is controlled with a custom master control for which I have also the FK equations. I applied a scaling factor from master to slave in order to convert large master motion to smaller slave motion. The scalling is applied on cartesian space. Since this is made within a loop, the motion increments are small. Each joints velocity is, at each step, ordered to be proportionnal to each joint course to get a synchronized movement. I get a decent result but not as smooth as I expected (hardware is presumed optimally tuned). It is why I consider using only velocity control with numerical jacobians, but I don't understand why it could be better than using small steps of IK with proprtionnal velocities...

---

Ugo,

Thank you for interest. The slave robot is essentially made of 3 revolute joints which rotation axis are respectively q0: around z (= gravity axis), q1 and q2 both turn around x and q3 rotates around y axis. At the output of motor q3 we have an universal joint linking to a bar which end is constrained in a second universal joint itself linked to the ground. The master control have similar structure. Right hand rule.

Here are the FK equations: ( Where p4 is the position of the center of rotation of the universal joint linked to q3 output and p2p4 the constant distance beetween p4 and the center of rotation of motor q1)

 1- first we compute position of p4:
 p4x = qx - q1 * s0 - q2 * s0 * c1 + p2p4 * (s0 * s1 + s0 * c1)
 p4y = qy + q2 * s1 + p2p4 * (c1 * s1)
 p4z = qz + q1 * c0 + q2 * c0 * c1 - p2p4 * ( s1 * c0 +* c0 * c1)

2- Compute translation and orientation of link p4 to distal pivot (which is the tool)
pE is the part of the link outside the distal pivot (pivotX, pivotY, pivotZ). 
(note that pivotZ = 0 by construction):
Ia = sqrt((pivotX - p4x)^2 + (pivotY - p4y)^2 + p4z ^2 )
Ib = IL - Ia //(Translation outside the distal pivot point)
Ibr = Ib / Ia
pEx = pivotX + (pivotX - p4x) * Ibr //(vector projection)
pEy = pivotY + (pivotY - p4y) * Ibr
pEz = -p4z * Ibr
fk.tr = Ib
## tool orientation:
alpha = atan((pEyy - p4y) / (pEz - p4z))
beta = atan((pEx - p4x) / sqrt((pEz - p4z)^2 + (pEy - p4y)^2))
//(gamma, the tool rotation is directly given by q3).

A loop read at 650 Hz the pose of the 4 DOF master control, compute the FK and if a change occurs, apply a scaling factor to the cartesian change of mastercontrol and send a new pose to the slave by adding to its IK order the cartesian change to the starting pose of the slave. Velocity orders are sent with values proportionnal to the change in joints values. Basically the slave is position controlled, velocties are used only to synchronize joints motions. This works, but the global motion is not as smooth as got when motors are individually controlled. And here (microsurgery), smoothness is very important.

Answer 1

Saying in general terms that with the Jacobian we can obtain smoother control and thus better movements is an overstatement if it is not referred to a specific context where one is able to analyze all the implications in depth.

In fact, we can do great things by knowing the exact IK anyway.

From a broader perspective, the Jacobian is a linear map relating the velocities of the joints with the velocity of the robot's end-effector, hence it is intimately connected to the control problem where we are asked to generate suitable velocity commands (we are dealing here with the kinematics and not with the dynamics) to achieve a goal.

With this in mind, your following definition of the Jacobian is not quite right:

I understand that Jacobian may map linearly cartesian coordinates to joints coordinates but why we could'nt get the same result whith small increments of inverse kinematics ?

That said, we need to consider other essential aspects that are more difficult to be implemented, if not impossible, with a closed-form IK:

1. Generally, the movements we aim to perform through a controller are not only specified in the joint space but rather also in the task space. For example, we need to move linearly with the tip while staying away from the joint bounds. To this end, we ought to use the Jacobian to trade off these requirements.
2. Nowadays, robots tend to be equipped with lots of degrees of freedom so that closed-form solutions to IK do not even exist.

Answer 2

My question was probably badly formulated and, finally, I think the right answer is the following:

When a master-slave system is used and when the kinematics or geometry of both systems are not similar, we need to use jacobians for master-slave control due to the intrinsic dynamic differences between master and slave joints motion. So, algebraic IK is not usefull except for reaching some specific points without master control.

Howhever, if the master control velocity is low regarding the control loop speed (= increment betwwen two frames), controlling slave by using IK (if exists) and ordering velocities proportionnal to joint courses is equivalent to using pure jacobian based control.