Industrial robots,
from the ground up.

ISO 8373 defines an industrial robot as an automatically controlled, reprogrammable, multipurpose manipulator, programmable in three or more axes, either fixed in place or mounted on a mobile platform, for use in industrial automation. Four properties in that definition separate a robot from the rest of the automation on the shop floor:

The first one went to work in 1961: the Unimate, a hydraulic polar-coordinate arm built by Unimation (George Devol and Joseph Engelberger) and installed at General Motors in Trenton, New Jersey, where it unloaded hot die castings and welded them onto car bodies. The IFR's World Robotics 2025 report counts 4.66 million industrial robots in operation worldwide, 542,000 of them installed in 2024.

A robot is a programmable manipulator. A cobot is one built for collaborative applications. A mobile robot drives itself around. A service robot does useful work outside industrial automation.

A six-axis articulated robot is built roughly like a human arm with an odd wrist. Working up from the floor: a base that turns about the vertical (J1), a shoulder (J2) that lifts the upper arm (link 2), an elbow (J3) that bends the forearm (link 3), and a wrist of three more rotary joints (J4, J5, J6) that orient the tool. At the tip is the tool flange, a machined face whose bolt pattern follows ISO 9409-1 on most arms. The pattern is sized to the robot, so a gripper or torch with the matching pattern bolts straight on.

The TCP (tool centre point) is the point the robot is actually positioning: the fingertip of the tool, not the flange.

When you send the robot to (400, 200, 350) you are asking it to put the TCP there. Swap a 60 mm welding torch for an 80 mm sealant nozzle without changing the tool definition and every taught point is 20 mm off. That is why measuring the TCP is the first job on any new tool.

Reach, payload, repeatability, accuracy

Each layout favours one kind of motion. A SCARA is stiff vertically and slightly compliant horizontally, which is what pushing a pin into a PCB needs. A delta hangs upside down with its motors on the fixed base, so the moving platform is light enough to accelerate at 10 to 15 g. A six-axis arm can put a tool anywhere in its reach at any angle, which is why it is the general-purpose choice. The sixth tile, the cobot, is a six- or seven-axis arm built for a particular kind of application rather than a separate layout.

A rigid body floating in space has six degrees of freedom: three translations (X, Y, Z) and three rotations (often called roll, pitch and yaw). That is why most industrial arms have six axes: it is the minimum that puts a tool at any point in reach, at any orientation.

ISO 9787:2013 defines the standard set: World (the cell reference), Base (on the mounting surface), Mechanical interface (on the flange) and Tool (at the TCP). All of them are right-handed. Only the world frame is tied to gravity, with +Z pointing up. The base frame's +Z is normal to the mounting surface, so it points down on a ceiling-mounted arm, and the flange and tool frames have +Z pointing out of the flange. Every brand also gives you a programmable work-object frame fixed to the thing you are working on (a fixture, a pallet, a car body), so the whole program moves with the part when you re-measure that one frame.

How vendors name the same frames

Every controller on this site uses right-handed frames. Point your right thumb along +X and your index finger along +Y; your middle finger gives +Z. In the world frame +Z points up, against gravity, so if you stand facing +X, +Y is on your left. Where the world origin sits and which way +X faces is up to the integrator. Hover, tap or tab to an axis in panel A and the matching finger lights up.

The same rule tells you which way a joint turns. Point your right thumb along the joint axis and your fingers curl the way positive rotation goes. Panel B is a SCARA-style arm seen from above, so both axes point out of the page and positive is counter-clockwise. Pick J1 or J2, press Rotate + or Rotate − and check the arm against the gold curl arrow. The vendor decides which way each axis is positive, so on a real arm you still check the manual or the direction marks on the casting.

The maths has not changed in decades; the names have. ABB, KUKA, FANUC, UR, Yaskawa, Kawasaki and Mitsubishi each have their own words, but a singularity, a work-object shift or an orientation interpolation is one of the eight cards below on every brand. Once you know the card, the manual reads much faster.

Each card says what it does, in plain words with no derivation, and where you will meet it: the pendant screen, error or RAPID data type where the formula turns up. Filter by family (kinematics, orientation, motion and dynamics) if the grid is too much at once.

T = ⎡ R  t ⎤
    ⎣ 0  1 ⎦

T₀ₙ = T₀₁(θ₁) · T₁₂(θ₂) · ⋯ · Tₙ₋₁,ₙ(θₙ)

q = IK(T_target)

Rᵀ R = I    det(R) = +1

R = R_z(γ) · R_y(β) · R_x(α)

q = (w, x, y, z)    ‖q‖ = 1

v = J(q) · q̇       det(J) → 0  ⇒  singularity

v(t):  accel ▲    cruise ─    decel ▼
   ∫ v dt = displacement

Forward kinematics is the easy direction. The encoders give you every joint angle, and you want the position and orientation of the TCP in the base frame. There is exactly one answer, and it is a short chain of matrix multiplications.

The usual way to write it down is with Denavit-Hartenberg (DH) parameters, a convention from 1955 that attaches a frame to each joint and describes each link with four numbers (twist, length, offset, angle). Multiply the link transforms in order, then the tool transform, and you have base to TCP. The controller does this every interpolation cycle, so you never do it by hand. What you do need to know is that the answer depends on the link lengths and the tool offset: change the gripper without changing the tool data and the computed TCP is wrong.

