1.4 Robot kinematics

Robot kinematics is the study of robot motion without worrying about the forces that cause that motion. Think of it as the geometry of movement: given a robot's structure, how do its parts move through space? This matters because every time an autonomous robot reaches for an object, drives along a path, or positions a tool, kinematics is what translates high-level goals into actual joint movements.

This topic covers forward and inverse kinematics, transformation matrices, the Jacobian, trajectory planning, redundancy, dynamics formulations, and mobile robot kinematics.

Forward and inverse kinematics

Forward and inverse kinematics are two sides of the same problem.

Forward kinematics starts with known joint angles (or positions) and computes where the end-effector ends up in space. You know how each joint is set, and you want to find the resulting position and orientation of the robot's hand or tool tip.

Inverse kinematics works the other way: you specify a desired end-effector position and orientation, and then solve for the joint angles needed to get there. This is typically the harder problem because multiple joint configurations can produce the same end-effector pose, and sometimes no solution exists at all.

Autonomous robots need both. Forward kinematics tells the robot "given my current joint readings, where is my hand right now?" Inverse kinematics answers "what joint angles do I need to reach that object on the table?"

Link length and twist angle

These are two of the four Denavit-Hartenberg (DH) parameters used to systematically describe a robot's geometry.

• Link length ($a$) is the distance between two adjacent joint axes, measured along their common normal. It defines the physical size of each link (like the length of an upper arm or forearm segment).
• Twist angle ($\alpha$) is the angle between two adjacent joint axes, measured in a plane perpendicular to the common normal. It captures how one joint axis is rotated relative to the next.
  • A twist angle of 0° means the joint axes are parallel. A twist angle of 90° means they're perpendicular.

Link offset and joint angle

The other two DH parameters complete the picture:

• Link offset ($d$) is the distance between two adjacent common normals, measured along the joint axis. It accounts for any displacement along the joint axis (for instance, the physical thickness of a joint housing).
• Joint angle ($\theta$) is the angle between the previous link and the current link, measured in a plane perpendicular to the joint axis. For revolute joints, $\theta$ is the variable that changes as the joint rotates.
  • A joint angle of 0° typically indicates a reference or "home" configuration.

Together, $a$, $\alpha$, $d$, and $\theta$ uniquely define the kinematic relationship between any two adjacent links. Every link-joint pair in the robot gets its own set of four DH parameters, and from those you can build the full kinematic model.

Homogeneous transformation matrices

Homogeneous transformation matrices (HTMs) are 4×4 matrices that encode both the position and orientation of one coordinate frame relative to another in a single compact representation.

Why 4×4 instead of 3×3? A 3×3 rotation matrix handles orientation, and a 3×1 translation vector handles position, but combining them into a 4×4 matrix lets you chain transformations together with simple matrix multiplication. To find the end-effector's pose relative to the base, you just multiply the HTMs for each link in sequence:

$T_0^n = T_0^1 \cdot T_1^2 \cdot \ldots \cdot T_{n-1}^n$

In robotics, HTMs describe the spatial relationship between the base frame, each intermediate link frame, and the end-effector frame.

Rotation matrices

Rotation matrices are the 3×3 upper-left portion of an HTM. They describe the orientation of one frame relative to another while preserving vector lengths and angles.

The three basic rotation matrices correspond to rotations about each principal axis:

• Roll: rotation about the x-axis
• Pitch: rotation about the y-axis
• Yaw: rotation about the z-axis

You can combine rotations by multiplying their matrices together. Order matters here: rotating first about x then about z gives a different result than z then x.

Translation vectors

Translation vectors are 3×1 vectors that describe the linear displacement between the origins of two coordinate frames. Inside an HTM, the translation vector occupies the first three rows of the fourth column:

$T = \begin{bmatrix} R & d \\ 0 & 1 \end{bmatrix}$

where $R$ is the 3×3 rotation matrix and $d$ is the 3×1 translation vector. The bottom row $[0 \; 0 \; 0 \; 1]$ is what makes the matrix "homogeneous" and allows the multiplication trick to work.

Kinematic chains and robot configurations

A kinematic chain is a series of rigid links connected by joints. It forms the skeleton of any robot manipulator or mobile robot. The number and type of joints determine the robot's degrees of freedom (DOF) and its range of motion.

A robot's configuration is the specific arrangement of all its links and joints at a given instant. If you know every joint angle or position, you know the full configuration.

Open vs closed kinematic chains

• Open kinematic chains have a single sequence of links from a fixed base to a free end-effector. Most industrial robotic arms are open chains. They offer large workspaces and relatively simple control.
• Closed kinematic chains contain one or more loops, meaning there are multiple structural paths connecting the base to the end-effector. Delta robots and parallel platforms are examples. They provide higher stiffness, accuracy, and load capacity, but with a smaller workspace.

