Skip to content
LumenaryAcademy
Design 75 min

Mechanisms and linkages

How machines turn one motion into another — degrees of freedom, the four-bar linkage solved numerically, coupler curves, slider–cranks, cams, and gear trains up to the planetary sets in every automatic gearbox.

Code tested · 6AI-draftedAwaiting review by a mechanical engineer

Your guides: Chloe · The Designer, Margaret · The Test Engineer, Gideon · The Checker

MotivationH

Turning one motion into another

A motor turns. A piston slides. A windscreen wiper swings back and forth. An excavator bucket curls, a sewing-machine needle stabs up and down in step with a shuttle below, and a car's wheel moves up and down over a bump while staying nearly upright. Almost every machine has to turn one motion, usually steady rotation, into another, and the parts that do it are mechanisms: rigid links joined so that they can move only in the ways the designer intends.

This lesson is about kinematics, the geometry of motion, without yet asking what forces cause it (that was rigid-body dynamics). You will count how many ways a mechanism can move, solve the position of a four-bar linkage with Newton's method, trace the curves its coupler draws, compute the violent accelerations inside an engine, shape a cam so that it does not hammer its follower, and work out the ratios of the planetary gear sets inside automatic gearboxes and hybrid cars.

DefinitionsH

Links, joints and degrees of freedom

Definition— link, joint and kinematic pair