IK is the hard direction. A six-axis arm has a closed-form solution when three consecutive axes meet at one point or are parallel (Pieper's condition). A spherical wrist meets it, and so does the UR layout with its three parallel axes. Such an arm has up to eight joint solutions for one TCP pose: two shoulder choices, two elbow choices and two wrist choices.

Every controller stores which solution a point was taught in. ABB calls it confdata, KUKA stores STATUS and TURN, and FANUC writes a configuration string such as F U T, 0, 0, 0. Switch the check off (ABB ConfL \Off, for example) and the controller takes whichever solution is nearest the current joints. Between two close points that can mean a 180° wrist flip, with the cable dress, and sometimes the tool, going into the fixture.

Each vendor names them differently, but every controller has all three:

Vendor command names

MoveJ pHome, v1000, fine, tool0;
MoveL pPick, v500,  fine, tool0;
SetDO doGripper, 1;
WaitTime 0.5;
MoveL pHome, v1000, fine, tool0;

PTP XHOME
$VEL.CP = 0.5
LIN XPICK
$OUT[1] = TRUE
WAIT SEC 0.5
LIN XHOME

movej([0, -1.57, 1.57, -1.57, -1.57, 0], a=1.4, v=1.05)
movel(p[0.4, 0.0, 0.3, 0, 3.14, 0], a=1.2, v=0.25)
set_digital_out(1, True)
sleep(0.5)

Blending: rounding the corners

A robot that stops dead at every taught point wastes cycle time. Blending lets the controller start the next move before the current one has reached its point, so it rounds the corner instead. You give a zone round the corner point; once the TCP is inside it, the controller is free to leave the taught path. The robot never actually reaches a blended point, so a point where something must happen exactly, such as a gripper closing on a part, gets fine.

Velocity profiles: trapezoidal or S-curve

No move runs at one speed. The controller ramps up from zero, cruises and ramps back down, and the shape of the ramp changes how the arm behaves. A trapezoidal profile switches acceleration on and off instantly, so jerk, the rate of change of acceleration, is infinite at each corner. The structure rings, the gripper shakes and a precise part takes longer to settle. An S-curve ramps the acceleration itself in and out, so jerk stays finite.

A singularity is a pose where the Jacobian, the matrix that turns joint speeds into TCP speed, loses rank. There is then a direction the TCP cannot move in, and near the pose a small TCP move in that direction needs very large joint speeds. A real controller reacts by slowing the path sharply or stopping the move with an error.

Without an end-effector the robot is an expensive way of moving a flange around. The main families:

ISO 10218-1:2025 covers what the robot maker must build into the robot. ISO 10218-2:2025 covers what the integrator must do to turn it into a safe cell or application. The 2025 revision moved the collaborative material from ISO/TS 15066, including the body-region contact limits, into ISO 10218-2. None of the robot program is a safety function: the e-stop, the guarding, the enabling device and any speed or force limits belong to the safety system, which is designed and validated on its own.

Stop categories (IEC 60204-1 §9.2.2)

The four ways to share a workspace

ISO/TS 15066 and the 2011 edition of ISO 10218 named four kinds of collaborative operation. The 2025 edition reorganises the wording around collaborative applications, but these four are still how integrators describe the options.

Power and force limits (ISO/TS 15066 Annex A)

These values come from the pain-onset study behind ISO/TS 15066, run by the University of Mainz for the German social accident insurance (DGUV). They are quasi-static limits, for a body part clamped between the robot and something solid. Transient limits, for a free impact where the body can move away, are twice these values, except that no transient contact is allowed with the skull, forehead or face.

In most cells the PLC runs the sequence: conveyors, fixtures, sensors and the robot. The robot runs the program the PLC asks for, reports when it has finished and waits for the next request. ABB, KUKA, FANUC, UR and Yaskawa cells all use some version of the six-step handshake below; the signal names change. Click a step or drag the scrubber to walk through it.

How the major vendors name those signals

The PLC side of the handshake in Structured Text

On the PLC side this is a small state machine: write the program number, raise START, wait for BUSY, then wait for DONE with a watchdog. A CASE statement is the usual way to write it. See the matching entry in the ST Language Guide (control-flow → CASE) and the Symbol Reference (TON timers for the wait-for-done watchdog).

(* PLC side of the robot handshake. Mirrors the timing diagram above.
   The watchdog is called on every scan: a TON only times while it is called. *)
WatchdogTimer(IN := (State = WAIT_DONE), PT := T#30S);

CASE State OF
  IDLE:
    IF NewJob THEN
      ProgNo  := JobNumber;        (* write program number bits *)
      State   := REQ_START;
    END_IF;

  REQ_START:
    Start := TRUE;                 (* raise edge on START output *)
    IF Robot_Busy THEN             (* robot acknowledged *)
      State := WAIT_DONE;
    END_IF;

  WAIT_DONE:
    Start := FALSE;                (* drop START once Busy is high *)
    IF Robot_Done THEN
      State := CLEANUP;
    ELSIF WatchdogTimer.Q THEN
      State := FAULT;              (* robot took too long *)
    END_IF;

  CLEANUP:
    ProgNo := 0;
    State := IDLE;

  FAULT:
    (* alarm, operator intervention *)
    ;
END_CASE;

Which fieldbus carries the signals