Serial vs parallel robot configurations

• Serial configurations are open chains where each joint is actuated independently, one after another. Most industrial robots (like a 6-axis arm) are serial. They have large workspaces but tend to have lower stiffness since errors accumulate along the chain.
• Parallel configurations use multiple kinematic chains connecting the base to the end-effector simultaneously. The Stewart platform (used in flight simulators) and the delta robot (used in high-speed pick-and-place) are classic examples. Actuators sit on or near the base, giving high stiffness and accuracy but a smaller workspace.
• Hybrid configurations combine serial and parallel elements to balance the advantages of both, such as the Tricept robot.

Jacobian matrix

The Jacobian matrix relates joint velocities to end-effector velocities. If you know how fast each joint is moving, the Jacobian tells you how fast (and in what direction) the end-effector is moving in Cartesian space.

For a robot with $n$ joints and a 6-DOF end-effector (3 for position, 3 for orientation), the Jacobian is a $6 \times n$ matrix. It depends on the current joint configuration, so it changes as the robot moves.

The Jacobian is central to motion planning, control, and performance analysis.

Velocity kinematics

Velocity kinematics uses the Jacobian to map between joint-space and Cartesian-space velocities.

• Forward velocity kinematics: Given joint velocities, compute end-effector velocity.

$\dot{x} = J(q) \, \dot{q}$

where $\dot{x}$ is the end-effector velocity vector, $J(q)$ is the Jacobian at configuration $q$, and $\dot{q}$ is the joint velocity vector.

• Inverse velocity kinematics: Given a desired end-effector velocity, compute the required joint velocities.

$\dot{q} = J(q)^{-1} \, \dot{x}$

This only works when the Jacobian is square and non-singular. For non-square or singular cases, you'll need the pseudoinverse or other techniques.

Singularities and manipulability

