LESSON

# Inverting the Jacobian Matrix

#### Share

#### Transcript

This is the linear relationship between joint angle velocity and end effector velocity that we worked out a moment ago. The Jacobian matrix here J is a two by two matrix and that means that it's very easy to invert, so we can write the expression like this. And what this is saying is if I know the end effector velocity that I want, and if I can compute the Jacobian matrix and then invert it, I can work out what joint angle velocities I need in order to achieve this particular end effector velocity and this is a very powerful thing. No matter what the end effector velocity is, I can always work out a set of joint angle velocities that will give me that end effector velocity.

We've previously worked out what the Jacobian matrix is for this simple, two link, planar manipulator and because it's only a two by two matrix, it's very easy to invert and the inverse looks like this. There's one slightly problematic aspect of this inverse Jacobian and that is this term here, when the second joint angle, Q2 is equal to zero, this inverse Jacobian becomes infinite. That might seem a little bit unusual but there's a pretty simple intuition behind this.

Let's have a look at the robot configuration where this occurs. So this is what the robot looks like when Q2 is equal to zero. And this particular configuration of the robot is often referred to as a singular pose because it introduces a singularity into the Jacobian matrix of the robot. A robot configuration like this is really exactly the same as a single link robot that looks like this, so this is a robot which only a single joint angle. And clearly a robot like this has got very, very limited motion. The end effector velocity can only ever be parallel to this blue vector here. That is tangential to the axis of the robot's link. It's not possible for the robot end effector to move in this direction at all and this is where the term singularity comes from. In this particular configuration of the robot, it's lost a degree of freedom. There is a direction in the robot's Cartesian workspace, in which it is impossible for the end effector to move.

Even if a joint angle in not exactly equal to zero; perhaps it's nearly zero, then we will still have problems in the directions that the robot is able to move. So a robot in this sort of configuration will find it difficult to move in this particular direction. We can compute the determinant of the Jacobian matrix and if it's equal to zero or if it's equal to small, that tells you that there is some motion direction for the robot that will be difficult or awkward. You can think about this in terms of your own arm; there are some configurations of the arm where you have the ability to move with almost equal velocity in many different directions and there are some other configurations of your arm, where it's really only possible to have velocity in one direction; for instance when you're trying to throw a ball, you put your arm into a configuration where you can have maximum velocity in the direction you want the ball to go, but almost no velocity component in direction orthogonal to that.

Another way to describe this situation is in terms of the condition number of the Jacobian. The condition number is a scalar that we can compute from any matrix and if the condition number is large it indicates that the matrix is close to being singular, that is it's determine is close to zero. You can consider this problematic situation of the Jacobian matrix in terms of it having either a small determinant or a large condition number. The condition number can be computed in MATLAB using the built in function "cond()".

By inverting the Jacobian matrix we can find the joint velocities required to achieve a particular end-effector velocity, so long as the Jacobian is not singular.

### Skill level

Undergraduate mathematics

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.