A link is a body treated as rigid. A joint (or kinematic pair, in Franz Reuleaux's term from the 1870s) connects two links and allows some relative motion. Lower pairs have surface contact: the revolute joint (a pin, R) allows rotation, the prismatic joint (a slider, P) allows translation. Higher pairs have point or line contact, like a cam on its follower or two gear teeth, and allow rolling with or without sliding. A chain of links with one link fixed as the frame (the ground) is a mechanism.

A free rigid body in a plane has three degrees of freedom: two translations and one rotation. Each revolute or prismatic joint removes two of them; a higher pair that allows both rolling and sliding removes one.

Theorem— Grübler–Kutzbach mobility criterion (planar)

A planar mechanism with nn links (counting the ground), j1j_1 one-freedom joints (pins and sliders) and j2j_2 two-freedom joints (cam and gear contacts) has mobility

M=3(n−1)−2j1−j2,M = 3(n - 1) - 2j_1 - j_2,

the number of independent inputs needed to fix its position, provided the constraints are independent. In space, each body has six freedoms and the corresponding formula is M=6(n−1)−∑i(6−fi)M = 6(n - 1) - \sum_i (6 - f_i) over joints of fif_i freedoms.

A four-bar linkage has 4 links and 4 pins: M=9−8=1M = 9 - 8 = 1, so one motor drives it. A triangle of three bars has M=0M = 0: it is a structure, the truss of trusses and frames. A five-bar linkage has M=2M = 2 and needs two motors, which is how some drawing robots and parallel pick-and-place arms work.

IntuitionH

The four-bar linkage

The four-bar is the simplest and most useful closed linkage: the ground link (length r1r_1) between two fixed pivots, an input crank (r2r_2), the coupler (r3r_3) that floats between the moving pins, and an output rocker or follower (r4r_4). Any point on the coupler, extended as a triangle or plate, traces a coupler curve, and these curves are wonderfully varied: ovals, figures of eight, teardrops and shapes with nearly straight stretches.

O2O4ABPθ2θ4μground r1crank r2coupler r3rocker r4
A four-bar linkage drawn at a crank angle θ2 = 60°, to scale for the crank–rocker in the program (ground 100, crank 30, coupler 90, rocker 70 mm). The coupler point P rides on a plate fixed to the coupler. The transmission angle μ between the coupler and the rocker measures how effectively the coupler can turn the rocker.

Whether the crank can turn all the way round depends only on the link lengths. Let ss and ll be the shortest and longest links and pp, qq the other two.

Theorem— Grashof condition

If s+l≤p+qs + l \le p + q, at least one link can rotate fully relative to the others (a Grashof linkage). Then the linkage is a crank–rocker if the shortest link is the crank, a double crank (drag link) if the shortest link is the ground, and a double rocker if the shortest link is the coupler. If s+l>p+qs + l > p + q, no link can turn fully: every motion is a rocking motion.

When s+l=p+qs + l = p + q exactly, the linkage passes through a flat change point where it can switch between assembly modes, a configuration designers usually avoid. Grashof published the condition in 1883; Franz Reuleaux's large collection of teaching models from the same period, now at Cornell University, still shows these motions beautifully.

Solving the position: loop closure

Treat each link as a vector. Going round the loop from O2O_2 via AA and BB to O4O_4 and back along the ground brings you to where you started:

r2eiθ2+r3eiθ3−r4eiθ4−r1=0.r_2 e^{i\theta_2} + r_3 e^{i\theta_3} - r_4 e^{i\theta_4} - r_1 = 0.

Its real and imaginary parts are two nonlinear equations in the two unknown angles θ3\theta_3 and θ4\theta_4. A closed-form solution exists (Freudenstein's equation of 1954 is the classic), but the numerical approach generalises to every linkage: guess the angles, linearise the equations with their Jacobian matrix, solve for a correction, and repeat. That is Newton's method, and it converges in a handful of steps from a good guess. Stepping the crank in small increments and starting each solve from the last answer keeps the solution on the same assembly branch: for most input angles there are two ways to assemble the linkage (open and crossed), and a careless solver can jump between them.

The transmission angle μ\mu, between coupler and rocker, measures how much of the coupler's force turns the rocker. Near 90° it is ideal; near 0° or 180° the coupler pushes almost along the rocker and the linkage binds or chatters. A common rule of thumb keeps μ\mu between about 40° and 140°.

ComputationC

Computing it: mobility and the four-bar by Newton's method

python
import numpy as np

def mobility(n_links, full_joints, half_joints=0):
    """Grubler-Kutzbach mobility of a planar mechanism (the ground counts as a link)."""
    return 3 * (n_links - 1) - 2 * full_joints - half_joints

print("four-bar linkage      M =", mobility(4, 4))
print("slider-crank          M =", mobility(4, 4))     # 3 pins + 1 sliding joint
print("five-bar linkage      M =", mobility(5, 5))
print("triangle (a truss)    M =", mobility(3, 3))
print("cam with roller       M =", mobility(4, 3, 1))   # the roller's own spin is a passive freedom

# A crank-rocker four-bar (mm): ground r1, crank r2, coupler r3, rocker r4
r1, r2, r3, r4 = 100.0, 30.0, 90.0, 70.0
s, l = min(r1, r2, r3, r4), max(r1, r2, r3, r4)
p_plus_q = r1 + r2 + r3 + r4 - s - l
print(f"\nGrashof: s + l = {s + l:.0f} <= p + q = {p_plus_q:.0f}? {s + l <= p_plus_q}")

def solve_position(t2, guess, tol=1e-12):
    """Newton-Raphson on the loop-closure equations for (theta3, theta4)."""
    t3, t4 = guess
    for it in range(50):
        f = np.array([r2 * np.cos(t2) + r3 * np.cos(t3) - r4 * np.cos(t4) - r1,
                      r2 * np.sin(t2) + r3 * np.sin(t3) - r4 * np.sin(t4)])
        J = np.array([[-r3 * np.sin(t3),  r4 * np.sin(t4)],
                      [ r3 * np.cos(t3), -r4 * np.cos(t4)]])
        step = np.linalg.solve(J, -f)
        t3, t4 = t3 + step[0], t4 + step[1]
        if np.max(np.abs(step)) < tol:
            return t3, t4, it + 1
    raise RuntimeError("Newton did not converge")

guess = (np.radians(40), np.radians(100))       # a rough sketch of the open configuration
print("\ncrank   coupler   rocker   transmission   Newton")
print("theta2  theta3    theta4   angle mu       steps")
for deg in range(0, 360, 30):
    t2 = np.radians(deg)
    t3, t4, its = solve_position(t2, guess)
    guess = (t3, t4)                              # start the next step from here: stays on this branch
    mu = np.degrees(t4 - t3)                      # transmission angle: between coupler and rocker
    print(f"{deg:5d}  {np.degrees(t3):7.1f}  {np.degrees(t4):7.1f}   {mu:9.1f}      {its}")

# Fine sweep for the rocker's swing and the extreme transmission angles
t2s = np.radians(np.arange(0, 360.5, 0.5))
guess = solve_position(0.0, (np.radians(40), np.radians(100)))[:2]
t4s, mus = [], []
for t2 in t2s:
    t3, t4, _ = solve_position(t2, guess)
    guess = (t3, t4)
    t4s.append(np.degrees(t4))
    mus.append(np.degrees(t4 - t3))
print(f"\nrocker swings from {min(t4s):.1f} to {max(t4s):.1f} deg: {max(t4s) - min(t4s):.1f} deg of swing")
print(f"transmission angle (coupler to rocker) ranges from {min(mus):.1f} to {max(mus):.1f} deg")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

The counts come out as expected, including M=2M = 2 for the cam with a roller follower: the extra freedom is the roller spinning on its pin, a passive freedom that does not affect the follower's motion. The linkage satisfies Grashof (130≤160130 \le 160) with the shortest link as the crank, so it is a crank–rocker. Newton's method converges in five steps at every crank angle in the table, the rocker swings through 51.8° (from 92.0° to 143.8°), and the transmission angle stays between 50.0° and 108.0°, comfortably inside the 40°–140° rule of thumb.

Worked examplesH

Coupler curves and straight lines

Before electric motors and linear guides, making a point move in a straight line was a serious problem: a steam engine's piston rod had to move straight, but the beam that drove it swung in an arc. James Watt's "parallel motion" of 1784 was a linkage whose coupler point moves almost straight over a useful stroke; he was proud of it all his life. Pafnuty Chebyshev in Russia studied how well such linkages could approximate a line, which led him to the polynomials named after him. Today, nearly-straight coupler curves are still used where a cheap pinned linkage must replace a sliding guide.

One elegant example is Hoeken's linkage, a crank–rocker with ground 2, crank 1, coupler 2.5 and rocker 2.5 units, whose coupler point lies on the coupler extended to 5 units from the crank pin. The program solves its position in closed form, by intersecting two circles, and plots the curve.

python
import numpy as np

# Hoeken's linkage: a crank-rocker whose coupler point traces a nearly straight line.
# Proportions: ground 2, crank 1, coupler 2.5, rocker 2.5; the coupler point P lies on the
# coupler line extended, 5 units from the crank pin. Scale: 1 unit = 40 mm.
u = 40.0
r1, r2, r3, r4, rp = 2 * u, 1 * u, 2.5 * u, 2.5 * u, 5 * u

def coupler_point(t2):
    """Closed-form position: crank pin A, rocker pin B by intersecting two circles, then P."""
    A = np.array([r2 * np.cos(t2), r2 * np.sin(t2)])
    O4 = np.array([r1, 0.0])
    d = np.linalg.norm(O4 - A)
    a = (r3**2 - r4**2 + d**2) / (2 * d)          # distance from A along A->O4 to the chord
    h = np.sqrt(r3**2 - a**2)
    e = (O4 - A) / d
    B = A + a * e + h * np.array([-e[1], e[0]])   # the upper of the two assemblies
    return A + rp * (B - A) / r3

t = np.radians(np.arange(0, 360, 2.0))
P = np.array([coupler_point(ti) for ti in t])

# Small ASCII plot of the coupler curve (x to the right, y upwards; y is stretched about 3x)
W, H = 64, 20
x0, x1 = P[:, 0].min(), P[:, 0].max()
y0, y1 = P[:, 1].min(), P[:, 1].max()
grid = [[" "] * W for _ in range(H)]
for x, y in P:
    col = int((x - x0) / (x1 - x0) * (W - 1))
    row = int((y1 - y) / (y1 - y0) * (H - 1))
    grid[row][col] = "*"
print("coupler curve of Hoeken's linkage:")
for row in grid:
    print("|" + "".join(row) + "|")
print(f"x from {x0:.0f} to {x1:.0f} mm, y from {y0:.0f} to {y1:.0f} mm")

# How straight is the flat part? Take the points over the crank angles where P moves
# along it, and fit a straight line.
flat = (np.degrees(t) >= 120) & (np.degrees(t) <= 240)
xs, ys = P[flat, 0], P[flat, 1]
k, c = np.polyfit(xs, ys, 1)
dev = ys - (k * xs + c)
print(f"\ncrank 120-240 deg: P travels {xs.max() - xs.min():.0f} mm along x")
print(f"best-fit line slope {k:.4f}; largest deviation from it {np.abs(dev).max():.2f} mm")
speed = np.hypot(np.diff(xs), np.diff(ys))
print(f"distance per 2-degree step: {speed.min():.2f} to {speed.max():.2f} mm (nearly constant speed)")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

The curve is a flattened loop with one nearly straight side. While the crank turns through the third of a revolution from 120° to 240°, the coupler point travels 109 mm along a line from which it never strays by more than 0.22 mm, and at an almost constant speed: 1.79 to 1.87 mm per 2° of crank. That makes it useful for walking machines, where the straight stretch is the foot on the ground, and for feeding mechanisms that must push material at a steady rate. Theo Jansen's wind-driven Strandbeest walkers on Dutch beaches use a more elaborate single-freedom leg linkage, found by computer search, on the same principle.

Finding link lengths that make a coupler point pass through chosen positions is linkage synthesis, a field founded by Ludwig Burmester in the 1880s, now done with numerical optimisation and with algebraic methods that find every solution of the synthesis equations.

ExplanationH

Slider–cranks and cams

The slider–crank

Replace the rocker of a four-bar by a slider and you have the slider–crank, the mechanism of every piston engine, reciprocating compressor and pump. With crank radius rr, connecting rod ll and crank angle θ\theta from top dead centre, the piston pin's distance from the crank centre is

x=rcos⁡θ+l2−r2sin⁡2θ.x = r\cos\theta + \sqrt{l^2 - r^2\sin^2\theta}.

The piston speeds up and slows down twice per revolution, and because the rod is not infinitely long, the motion is not simple harmonic: the acceleration at top dead centre is rω2(1+r/l)r\omega^2(1 + r/l), larger than the rω2(1−r/l)r\omega^2(1 - r/l) at bottom dead centre. These accelerations, multiplied by the piston's mass, are the shaking forces that engine designers balance with counterweights and with the arrangement of cylinders.

Cams

A cam is a shaped disc or cylinder that pushes a follower through any motion the designer chooses: rise, dwell, return, dwell. Cams open the valves of most car engines, drive packaging and textile machines, and time the mechanisms inside clocks and music boxes. The follower may be a knife edge, a roller or a flat face, and it is held against the cam by a spring or by a groove.

Ofollowerbase circle (dashed)0120180300360cam angle (degrees)20risedwellreturnfollower lift s (mm)
Left: a disc cam turning about O pushes a roller follower up in its guide; the dashed circle is the base circle. Right: the follower displacement over one revolution of the cam: a 20 mm cycloidal rise over 120°, a dwell, a cycloidal return over 120°, and a dwell, computed from the motion law in the program.

Choosing the motion law for each rise and return is the heart of cam design. The follower's acceleration, multiplied by its mass, is a force; a sudden jump in acceleration is a shock that excites vibration and noise. A rise at constant velocity is the worst: the velocity jumps at each end, so the acceleration is momentarily infinite and the follower is hammered. A simple harmonic rise has smooth velocity but jumps in acceleration where it meets the dwells. A cycloidal rise has zero velocity and zero acceleration at both ends, at the price of a higher peak acceleration, and is the usual choice for fast cams; polynomial laws (the 3-4-5 polynomial, for example) and splines give designers finer control.

The pressure angle, between the follower's line of motion and the normal at the contact point, plays the part the transmission angle played for linkages. A large pressure angle pushes the follower sideways in its guide and can jam it; designers usually keep it below about 30° for a translating roller follower, and the main way to reduce it is a larger cam.

python
import numpy as np

# 1. Slider-crank of a small engine: crank radius r, connecting rod l, 6000 rev/min.
r, l, rpm = 0.040, 0.140, 6000.0               # m
w = 2 * np.pi * rpm / 60                       # rad/s
step = np.radians(0.25)
th = np.arange(0, 2 * np.pi, step)
x = r * np.cos(th) + np.sqrt(l**2 - (r * np.sin(th))**2)   # piston pin, measured from crank centre
dt = step / w
v = (np.roll(x, -1) - np.roll(x, 1)) / (2 * dt)            # central differences, wrapping round
a = (np.roll(x, -1) - 2 * x + np.roll(x, 1)) / dt**2
i_bdc = len(th) // 2
print(f"stroke {1000 * (x.max() - x.min()):.0f} mm, mean piston speed {2 * 2 * r * rpm / 60:.1f} m/s")
print(f"peak piston speed {np.abs(v).max():.1f} m/s at crank angle {np.degrees(th[np.argmax(np.abs(v))]):.1f} deg")
print(f"|acceleration| at top dead centre    {abs(a[0]):7,.0f} m/s^2 "
      f"(r w^2 (1 + r/l) = {r * w**2 * (1 + r / l):,.0f}), about {abs(a[0]) / 9.81:,.0f} g")
print(f"|acceleration| at bottom dead centre {abs(a[i_bdc]):7,.0f} m/s^2 (r w^2 (1 - r/l) = {r * w**2 * (1 - r / l):,.0f})")

# 2. Cam follower: a rise of h = 20 mm over beta = 120 deg of cam rotation, between two dwells.
#    s(u) with u = theta / beta from 0 to 1; derivatives with respect to the cam angle theta.
h, beta = 20.0, np.radians(120)
u = np.linspace(0, 1, 2001)
laws = {
    "constant velocity": (h * u,
                          h / beta * np.ones_like(u),
                          np.zeros_like(u)),
    "simple harmonic":   (h / 2 * (1 - np.cos(np.pi * u)),
                          h * np.pi / (2 * beta) * np.sin(np.pi * u),
                          h * np.pi**2 / (2 * beta**2) * np.cos(np.pi * u)),
    "cycloidal":         (h * (u - np.sin(2 * np.pi * u) / (2 * np.pi)),
                          h / beta * (1 - np.cos(2 * np.pi * u)),
                          2 * np.pi * h / beta**2 * np.sin(2 * np.pi * u)),
}
cam_rpm = 600
w2 = (2 * np.pi * cam_rpm / 60) ** 2
print(f"\nrise law             s' at ends   s'' at ends   peak |s''|   peak accel at {cam_rpm} rpm")
print("                     (mm/rad)     (mm/rad^2)    (mm/rad^2)   (m/s^2)")
for name, (s, ds, d2s) in laws.items():
    peak = np.inf if ds[0] > 0 else np.abs(d2s).max()   # a velocity jump means an infinite acceleration
    print(f"{name:18s}   {ds[0]:9.2f}   {d2s[0]:10.2f}    {peak:9.2f}    {peak * w2 / 1000:8.1f}")
print("(the dwells on either side have s' = s'' = 0, so any non-zero value at the ends is a jump)")

# 3. Pressure angle of an in-line roller follower: tan(phi) = s' / (Rp + s)
s, ds, _ = laws["cycloidal"]
for Rp in [30.0, 40.0, 60.0]:                  # prime-circle radius, mm
    phi = np.degrees(np.arctan(ds / (Rp + s)))
    print(f"prime circle {Rp:4.0f} mm: largest pressure angle on the cycloidal rise {phi.max():.1f} deg")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

The engine has an 80 mm stroke and a mean piston speed of 16 m/s, but the piston peaks at 26.1 m/s at 75° after top dead centre, not at 90°, because of the rod's angularity. At top dead centre it decelerates at about 20 300 m/s², over 2000 times the acceleration of gravity, against 11 280 m/s² at bottom dead centre. For the cam, the constant-velocity rise is ruled out by its velocity jump; the harmonic rise has the lowest peak acceleration, 89 m/s² at 600 rev/min, but jumps to it from zero; the cycloidal rise peaks higher, at 113 m/s², but starts and ends smoothly. Its pressure angle reaches 26.1° on a 30 mm prime circle and falls to 15.4° on a 60 mm one.

DefinitionsH

Gear trains and planetary gears

The gears of machine elements combine into trains. In a simple train, each shaft carries one gear and the idlers in between only change the direction; the ratio is set by the first and last gears. In a compound train, a shaft carries two gears of different sizes, and the ratios of the meshing pairs multiply: three stages of 3:1, 3:1 and 4:1 give 36:1. A reverted compound train brings the output back onto the input's axis, as in a clock or a lathe gearbox.

Definition— planetary (epicyclic) gear set

A sun gear in the centre meshes with several planet gears, which also mesh with an internally toothed ring; the planets' pins are carried by a carrier. With tooth counts zsz_s and zrz_r (where, for standard gears, zr=zs+2zpz_r = z_s + 2z_p), the speeds of sun, ring and carrier obey the Willis equation

ωs−ωcωr−ωc=−zrzs,\frac{\omega_s - \omega_c}{\omega_r - \omega_c} = -\frac{z_r}{z_s},

which is the fixed-axis ratio seen by an observer riding on the carrier. The set has two degrees of freedom: hold one member (or drive two) and the third's speed follows.

sunplanetcarrierring
A planetary gear set seen along its axis: sun (24 teeth), three planets (30 teeth) on a carrier, and a ring (84 teeth). Holding the ring and driving the sun turns the carrier 4.5 times slower; holding any other member gives a different ratio.
python
from fractions import Fraction as Fr

# Compound train: ratios of the meshing pairs multiply.
pairs = [(17, 51), (20, 60), (18, 72)]          # (driver teeth, driven teeth)
ratio = 1
for zd, zn in pairs:
    ratio *= Fr(zn, zd)
print(f"compound train {pairs}: overall ratio {ratio} = {float(ratio):.1f} : 1")

# A planetary (epicyclic) gear set: sun S, three planets P, ring R, carrier C.
zs, zp = 24, 30
zr = zs + 2 * zp                                 # the planets must fit between sun and ring
N = 3
print(f"\nsun {zs}, planets {zp}, ring {zr} teeth; (zs + zr) / N = {(zs + zr) / N:g}"
      f" -> {'equally spaced planets fit' if (zs + zr) % N == 0 else 'planets cannot be equally spaced'}")

def willis(ws=None, wr=None, wc=None):
    """Solve (ws - wc) / (wr - wc) = -zr / zs for the one unknown speed (pass None for it)."""
    k = Fr(-zr, zs)
    if ws is None:
        return wc + k * (wr - wc)
    if wr is None:
        return wc + (ws - wc) / k
    return (ws - k * wr) / (1 - k)              # carrier

print("\ninput        output     held     ratio (input speed / output speed)")
print(f"sun          carrier    ring     {str(Fr(1) / willis(ws=1, wr=0)):>6}  = {float(1 / willis(ws=1, wr=0)):6.3f}")
print(f"ring         carrier    sun      {str(Fr(1) / willis(ws=0, wr=1)):>6}  = {float(1 / willis(ws=0, wr=1)):6.3f}")
print(f"sun          ring       carrier  {str(Fr(1) / willis(ws=1, wc=0)):>6}  = {float(1 / willis(ws=1, wc=0)):6.3f}  (reverses)")
print(f"carrier      ring       sun      {str(Fr(1) / willis(ws=0, wc=1)):>6}  = {float(1 / willis(ws=0, wc=1)):6.3f}  (overdrive)")

# With no member held, the set adds speeds: a power-split device.
for ws, wr in [(3000, 0), (3000, 1000), (-1000, 1500)]:
    print(f"sun {ws:5d} rpm, ring {wr:5d} rpm -> carrier {float(willis(ws=ws, wr=wr)):7.1f} rpm")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

One small set gives four useful ratios: 4.5 (sun in, carrier out, ring held), 9/7 ≈ 1.29 (ring in, carrier out), −3.5 (a reverse, with the carrier held) and 7/9 ≈ 0.78 (an overdrive). An automatic gearbox chains two to four such sets and selects ratios by engaging clutches and brakes that hold or join their members, without ever taking the gears out of mesh. With nothing held, the carrier's speed is a weighted average of the sun's and ring's, ωc=(zsωs+zrωr)/(zs+zr)\omega_c = (z_s\omega_s + z_r\omega_r)/(z_s + z_r), so the set adds two motions; that is how a hybrid car's power-split device blends an engine and two electric machines, and how a car's differential, with bevel gears in place of the ring and sun, lets two wheels turn at different speeds round a corner. The tooth counts also pass the assembly check: three planets can be equally spaced only if (zs+zr)/3(z_s + z_r)/3 is a whole number, here 36.

History & global context

Mechanisms in everyday machines and in history

Look for these mechanisms and you will find them everywhere:

  • Windscreen wipers. A motor-driven crank–rocker turns rotation into a sweep; a parallelogram linkage then moves the second arm in step.
  • Excavators and loaders. Hydraulic cylinders act as prismatic joints in linkages; the bucket is curled by a four-bar that multiplies the cylinder's stroke into a large rotation.
  • Car suspensions. A double-wishbone suspension is a four-bar in each view, designed so that the wheel moves up and down while its tilt and track change in controlled ways.
  • Bicycles. The derailleur moves the chain on a parallelogram linkage; the pedals and legs form a slider–crank-like chain; hub gears are planetary sets.
  • Folding furniture, umbrellas, pliers and car jacks. Linkages that change shape, multiply force or lock flat.

Mechanisms are old. Hero of Alexandria described gear trains and cam-like devices in the first century; the Antikythera mechanism, a bronze astronomical calculator from Greece of about the second century BC, has some thirty surviving gears. Ismail al-Jazari, working in the Artuqid court at Diyarbakır, described a crank and connecting rod, segmental gears and a camshaft in his Book of Knowledge of Ingenious Mechanical Devices in 1206. Su Song's astronomical clock tower in Kaifeng, China, completed in 1088, used a chain drive and an escapement to turn an armillary sphere. Franz Reuleaux in Berlin gave the subject its modern vocabulary in 1875, and the robotics of today extends it: a robot arm is a chain of links and joints whose position is solved exactly as in this lesson, in forward kinematics and inverse kinematics.

Common misconceptionsH

Common misconceptions

Misconception

"Grübler's formula always gives the true mobility." It counts constraints, assuming they are independent. Special geometry (parallel links, equal lengths) can make a mechanism with M=0M = 0 move, or leave extra passive freedoms such as a spinning roller.

Misconception

"The position of a linkage is determined by its input angle alone." Usually there are two assembly branches (open and crossed), and a numerical solver must be kept on the right one, by continuation from the last answer.

Misconception

"A piston moves in simple harmonic motion." Only with an infinitely long connecting rod. A real rod makes the motion faster near top dead centre, with peak acceleration rω2(1+r/l)r\omega^2(1 + r/l) there.

Misconception

"A smooth-looking cam profile gives smooth motion." What matters is the follower's velocity and acceleration as functions of cam angle. A constant-velocity rise looks smooth and hammers the follower at each end.

Exercises

Exercises

1. Mechanisms and linkages

Warm-upHuman

A planar six-bar linkage has six links (counting the ground) joined by seven pin joints and no other joints. According to the Grübler–Kutzbach criterion, what is its mobility MM?

2. Mechanisms and linkages

CoreHuman

A four-bar linkage has a ground link of 40 mm, a crank of 100 mm, a coupler of 80 mm and a follower of 70 mm. What kind of linkage is it?

Choose one

3. Mechanisms and linkages

Warm-upHuman

A motor at 1500 rev/min drives a compound gear train with three meshing pairs: 15 teeth driving 45, then 12 driving 48, then 20 driving 50. What is the output speed in rev/min?

4. Mechanisms and linkages

CoreHuman

A planetary gear set has an 18-tooth sun and a 72-tooth ring. The ring is held fixed and the sun is driven at 1500 rev/min. How fast does the carrier turn, in rev/min?

5. Mechanisms and linkages

CoreHuman

A packaging machine's cam must lift a follower 15 mm between two dwells at high speed, with as little vibration as possible. Which motion law is the best starting point for the rise?

Choose one

6. Mechanisms and linkages

StretchHuman

A compressor's slider–crank has a crank radius of 50 mm and a connecting rod 200 mm long, and runs at 3000 rev/min. What is the magnitude of the piston's acceleration at top dead centre, to the nearest m/s²?

7. Mechanisms and linkages

CoreComputational

Write solve_four_bar(r1, r2, r3, r4, t2, guess) that returns (t3, t4), the coupler and rocker angles in radians, for a four-bar with ground r1, crank r2, coupler r3 and rocker r4 at crank angle t2. Use Newton's method on the loop-closure equations

r2cos⁡θ2+r3cos⁡θ3−r4cos⁡θ4−r1=0,r2sin⁡θ2+r3sin⁡θ3−r4sin⁡θ4=0,r_2\cos\theta_2 + r_3\cos\theta_3 - r_4\cos\theta_4 - r_1 = 0, \qquad r_2\sin\theta_2 + r_3\sin\theta_3 - r_4\sin\theta_4 = 0,

starting from guess = (t3, t4), so that the answer stays on the assembly branch nearest the guess. Raise RuntimeError if it fails to converge in 50 iterations.

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

8. Mechanisms and linkages

CoreComputational

Write classify_four_bar(ground, crank, coupler, rocker) that returns one of the strings "crank-rocker", "double-crank", "double-rocker" or "non-Grashof", using the Grashof condition s+l≤p+qs + l \le p + q and which link is the shortest. Treat a linkage whose shortest link is the rocker as a crank–rocker too (the rocker can turn fully, so the roles are swapped). You may assume the shortest link is unique.

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

Further reading and resources

  • KMODDL, the Kinematic Models for Design Digital Library · Cornell UniversityPhotographs, videos and descriptions of Franz Reuleaux's nineteenth-century collection of mechanism models.
  • Strandbeest · Theo JansenThe Dutch artist's wind-powered walking machines, built from a single-degree-of-freedom leg linkage.
  • The Kinematics of Machinery · Franz Reuleaux · 1876The English translation of Reuleaux's founding book on kinematic pairs and chains; in the public domain.
  • Design of Machinery · Robert L. NortonA standard textbook on linkage synthesis and analysis, cams and gear trains.
  • FreeCAD documentation wikiThe Assembly workbench can animate joints and check the motion of a linkage.