Robot Kinematics
Introduction
Suppose that you’ve been given a robot to program. Unless you want the robot to be a paperweight, a legitimate use-case for many robots, you’ll want to have the robot take action in the world. One early hurdle to this is the difference between the space you can control the robot in, frequently referred to as joint space or configuration space, and the space in which it is easy to define tasks often referred to as task space, operational space, or Cartesian space. Reasoning in joint space is difficult for a couple of reasons. First, the dimension of the joint space will be equal to the number of joints of the robot. Thus as the number of joints increase the space that must be reasoned about becomes more difficult to comprehend. If you’re wondering how to reason about high dimensional spaces here’s some insight from Geoff Hinton:
To deal with hyper-planes in a 14-dimensional space, visualize a 3-D space and say “fourteen” to yourself very loudly. Everyone does it.
Another oddity of thinking in joint space is the change of obstacle shape in joint space. A very simple illustration of this is provided by Ron Alterovitz’s configuration space visualizer:
A rather simple polygon object and a robot arm with 2 joints are depicted on the left. On the right, the same polygon object but transformed into joint space. It has become a very difficult to describe entity that wraps around the boundary of the joint space. In contrast, reasoning about how the robot should move in task space is significantly easier, this is in large part because its how we natively think about the world. Rarely, do I think to myself, “Well, I want my elbow to go to 46 degrees so that I may pick up my coffee cup.” Thus we’re left with two choices, use a method to translate between the two spaces, or develop the ability to reason in high dimensions with obtuse shapes. Generally, the field has decided that when humans are involved it’s best to reason in task space. Let’s take a look at how to convert between these two spaces.
Forward Kinematics
A mapping from joint angles to Cartesian positions.
Forward kinematics calculates the Cartesian position of a point on the robot given a set of joint values for all the joints in a robot’s kinematic chain. Generally, we will use $x$ to denote Cartesian positions and $\theta$ to denote a vector of joint angles. Then we can define the forward kinematics problem as:
$$x = f(\theta).$$ Where $f(\theta)$ is a function that is either provided to us by the lovely mechanical engineers that built the robot or one that we must derive on our own. While this might sound difficult it’s not terribly difficult if you break each joint down into an offset and an angle from the previous joint. Once you’ve created the transformation matrices for all of the joints with respect to the previous joint they can all be multiplied together to provide the position of the desired point on the robot. Forward kinematics is relatively straightforward, it just takes attention to detail to make sure all of the frames are correct.
Inverse Kinematics
A mapping from Cartesian position to joint angles.
Inverse Kinematics calculates the joint angles that the robot must attain in order to reach the desired Cartesian position. When the kinematics are simple and well understood Inverse Kinematics can be solved analytically, which allows for all solutions to be calculated quickly. For more complex systems numerical approaches are typically used. One downside of numerical approaches is that they can only return one solution for every optimization. They are also slower than analytical approaches, but in general still fast enough for most uses. One way to quantify the complexity of a kinematic chain is to count the number of degrees of freedom (DoF). As the number of DoF increase the chain is more complex, and above 6 DoF the chain is guaranteed to have an infinite number of solutions. Approximating this conituum of solutions is a difficult problem that will be discussed in later posts after establishing some more mathematical foundations.