Singularities are configurations where the Jacobian loses rank. At a singularity, the robot loses the ability to move the end-effector in one or more directions. Common examples include a fully extended arm (where you can't push the end-effector further outward) or a folded-back configuration where two joint axes align.

Manipulability quantifies how easily the robot can move and exert forces in different directions at a given configuration. The manipulability ellipsoid, derived from the Jacobian (specifically from $J J^T$), visualizes this: a round ellipsoid means the robot can move equally well in all directions, while a flat or elongated one means motion is easy in some directions but difficult in others.

Avoiding singularities during trajectory planning is critical. Near a singularity, joint velocities can spike to extreme values even for slow end-effector motion.

Trajectory planning

Trajectory planning generates a time-based path for the robot to follow, specifying positions, velocities, and accelerations over time. A good trajectory is smooth (no sudden jerks), respects the robot's physical limits, and avoids obstacles.

Common approaches include:

• Point-to-point motion: Specify only the start and goal configurations. The path between them is computed automatically.
• Interpolation: Define several waypoints and generate a smooth curve through them using polynomial functions (cubic splines are common) or other interpolation methods.
• Optimization-based planning: Formulate the problem as an optimization, minimizing criteria like total time, energy consumption, or jerk (rate of change of acceleration).

Joint space vs Cartesian space

• Joint space planning specifies trajectories for each joint individually over time. It's computationally simpler because you're directly controlling the actuators, and you don't need to solve inverse kinematics at every time step. However, the end-effector path in Cartesian space may not be intuitive or straight.
• Cartesian space planning specifies the end-effector's path in 3D space, then uses inverse kinematics to convert that into joint trajectories. This gives you direct control over the end-effector's motion (e.g., moving in a straight line), but it's more computationally expensive and can run into singularity problems.

The choice depends on the task. If you need the end-effector to follow a precise path (like welding a seam), use Cartesian space. If you just need to get from point A to point B efficiently, joint space often works fine.

Trapezoidal velocity profile

A trapezoidal velocity profile is one of the simplest and most common motion profiles. It gets its name from the shape of the velocity-vs-time graph.

The three phases are:

1. Acceleration phase: The robot accelerates from rest to a maximum velocity at a constant rate.
2. Constant velocity phase: The robot cruises at maximum velocity for a set duration.
3. Deceleration phase: The robot decelerates from maximum velocity back to rest at a constant rate.

This profile ensures continuous velocity (no instantaneous jumps) and keeps acceleration bounded. You can tune the maximum velocity, acceleration rate, and phase durations based on the robot's motor limits and task requirements. The tradeoff is that acceleration changes instantaneously at the transitions between phases, producing finite jerk at those points. For smoother motion, S-curve profiles add gradual acceleration ramps.

Redundant manipulators

A redundant manipulator has more degrees of freedom than the minimum needed for its task. A task in 3D space with full position and orientation control requires 6 DOF. A 7-DOF robot arm is therefore redundant by one degree.

The degree of redundancy (DOR) is:

$DOR = n - m$

where $n$ is the number of joints and $m$ is the number of task-space DOF.

Redundancy is valuable because the extra DOF can be used for:

• Obstacle avoidance: The robot can reconfigure its elbow or intermediate links to dodge obstacles while keeping the end-effector on target.
• Singularity avoidance: Extra joints let the robot steer away from singular configurations.
• Secondary optimization: Minimize joint torques, stay away from joint limits, or maximize manipulability, all while still performing the primary task.

Kinematic redundancy

Kinematic redundancy means that for a given end-effector pose, there are infinitely many valid joint configurations. This makes inverse kinematics underdetermined: the math gives you a family of solutions rather than a single answer.

You need additional criteria or constraints to pick one solution from the infinite set. That's where redundancy resolution comes in.

Redundancy resolution techniques

Several methods exist for choosing a unique joint configuration:

• Pseudoinverse method: Uses the Moore-Penrose pseudoinverse of the Jacobian ($J^+$) to find the joint velocity solution with the smallest norm. This minimizes the overall joint velocity magnitude but doesn't optimize anything else.
• Null-space projection: The null space of the Jacobian represents joint motions that don't affect the end-effector. You can project secondary objectives (like avoiding joint limits or obstacles) into this null space, optimizing them without disturbing the primary task.
• Optimization-based methods: Formulate the problem as constrained optimization (e.g., quadratic programming), balancing multiple criteria and hard constraints simultaneously. More computationally expensive but more flexible.

The right technique depends on the application, real-time requirements, and what secondary objectives matter most.

Dynamics in robot kinematics

While kinematics studies motion without forces, dynamics brings forces and torques into the picture. Dynamics accounts for mass, inertia, gravity, friction, and external loads to predict how a robot actually moves under applied forces, or what forces are needed to produce a desired motion.

Two main formulations are used:

Lagrangian formulation

The Lagrangian approach is energy-based. You compute the Lagrangian $L = K - P$, where $K$ is kinetic energy and $P$ is potential energy. Applying the Euler-Lagrange equation to $L$ produces the equations of motion as a set of second-order differential equations.

This method is systematic and conceptually clean, making it a good choice for deriving equations symbolically and analyzing robots with many DOF. The downside is computational cost: computing energy terms and their partial derivatives can be expensive, especially for real-time control of robots with many joints.

Newton-Euler formulation

The Newton-Euler approach applies Newton's second law ($F = ma$) and Euler's rotational equations to each link individually. It uses a recursive algorithm:

1. Forward pass (base to end-effector): Propagate velocities and accelerations outward through each link.
2. Backward pass (end-effector to base): Propagate forces and torques back inward.

This recursive structure makes the Newton-Euler method computationally efficient and well-suited for real-time control. The tradeoff is that it's less intuitive to set up and requires careful tracking of forces, torques, and motion variables for every link.

Kinematics of mobile robots

Mobile robot kinematics differs from manipulator kinematics because the robot's base isn't fixed. Instead of computing where an end-effector goes, you're computing how the whole robot moves through its environment based on wheel or leg velocities.

Key challenges include dealing with slip, terrain variation, and motion constraints imposed by the robot's drive mechanism.

Holonomic vs non-holonomic constraints

• Holonomic constraints depend only on position (not velocity). A robot with holonomic constraints can move instantaneously in any direction. Omnidirectional robots with Mecanum wheels are holonomic: they can strafe sideways without turning first.
• Non-holonomic constraints involve velocity and can't be reduced to position-only equations. A car is the classic example: it can't slide sideways. It must steer and drive forward to change lateral position. Differential-drive robots and car-like robots are non-holonomic.

Holonomic robots are more maneuverable but mechanically more complex. Non-holonomic robots are simpler to build but require more sophisticated path planning to account for their motion constraints.

Ackermann steering geometry

Ackermann steering is the standard geometry for car-like robots (and actual cars). The front wheels steer while the rear wheels remain fixed in orientation.

The key insight is that during a turn, the inner front wheel must turn more sharply than the outer front wheel so that all four wheels trace arcs around a single common center point. This avoids tire scrubbing and slip.

The relationship between the steering angles is:

$\cot{\delta_{o}} - \cot{\delta_{i}} = \frac{w}{l}$

where $\delta_o$ is the outer wheel angle, $\delta_i$ is the inner wheel angle, $w$ is the track width (distance between left and right wheels), and $l$ is the wheelbase (distance between front and rear axles).

Ackermann steering assumes a flat surface and relatively low speeds. At high speeds or on rough terrain, more complex models that account for tire dynamics and slip become necessary.