Frames, Transforms and Arm Kinematics

Frames and poses

Robot software is mostly bookkeeping of where things are. A frame is a coordinate system attached to something (the world, the robot, a camera, a tool), and a pose is the position and orientation of one frame relative to another. Two things are used constantly: transforming a point from one frame to another, and chaining poses (the camera relative to the base, the base relative to the world).

Convention	Rule
Units	Meters and radians (SI): never degrees or millimeters inside the software (REP 103)
Axes	Right-handed: x forward, y left, z up; rotation positive counter-clockwise about an axis looking down on it
Naming	“Pose of B in A” (TAB) transforms points from B coordinates to A coordinates
Camera frames	Optical frames use z forward, x right, y down: a different convention from the robot body, so a fixed rotation links them

Transforms in 2D

In a plane a pose is (x, y, θ). A point (p_x, p_y) in the robot’s frame is at, in the world frame:

x_w = x + p_x cos θ − p_y sin θ    y_w = y + p_x sin θ + p_y cos θ

Rotations in 3D: matrices, Euler angles, quaternions

In 3D an orientation has three degrees of freedom, and there are several ways to write it. Each has a use:

Form	What it is	Good for	Watch out for
Rotation matrix	3 × 3, orthogonal, determinant +1	Rotating vectors, composing, no ambiguity	Nine numbers for three degrees of freedom; drifts from orthogonal if multiplied many times
Euler angles (roll, pitch, yaw)	Three angles about axes in a stated order	Human-readable input and display	The order and axes must be stated (ROS: fixed axes x, y, z = roll, pitch, yaw); gimbal lock near pitch = ±90°
Axis-angle / rotation vector	A unit axis and an angle (or axis × angle)	Robot controllers, small rotations, optimization	Angle of 0 has no defined axis
Unit quaternion (x, y, z, w)	Four numbers with x² + y² + z² + w² = 1	Storing, composing and interpolating (slerp) orientations; ROS messages	q and −q are the same rotation; normalize after many operations

Quaternion for a rotation of angle φ about the unit axis (a_x, a_y, a_z): q = (a_x sin φ/2, a_y sin φ/2, a_z sin φ/2, cos φ/2)

import numpy as np
from scipy.spatial.transform import Rotation as R

r = R.from_euler("xyz", [90, 0, 90], degrees=True)       # roll 90, pitch 0, yaw 90 (extrinsic, ROS order)
r.as_quat()            # (x, y, z, w): the order ROS uses
r.apply([1, 0, 0])     # rotate a vector
(R.from_euler("z", 90, degrees=True) * R.from_euler("x", 90, degrees=True)).as_matrix()   # composition

Homogeneous transforms and chains of frames

A rotation R and a translation p are packed into one 4 × 4 homogeneous transform T = [R p; 0 1], so that a point in homogeneous form (x, y, z, 1) is moved by one matrix multiplication, and a chain of frames is a product of matrices: T_world←tool = T_world←base T_base←arm … T_wrist←tool. The inverse is simple: T⁻¹ = [R^T −R^T p; 0 1].

• Order matters: matrix products do not commute. Read a chain from the left as “from the world down to the tool”.
• tf2 does this for you: it multiplies the transforms along the tree between any two frames at a given time (see ROS 2 in Practice).
• Check by round trips: a point transformed to a frame and back must return unchanged; a transform times its inverse must be the identity.
• Fixed mounts (the camera on the arm) are measured once by calibration: hand-eye calibration solves A X = X B for the unknown camera-to-gripper transform from several poses.

Forward kinematics

Forward kinematics computes the tool pose from the joint angles. For a planar arm with link lengths L₁ and L₂ and joint angles θ₁ and θ₂:

x = L₁ cos θ₁ + L₂ cos(θ₁ + θ₂)    y = L₁ sin θ₁ + L₂ sin(θ₁ + θ₂)

With L₁ = 0.4 m, L₂ = 0.3 m, θ₁ = 30° and θ₂ = 45°: x = 0.4 cos 30° + 0.3 cos 75° = 0.3464 + 0.0776 = 0.4241 m; y = 0.2000 + 0.2898 = 0.4898 m. Forward kinematics always has exactly one answer.

• For a general arm describe each joint with four numbers, the Denavit-Hartenberg (DH) parameters (link length a, twist α, offset d, angle θ), and multiply the four-by-four matrices: the URDF or MoveIt does this from the robot description.
• The zero position of each joint and its direction of positive rotation must match between the model and the real robot; a sign error here is the most common cause of an arm that moves the wrong way.
• Joint encoders give the angles: the accuracy of the tool position is the sum of the angle errors times the link lengths, plus the errors in the link lengths themselves (calibrate them).

Inverse kinematics

Inverse kinematics (IK) finds the joint angles that put the tool at a given pose. It is harder: there may be no solution, one, several or infinitely many.

• Closed-form solutions exist for common arms (a six-axis arm with a spherical wrist has up to eight); they are fast and give all the solutions: choose the one nearest the current joints, within limits and clear of obstacles.
• Numerical IK iterates from a starting guess using the Jacobian (next section) and finds one solution: used for arms without a closed form and for redundant arms (KDL, TRAC-IK, IKFast, MoveIt’s solvers).
• Always check the result with forward kinematics, the joint limits and collisions.

