Velocity kinematics in 3D



We're going to talk now about the shape of the Jacobian matrix. A robot manipulator has in general got N joints, N could be a small number, but the robot might have only two joints. The robots might have 100 joints. I want to understand what's the effect of the number of joints on the shape of the robot manipulator Jacobian matrix, because Jacobian has one column per joint. So, an N joint robot has a manipulator Jacobian matrix with N columns.

The Jacobian has one row for each element of the spatial velocity vector. So, for motion in three dimensions, the spatial velocity vector has got 6 elements – 3 for translational velocity and 3 for angular velocity. And, that means the Jacobian matrix always has six rows. So, the robot manipulator Jacobian matrix is a 6 by N matrix.
This robot only has 4 joints and we call it an under actuated robot. And, that means that its tasks base doesn't cover all of the set SE3. Although the end effector can achieve all positions within the limits of its works space, it's not able to achieve all possible orientations.

So, for example, when the robot in a configuration like this, it can adjust the orientation of the gripper like that. But, it's impossible for it to adjust the orientation of the gripper in that direction or in that direction.
Let's consider the case of a robot with only 4 joints. This is often referred to as an under-actuated robotic system. In this case, the robot Jacobian has got 6 rows and 4 columns. The Jacobian is not square, and therefore, we cannot invert it. But that's not necessarily a problem. A robot like this is unable to rotate the tool about the x or y axis. It's just the way it's constructed. It cannot rotate the tool in that way. So, we can strike out these elements of the robot’s spatial velocity. Since we can't control velocity around these axes, let's just remove them.
If I do that, then I should also remove the corresponding rows in the Jacobian matrix. And, the result now is a 4 by 4 system. And now, the Jacobian matrix is invertible. Given a desired spatial velocity, it's a smaller spatial velocity vector now. We can compute the robot joint angle velocities. We need to obtain that spatial velocity.

Here's a robot that has perhaps 100 joints. In this case, the manipulator Jacobian is a 6 by 100 matrix. It's not square and we cannot invert it. We can compute something called the pseudo-inverse and that's often denoted by the symbol plus.
The pseudo-inverse is computed in this way. This looks quite straight forward until you remind yourself that the term inside here is in fact 100 by 100 matrix and we need to invert that. And computationally, that's not a simple thing to do. However, if we use this pseudo-inverse, we can write an expression that relates the desired spatial velocity of the robots end effector to the required velocity of each of its 100 joints.
But we can do an extra thing as well in case of a robot like this – a robot with more than 6 joints. We can add this term here and we refer to this as the null-space motion. It's pretty multiplied by this matrix expression here, which effectively filters it, so that this motion does not affect the pose of the robot end effector. We can use this motion which doesn't affect the end effective pose to do things like change the shape of the arm. We can also use it to do things like move a robot joint away from its limit towards the middle part of its working range.
So, we use these extra joint velocity motion to change the shape of the arm, move joints away from the limits. At the same time not affecting the end effective pose. It's a pretty neat trick. This matrix N is referred to as the null space of the Jacobian matrix. It is the set of vectors that pre-multiplied by the manipulator Jacobian matrix, give a result of zero. In this particular case, if the robot had 100 joints, then the null space would be of dimension 94. That's 100 minus 6. So, N would be a 6 by 94 element matrix.
I'm going to import the model of a redundant robot that moves in 3D and that's the model hyper 3D. And, I'm going to ask for a robot with 20 joints. To illustrate, for example, I need to choose a set of joint angles. I need to choose 20 numbers. I know that if they're all equal to zero, the robot will be at a singularity.

So, what I'm going to do is to choose 20 random numbers. I'm going to use the MATLAB built-in function rand. So, this is my joint angle vector – 20 random numbers in the range 0 to 1. And, I can plot this particular joint angle configuration for a robot and this is what it looks like. If I can just have a bit of a look around and we can see that it's pointing slightly upwards and it's got a few bends and twists in it.
Now that I have the set of joint angles and I have a robot model, I can compute a Jacobian matrix. And, we've seen how to do that for many other types of robots. I used the Jacobian method and I pass in the set of joint angles. And, this is the Jacobian matrix. We can see that it's got 6 rows and it's got 20 columns because there are 20 joints.

If I tried to invert this matrix, I'm going to get an error because the matrix is not square. MATLAB is telling me I can't do that but I can compute the pseudo-inverse. And, that's computed using the MATLAB built-in function pinv, and parse in the Jacobian matrix. And, this is the result of the pseudo-inverse. And, we can see that we have here in the workspace now a 20 by 6 matrix, the pseudo-inverse of the Jacobian matrix.
Now, we talked about the null space motion. And, in order to compute the null space motion, we need to compute the null space of the Jacobian matrix itself and MATLAB has the function to do that.

It's the function null and I parse in the Jacobian matrix and here is the null space matrix. The null space matrix has 20 rows and only 14 columns. 14 comes from 20, which is the number of columns in the original Jacobian minus 6. And 6 is the rank of that original Jacobian. That's the number of unique columns in the Jacobian matrix. So, there were 6 unique columns and there were 14 columns that exist in the null space of that Jacobian. 14 plus 6 equals 20, the original number of columns.

Let's summarize some of the different shapes that a robot Jacobian matrix can have. For the case of a robot with 6 joints, we say that the robot is fully actuated. The Jacobian will be a square 6 by 6 matrix. And a robot with 6 joints is able to fully access all poses within a SE3.
That means, any position and any arbitrary orientation. For the case of a robot with less than 6 joints, which we refer to as an under-actuated robot, the Jacobian will be a 6 by N matrix. It will have more rows than it has columns.
This means that the robot cannot access all possible poses within a SE3. And, in order to use the Jacobian for control purposes, we need to square it up and we do that by removing some spatial degrees of freedom. We eliminate some rows in the Jacobian matrix so that it becomes a 5 by 5 or 4 by 4 Jacobian matrix which is then invertible. In the case of a robot with more than 6 joints, which we refer to as an over actuated robot, the Jacobian matrix has more columns than it has rows. It's a 6 by N matrix.
In order to use the Jacobian matrix for control purposes, we take its pseudo-inverse. The great advantage of a robot like this is that we can think about having spare joints and we can use some of these spare joints to do what we call null space motion. And, while we hold the ineffective pose constant, we can adjust all of the joints to change the shape of the arm or move the joints away from motion limits.


There is no code in this lesson.

A robot manipulator may have any number of joints. We look at how the shape of the Jacobian matrix changes depending on the number of joints of the robot.

Professor Peter Corke

Professor of Robotic Vision at QUT and Director of the Australian Centre for Robotic Vision (ACRV). Peter is also a Fellow of the IEEE, a senior Fellow of the Higher Education Academy, and on the editorial board of several robotics research journals.

Skill level

This content assumes high school level mathematics and requires an understanding of undergraduate-level mathematics; for example, linear algebra - matrices, vectors, complex numbers, vector calculus and MATLAB programming.

More information...

Rate this lesson


Check your understanding

Leave a comment

Previous lesson Next lesson