507 Ways to Move Part 12: Cranks, Linkages & Four-Bar Mechanisms

1. The Slider-Crank Mechanism

The slider-crank converts rotation to reciprocation (or vice versa). It consists of a crank (rotating link), a connecting rod (coupler), and a slider (piston) constrained to move in a straight line.

1.1 Kinematics of Slider-Crank

import math

def slider_crank_kinematics(r, l, theta_deg, omega):
    """
    Compute piston position, velocity, and acceleration
    for an inline slider-crank mechanism.

    r: crank radius (mm)
    l: connecting rod length (mm)
    theta_deg: crank angle from TDC (degrees)
    omega: crank angular velocity (rad/s)

    Returns: (position, velocity, acceleration)
    """
    theta = math.radians(theta_deg)
    n = l / r  # rod ratio (typically 3-5 for engines)

    # Piston displacement from TDC (approximate formula)
    x = r * ((1 - math.cos(theta)) + (1 - math.cos(2*theta)) / (2*n))

    # Piston velocity
    v = r * omega * (math.sin(theta) + math.sin(2*theta) / (2*n))

    # Piston acceleration
    a = r * omega**2 * (math.cos(theta) + math.cos(2*theta) / n)

    return x, v, a

# Example: Typical automotive engine
r = 45.0     # crank radius 45 mm (90 mm stroke)
l = 150.0    # con-rod length 150 mm
rpm = 6000
omega = 2 * math.pi * rpm / 60  # rad/s

print(f"Engine: stroke={2*r:.0f}mm, rod={l:.0f}mm, "
      f"rod ratio={l/r:.2f}, RPM={rpm}")
print(f"{'Angle':>8} {'Disp(mm)':>10} {'Vel(m/s)':>10} {'Accel(g)':>10}")
print("-" * 42)

for angle in range(0, 361, 30):
    x, v, a = slider_crank_kinematics(r, l, angle, omega)
    print(f"{angle:8d} {x:10.2f} {v/1000:10.2f} {a/9810:10.1f}")

# Key observation: piston spends more time near TDC than BDC
# because the connecting rod "stretches" the dwell at top

1.2 Offset Slider-Crank

In an offset slider-crank, the slider path does not pass through the crank center. This creates an asymmetric stroke — the forward stroke takes a different crank angle than the return stroke. Applications include:

• Quick-return in shaping machines: The cutting stroke is slow (more crank angle) and the return is fast (less crank angle).
• Reduced piston side thrust: Some engine designs offset the crankshaft slightly to reduce friction during the power stroke.
• Pump mechanisms: Offset creates unequal suction and discharge strokes for specific flow characteristics.

2. The Four-Bar Linkage

The four-bar linkage consists of four rigid links connected in a closed loop by four revolute joints. One link is fixed (the frame or ground). The behavior of the mechanism depends entirely on the relative lengths of the four links.

2.1 Grashof's Condition

Grashof's condition determines whether any link can make a full 360-degree rotation. Let the link lengths be sorted as s (shortest), l (longest), p and q (intermediate):

def grashof_analysis(link_lengths):
    """
    Analyze a four-bar linkage using Grashof's condition.

    link_lengths: dict with keys 'a' (frame), 'b' (input/crank),
                  'c' (coupler), 'd' (output/follower)
    """
    lengths = sorted(link_lengths.values())
    s, p, q, l = lengths[0], lengths[1], lengths[2], lengths[3]

    grashof_sum = s + l
    other_sum = p + q

    print(f"Link lengths: {link_lengths}")
    print(f"Sorted: s={s}, p={p}, q={q}, l={l}")
    print(f"s + l = {grashof_sum:.2f}")
    print(f"p + q = {other_sum:.2f}")

    if grashof_sum < other_sum:
        print("GRASHOF mechanism (at least one fully rotating link)")

        # Determine type based on which link is shortest
        names = list(link_lengths.keys())
        vals = list(link_lengths.values())
        shortest_link = names[vals.index(s)]

        if shortest_link == 'a':
            linkage_type = "Double-crank (drag link)"
            print(f"  Shortest is frame -> {linkage_type}")
        elif shortest_link == 'b':
            linkage_type = "Crank-rocker"
            print(f"  Shortest is input -> {linkage_type}")
        elif shortest_link == 'd':
            linkage_type = "Rocker-crank"
            print(f"  Shortest is output -> {linkage_type}")
        else:
            linkage_type = "Double-rocker (coupler shortest)"
            print(f"  Shortest is coupler -> {linkage_type}")

    elif abs(grashof_sum - other_sum) < 0.001:
        print("CHANGE-POINT mechanism (special Grashof)")
        print("  Warning: behavior uncertain at change points")
    else:
        print("NON-GRASHOF mechanism (triple rocker)")
        print("  No link can make full rotation")

# Example: Crank-rocker
print("=== Classic Crank-Rocker ===")
grashof_analysis({'a': 4, 'b': 2, 'c': 3, 'd': 3.5})

print("\n=== Non-Grashof (Triple Rocker) ===")
grashof_analysis({'a': 4, 'b': 3, 'c': 3, 'd': 5})

print("\n=== Double-Crank (Drag Link) ===")
grashof_analysis({'a': 2, 'b': 3, 'c': 4, 'd': 3.5})

2.2 Inversions of the Four-Bar Linkage

An inversion is obtained by fixing a different link while keeping all link lengths the same. A Grashof four-bar has four inversions:

2.3 Transmission Angle Optimization

The transmission angle (μ) is the angle between the coupler and the output link at their connecting joint. It measures how effectively force is transmitted through the linkage:

• Ideal: μ = 90 degrees (force is entirely productive).
• Minimum acceptable: μ > 40 degrees (below this, friction dominates and the mechanism may jam).
• Optimization: Choose link lengths to maximize the minimum transmission angle over the full cycle.

3. Bell Cranks & Force Redirection

A bell crank is an L-shaped lever pivoted at the bend, used to change the direction of force by 90 degrees (or other angles). Brown catalogs bell cranks in movements #126, #154, and #156-157.

The mechanical advantage of a bell crank depends on the arm lengths: MA = L_output / L_input. If the output arm is shorter, force is amplified but travel is reduced — exactly like a class-1 lever.

4. Toggle Mechanisms

4.1 The Toggle Principle

A toggle mechanism exploits the geometry near a dead center position, where two links align in a straight line. At this point, a small input force produces a theoretically infinite output force (limited in practice by structural strength and friction).

Analogy: Think of straightening your arm against a wall. When your elbow is slightly bent, it takes moderate effort to straighten it. As your arm approaches full extension (the toggle point), the wall force becomes enormous even though you're pushing with the same muscle effort. Toggle presses exploit exactly this principle.

import math

def toggle_force_amplification(F_input, theta_deg):
    """
    Calculate force amplification in a toggle mechanism.

    F_input: input force (N) applied to the joint
    theta_deg: angle from dead center (straight line)

    As theta approaches 0, amplification approaches infinity.
    """
    theta = math.radians(theta_deg)

    if theta < 0.01:
        print(f"  theta={theta_deg} deg: AT DEAD CENTER "
              f"(theoretical infinite amplification)")
        return float('inf')

    # F_output = F_input / (2 * tan(theta))
    F_output = F_input / (2 * math.tan(theta))
    amplification = F_output / F_input

    print(f"  theta={theta_deg:5.1f} deg: F_out={F_output:10.1f} N "
          f"(amplification={amplification:8.1f}x)")
    return F_output

# Demonstrate toggle amplification
print("Toggle force amplification (F_input = 100 N)")
print("=" * 55)
for angle in [30, 20, 10, 5, 2, 1, 0.5, 0.1]:
    toggle_force_amplification(100, angle)

4.2 Dead Points & Overcoming Them

A dead point occurs when the crank and connecting rod align — the mechanism cannot be driven by force on the slider alone. In engines, dead points occur at Top Dead Center (TDC) and Bottom Dead Center (BDC). Solutions include:

• Flywheel: Stores rotational energy to carry the crank through dead points (used in all reciprocating engines).
• Multiple cylinders: In a multi-cylinder engine, other cylinders provide torque when one is at dead center.
• Offset crank: Slightly misaligning the slider path from the crank center avoids exact dead center.
• Springs: Store energy to push past dead points (used in toggle clamps and latches).

5. Quick-Return Mechanisms

5.1 Whitworth Quick-Return

The Whitworth quick-return is an inversion of the slider-crank where the fixed pivot is inside the crank circle. It produces a slow cutting stroke and a fast return stroke — essential for shaping and planing machines where the tool cuts in only one direction:

5.2 Crank-Shaper Mechanism

The crank-shaper uses a slotted lever driven by a crank pin. As the crank rotates at constant speed, the lever oscillates, driving the ram (cutting tool) back and forth. The geometry ensures the forward (cutting) stroke occupies more crank rotation than the return, giving the quick-return effect.

6. Special Linkages

6.1 Lazy-Tongs & Pantograph

Lazy-tongs (Brown's movement #144) is an accordion-like linkage of crossed levers that extends and retracts. It amplifies linear displacement — a small input push results in a large extension. Applications include:

• Scissor lifts: Hydraulic cylinder at the base extends lazy-tongs to lift a platform.
• Expandable gates: Security barriers and pet gates use lazy-tongs for compact storage.
• Pantograph: A four-bar variant that copies (and optionally scales) motion — used in engraving machines and railway current collectors.

6.2 Compound Cranks

Brown's movements #168-169 illustrate compound crank arrangements where multiple cranks are coupled together, often at 90 or 120 degrees, to produce smooth multi-phase power output. This is the principle behind multi-cylinder engines — the crankshaft is a compound crank with throws arranged at specific angles to balance forces and distribute power pulses evenly.

7. Historical Context

8. Case Studies

Exercises & Self-Assessment

Conclusion & Next Steps

Cranks and linkages are the alphabet of mechanical motion. Here are the key takeaways from Part 12:

• The slider-crank converts rotation to reciprocation in every piston engine, compressor, and pump. Its kinematics are governed by crank radius and rod ratio.
• Grashof's condition (s + l vs p + q) is the first test in any four-bar design — it determines whether full rotation is possible.
• Four-bar inversions produce crank-rocker, double-crank, and double-rocker behaviors from the same link lengths by fixing different links.
• Transmission angle must stay above 40 degrees to ensure reliable force transmission.
• Bell cranks redirect force; toggles amplify force near dead center.
• Quick-return mechanisms provide unequal forward/return speeds for machine tools.
• Watt's parallel motion proved that four-bar linkages can approximate straight-line motion — a discovery that powered the Industrial Revolution.