The Jacobian: velocities, forces and singularities

The Jacobian J relates joint velocities to tool velocity: v = J q̇. For the two-link arm:

J = [ −L₁ sin θ₁ − L₂ sin(θ₁+θ₂), −L₂ sin(θ₁+θ₂) ; L₁ cos θ₁ + L₂ cos(θ₁+θ₂), L₂ cos(θ₁+θ₂) ]    det J = L₁ L₂ sin θ₂

θ₂	det J = L₁ L₂ sin θ₂	Fraction of the best
90°	0.1200	100 %
45°	0.0849	71 %
10°	0.0208	17 %
1°	0.0021	2 %

Near a singularity the joints must move enormously for a small tool motion. To move the tool at 0.2 m/s perpendicular to the arm needs roughly ω = v ÷ (L₁ sin θ₂): 0.50 rad/s at θ₂ = 90°, but 5.74 rad/s at 5°. Planners avoid the neighbourhood of singularities, and controllers limit joint speed there.

• Manipulability √det(J J^T) measures how far a pose is from a singularity: maximize it when choosing among IK solutions.
• Damped least squares: q̇ = J^T (J J^T + λ² I)⁻¹ v stays finite at a singularity at the cost of a small error in the tool motion.
• Orientation Jacobian: a full arm has a 6 × n Jacobian (three linear and three angular velocities).

Six-axis arms, redundancy and joint limits

Task	Degrees of freedom needed
Position only (x, y, z)	3
Position and orientation of a rigid tool	6
A planar arm placing a point (x, y)	2
A 7-joint arm (one redundant)	7: infinitely many solutions for a pose

• Six joints are enough to reach any position and orientation inside the workspace; the typical industrial arm has six (see Industrial Robotics).
• A spherical wrist (three joint axes meeting at a point) lets the position and orientation problems separate, giving the closed-form IK.
• Redundant arms (seven joints, or a mobile manipulator) have extra freedom, used to avoid obstacles, singularities and joint limits (null-space control).
• Joint limits and self-collision reduce the usable workspace and remove some IK solutions; the planner must check them.
• Wrist and shoulder singularities appear in every six-axis arm (wrist axes aligned, arm stretched, wrist over the base): programs that pass near them slow down or stop (see the singularity messages in your robot’s manual).
• Joint space versus Cartesian moves: a joint move goes in a curve in space and never meets a singularity; a straight-line Cartesian move needs IK at every point and can fail.

Kinematics in practice: tf2, MoveIt and calibration

• Describe the robot once in a URDF with accurate link lengths and joint axes (see Simulation and Digital Twins); robot_state_publisher turns joint states into the frame tree.
• MoveIt 2 uses the URDF for forward and inverse kinematics, collision checking and motion planning (OMPL, Pilz, STOMP).
• Calibrate: real link lengths and joint zero offsets differ from the CAD by fractions of a millimeter and a degree; a few millimeters of tool error at a meter’s reach come from 0.2° of joint error (1 m × 0.0035 rad = 3.5 mm). Industrial robots are calibrated at the factory; for others use a measuring arm or a laser tracker.
• Hand-eye calibration finds the camera pose relative to the gripper or the base, so that an object found in an image can be reached.
• Test with a pose you can check: command the tool to a point you can measure (a corner of a fixture) and compare.
• Name every frame clearly and draw the tree: most “wrong place” bugs are a transform applied in the wrong direction or the wrong frame.

Related

• Robotics Tools: the overview of this guide.
• Mobile Robot Kinematics and Odometry: the same ideas in 2D for wheeled robots.
• Motor Control, PID and Trajectories: following the joint trajectories that IK produces.
• ROS 2 in Practice: tf2 and the frame tree.
• Industrial Robotics and Structures and Strength of Materials: arm configurations, payloads and link stress.

FAQ

Should I use Euler angles or quaternions?

Use quaternions (or rotation matrices) in software and for storing and composing orientations; use Euler angles only for people to read and type. Always state the order and the axes.

Why does my inverse kinematics return no solution?

The target is outside the reachable workspace, at a distance the arm cannot reach, an orientation the wrist cannot make, or a pose that violates a joint limit. Check the reach, then the limits.

What is a singularity and why does the arm slow down?

A pose where the Jacobian cannot be inverted: the arm loses the ability to move in some direction, and the joint speeds needed for a small tool motion become huge. Controllers slow or stop there; planners avoid it.

How do I know a transform is in the right direction?

Test it with a point you can place by hand. A transform T_AB maps B coordinates into A; if the result is rotated or mirrored the wrong way, you have used the inverse.

References

• Craig, J. J., Introduction to Robotics: Mechanics and Control; Spong, M. W., Hutchinson, S. and Vidyasagar, M., Robot Modeling and Control.
• Murray, R. M., Li, Z. and Sastry, S. S., A Mathematical Introduction to Robotic Manipulation; Lynch, K. M. and Park, F. C., Modern Robotics (free online).
• ROS REP 103 and REP 105; MoveIt 2 and tf2 documentation; Kuipers, J. B., Quaternions and Rotation Sequences.

Last reviewed: October 2026. All values are computed in the page builder; check sign and zero conventions against your own robot.