507 Ways to Move Part 15: Escapements & Clockwork

1. What Is an Escapement?

1.1 Controlled Energy Release

Without an escapement, a wound mainspring would simply unwind in a blur, or a hanging weight would crash to the floor in seconds. The escapement acts as a gatekeeper, releasing one tooth-space of energy per oscillation. Consider a clock with a 30-tooth escape wheel beating at 1 Hz (one beat per second): the escape wheel completes one revolution every 30 seconds, and through a gear train, this precise rotation is transmitted to the minute and hour hands.

Every escapement consists of three essential elements:

• Escape wheel -- the last wheel in the gear train, with specially shaped teeth
• Pallets (or pallet fork) -- the component that alternately locks and releases the escape wheel
• Oscillator -- pendulum or balance wheel that controls the timing

1.2 Oscillators: Pendulums & Balance Wheels

2. Early Escapements

2.1 Verge & Foliot (13th Century)

The verge and foliot is the earliest known mechanical escapement, appearing in European tower clocks around 1275-1300. A vertical shaft (the verge) carries two small plates (pallets) set at roughly 90 degrees to each other. A horizontal bar (the foliot) with adjustable weights sits atop the verge. The crown-shaped escape wheel pushes alternately against the two pallets, causing the verge and foliot to oscillate back and forth.

The verge escapement is inherently inaccurate because it is a "recoil" escapement -- the pallets push the escape wheel backward during each beat, wasting energy and disturbing the oscillation. Typical accuracy: losing or gaining 15-60 minutes per day. Nevertheless, it served for over 300 years because no better alternative existed.

2.2 Anchor Escapement (Brown's #288)

Brown's movement #288 shows the anchor escapement, invented independently by Robert Hooke and William Clement around 1670. It revolutionized timekeeping by enabling the use of a pendulum with a small arc of swing (3-5 degrees versus the verge's 80-100 degrees).

The anchor escapement uses two curved pallets on an anchor-shaped arm that engages a standard escape wheel. As the pendulum swings, one pallet releases the escape wheel while the other catches the next tooth. The small arc means the pendulum's period is much closer to isochronous (constant regardless of amplitude), improving accuracy to +/- 10 seconds per day.

However, the anchor escapement still exhibits recoil -- a brief backward movement of the escape wheel during each beat, visible as a slight backward flick of the second hand in a grandfather clock.

2.3 Deadbeat Escapement (Brown's #290)

George Graham's deadbeat escapement (1715), shown in Brown's #290, eliminated recoil entirely. The pallet faces are shaped so that the escape wheel tooth slides along a circular arc centered on the pallet pivot during the locking phase. This means the escape wheel neither advances nor recoils while locked -- it is "dead" beat.

The deadbeat improved accuracy to +/- 1 second per day and became the standard for precision clocks for over 200 years. The second hand moves in crisp, discrete jumps with no backward flick -- the characteristic "tick...tick...tick" of a quality regulator clock.

3. Watch Escapements

3.1 Swiss Lever Escapement (Brown's #309-314)

Brown dedicates movements #309 through #314 to the lever escapement, the most successful watch escapement ever designed. Invented by Thomas Mudge in 1759 and perfected by Abraham-Louis Breguet, the Swiss lever escapement has been the standard for mechanical watches for over 200 years.

The lever escapement works through an elegant sequence:

1. The balance wheel rotates, and a jeweled impulse pin on the roller enters the fork slot of the pallet lever
2. The impulse pin pushes the lever, unlocking the entry pallet from the escape wheel
3. An escape wheel tooth slides along the impulse face of the entry pallet, giving energy to the lever (and through it, to the balance wheel)
4. The exit pallet drops onto the next escape wheel tooth, locking the train
5. The balance wheel continues its arc, then reverses under the hairspring's restoring force
6. The process repeats on the other side

The Swiss lever's genius lies in its detached operation: the balance wheel is free from any connection to the escapement during most of its oscillation (about 320 degrees out of 360). This "free arc" means the balance wheel's period is determined almost entirely by its own moment of inertia and the hairspring's stiffness, not by the escapement.

3.2 Cylinder Escapement

The cylinder escapement (Thomas Tompion, ~1695) was widely used in cheaper watches from the 18th to early 20th century. The balance staff itself is hollowed into a half-cylinder that alternately traps and releases escape wheel teeth. Simpler and thinner than the lever, but less accurate because the escape wheel is always in frictional contact with the cylinder during oscillation. Accuracy: +/- 15-30 seconds per day.

3.3 Coaxial Escapement (Daniels)

George Daniels invented the coaxial escapement in 1976, the first fundamentally new practical escapement in 250 years. Instead of sliding friction on the pallet jewels (which causes wear and requires lubrication), the coaxial delivers its impulse through a tangential push on the impulse jewel -- more like a pat on the back than a drag across a surface.

The result: dramatically reduced friction and wear, longer service intervals (8-10 years versus 3-5 for lever), and improved long-term accuracy. Omega adopted the coaxial for its movements starting in 1999 (Caliber 2500), and it now appears in most Omega mechanical watches.

4. Chronometer Escapements

4.1 Detent/Chronometer Escapement (Brown's #296-300)

Brown's movements #296 through #300 cover various forms of the detent (chronometer) escapement, the highest-accuracy mechanical escapement ever produced for portable timepieces. Used in marine chronometers from the late 18th century onward, the detent escapement achieves accuracies of +/- 0.1 seconds per day.

The detent escapement gives impulse to the balance wheel on only one direction of swing (not both, like the lever). This means the balance wheel is completely free -- detached from the escapement -- for approximately 350 degrees of each complete oscillation. The trade-off is fragility: a sharp knock can cause the detent to "trip" (release an extra tooth), losing time. This is why marine chronometers are mounted in gimbals inside padded boxes.

4.2 Grasshopper Escapement (Harrison)

John Harrison's grasshopper escapement (1720s) is one of the most unconventional and effective clock escapements ever devised. The pallets are spring-loaded arms that literally hop away from the escape wheel teeth -- like a grasshopper's legs. This design produces zero recoil and requires no lubrication because the contact surfaces experience only tangential forces, not sliding friction.

Harrison used the grasshopper in his famous early marine timekeepers (H1, H2, H3). Modern reproductions by clockmaker Martin Burgess, using Harrison's principles, have achieved extraordinary accuracy: the Burgess Clock B at the Royal Observatory Greenwich ran for 100 days in a sealed case with a total error of only 0.625 seconds -- a feat unmatched by any other pendulum clock.

5. Pendulum Dynamics & Isochronism

The pendulum's usefulness as a timekeeper rests on isochronism: the property that the period of oscillation is independent of the amplitude (arc of swing). Galileo first observed this property around 1583, and Christiaan Huygens mathematically proved in 1673 that a pendulum swinging along a cycloidal arc is perfectly isochronous.

For a simple pendulum with small amplitudes (less than about 15 degrees), the period is approximately:

T = 2 * pi * sqrt(L / g)

where L is the effective length and g is gravitational acceleration. For larger amplitudes, the exact period requires an elliptic integral, and the period increases with amplitude. This is why precision clock escapements are designed to maintain a very small, constant amplitude -- typically 1.5-3 degrees half-amplitude for a deadbeat escapement.

Temperature affects pendulum length through thermal expansion. A steel pendulum rod gaining 1 degree C in temperature extends by about 11 micrometers per meter, causing the clock to lose approximately 0.5 seconds per day per degree. Solutions include:

• Gridiron pendulum (Harrison, 1726) -- alternating steel and brass rods that expand in opposite directions
• Mercury pendulum (Graham, 1721) -- mercury in a glass jar rises as the rod lengthens, keeping the center of gravity constant
• Invar pendulum (Guillaume, 1897) -- nickel-iron alloy with near-zero thermal expansion
• Fused silica pendulum (modern) -- glass with extremely low thermal expansion coefficient

6. Maintaining Power & Winding Mechanisms

When a clock is being wound, the driving force is momentarily removed from the gear train, and the clock would stop unless a maintaining power device is fitted. Brown's movements #320-321 show maintaining power mechanisms, and #212-215 describe watch winding stops.

Harrison's maintaining power uses a secondary spring that is charged during normal operation and takes over driving the escapement during the few seconds of winding. Bolt-and-shutter maintaining power uses a spring-loaded shutter that blocks the winding square until the maintaining power is engaged -- forcing the user to activate it before winding.

In watches, the automatic winding system (rotor winding, invented by Abraham-Louis Perrelet in 1770 and perfected by Rolex in 1931) uses a semicircular weight that swings with wrist movement, winding the mainspring through a click mechanism. The slipping mainspring (or bridle) allows the mainspring to slip once fully wound, preventing over-winding and ensuring relatively constant torque delivery.

7. Historical Timeline

8. Case Studies

9. Python Pendulum & Escapement Calculator

"""
Pendulum & Escapement Calculator
Brown's 507 Mechanical Movements - Part 15
Calculates pendulum period, beat rates, gear train ratios, and temperature effects.
"""

import math


def pendulum_period(
    length_m: float,
    amplitude_deg: float = 3.0,
    gravity: float = 9.80665,
    use_exact: bool = True
) -> dict:
    """
    Calculate pendulum period with optional exact (elliptic integral) correction.

    Parameters
    ----------
    length_m : float          Effective pendulum length in meters
    amplitude_deg : float     Half-amplitude in degrees
    gravity : float           Local gravitational acceleration (m/s^2)
    use_exact : bool          Use series expansion for amplitude correction

    Returns
    -------
    dict with period, frequency, beats_per_hour, etc.
    """
    # Simple approximation
    T_simple = 2 * math.pi * math.sqrt(length_m / gravity)

    # Series expansion correction for finite amplitude
    theta = math.radians(amplitude_deg)
    if use_exact:
        # First three terms of the series expansion
        k = math.sin(theta / 2)
        correction = (1
                      + (1/4) * k**2
                      + (9/64) * k**4
                      + (25/256) * k**6)
        T_corrected = T_simple * correction
    else:
        T_corrected = T_simple

    frequency = 1 / T_corrected
    beats_per_hour = 3600 / (T_corrected / 2)  # Each half-swing is one beat

    # Circular error (difference from ideal)
    circular_error_ms = (T_corrected - T_simple) * 1000

    return {
        'length_m': length_m,
        'amplitude_deg': amplitude_deg,
        'period_simple_s': round(T_simple, 6),
        'period_corrected_s': round(T_corrected, 6),
        'frequency_Hz': round(frequency, 4),
        'beats_per_hour': round(beats_per_hour, 1),
        'circular_error_ms': round(circular_error_ms, 4),
        'seconds_pendulum': round(length_m, 4) == round(gravity / (math.pi**2), 4)
    }


def balance_wheel_period(
    moment_of_inertia_kg_m2: float,
    hairspring_stiffness_nm_rad: float,
    amplitude_deg: float = 270
) -> dict:
    """
    Calculate balance wheel oscillation period.

    Parameters
    ----------
    moment_of_inertia_kg_m2 : float   Balance wheel moment of inertia
    hairspring_stiffness_nm_rad : float   Hairspring stiffness (N*m/rad)
    amplitude_deg : float              Typical amplitude in degrees

    Returns
    -------
    dict with period, frequency, vibrations_per_hour, etc.
    """
    T = 2 * math.pi * math.sqrt(moment_of_inertia_kg_m2 / hairspring_stiffness_nm_rad)
    freq = 1 / T
    vph = 3600 / (T / 2)  # Vibrations (half-oscillations) per hour

    return {
        'period_s': round(T, 6),
        'frequency_Hz': round(freq, 4),
        'vibrations_per_hour': round(vph, 0),
        'amplitude_deg': amplitude_deg,
        'beats_per_second': round(2 * freq, 2),
        'common_vph_match': _match_common_vph(vph)
    }


def _match_common_vph(vph):
    """Match to common watch vibration rates."""
    common = {
        18000: '18,000 vph (2.5 Hz) - Standard',
        21600: '21,600 vph (3 Hz) - Common',
        25200: '25,200 vph (3.5 Hz) - Seiko',
        28800: '28,800 vph (4 Hz) - High-beat',
        36000: '36,000 vph (5 Hz) - Very high-beat'
    }
    closest = min(common.keys(), key=lambda x: abs(x - vph))
    if abs(closest - vph) < 500:
        return common[closest]
    return f'{round(vph)} vph (non-standard)'


def temperature_drift(
    pendulum_length_m: float,
    temp_change_c: float,
    material: str = 'steel'
) -> dict:
    """
    Calculate clock rate change due to temperature-induced pendulum length change.

    Parameters
    ----------
    pendulum_length_m : float    Pendulum effective length
    temp_change_c : float        Temperature change in degrees Celsius
    material : str               Pendulum rod material

    Returns
    -------
    dict with length change, period change, seconds gained/lost per day
    """
    # Thermal expansion coefficients (per degree C)
    cte = {
        'steel': 11e-6,
        'brass': 19e-6,
        'invar': 1.2e-6,
        'fused_silica': 0.5e-6,
        'aluminum': 23e-6,
        'wood_oak': 5e-6
    }

    alpha = cte.get(material, 11e-6)
    delta_L = pendulum_length_m * alpha * temp_change_c

    # Period change: dT/T = (1/2) * dL/L
    fractional_period_change = 0.5 * alpha * temp_change_c
    seconds_per_day = fractional_period_change * 86400

    return {
        'material': material,
        'CTE_per_C': alpha,
        'temp_change_C': temp_change_c,
        'length_change_um': round(delta_L * 1e6, 2),
        'fractional_period_change': f'{fractional_period_change:.2e}',
        'seconds_gained_lost_per_day': round(seconds_per_day, 3),
        'direction': 'loses time (slower)' if temp_change_c > 0 else 'gains time (faster)'
    }


def escape_wheel_gear_train(
    escape_teeth: int = 30,
    beat_period_s: float = 1.0,
    target_rotation_period_min: float = 60.0
) -> dict:
    """
    Calculate gear train ratios from escape wheel to minute hand.

    Parameters
    ----------
    escape_teeth : int               Number of teeth on escape wheel
    beat_period_s : float             Time between beats (half-period)
    target_rotation_period_min: float Time for output shaft rotation (60 min for minute hand)

    Returns
    -------
    dict with escape wheel RPM, required gear ratio, etc.
    """
    # Escape wheel rotation period
    escape_rotation_s = escape_teeth * beat_period_s  # One beat per tooth
    escape_rpm = 60.0 / escape_rotation_s

    # Required total gear ratio (escape wheel to minute hand)
    target_rotation_s = target_rotation_period_min * 60
    gear_ratio = target_rotation_s / escape_rotation_s

    return {
        'escape_teeth': escape_teeth,
        'beat_period_s': beat_period_s,
        'escape_rotation_period_s': escape_rotation_s,
        'escape_rpm': round(escape_rpm, 4),
        'gear_ratio_to_minute_hand': round(gear_ratio, 2),
        'beats_per_minute': round(60 / beat_period_s, 1),
        'beats_per_hour': round(3600 / beat_period_s, 0)
    }


# ── Example Usage ──
if __name__ == '__main__':
    print("=" * 65)
    print("  PENDULUM & ESCAPEMENT CALCULATOR")
    print("  Brown's 507 Mechanical Movements - Part 15")
    print("=" * 65)

    # Example 1: Seconds pendulum (T = 2s, L ~ 0.994m)
    print("\n--- Example 1: Seconds Pendulum ---")
    result = pendulum_period(length_m=0.9941, amplitude_deg=3.0)
    for k, v in result.items():
        print(f"  {k:30s}: {v}")

    # Example 2: Big Ben pendulum
    print("\n--- Example 2: Big Ben Pendulum (3.9m) ---")
    result2 = pendulum_period(length_m=3.9, amplitude_deg=1.5)
    for k, v in result2.items():
        print(f"  {k:30s}: {v}")

    # Example 3: Watch balance wheel (typical 28,800 vph)
    print("\n--- Example 3: Watch Balance Wheel (28,800 vph target) ---")
    result3 = balance_wheel_period(
        moment_of_inertia_kg_m2=1.2e-8,
        hairspring_stiffness_nm_rad=4.7e-4,
        amplitude_deg=270
    )
    for k, v in result3.items():
        print(f"  {k:30s}: {v}")

    # Example 4: Temperature drift
    print("\n--- Example 4: Temperature Drift (+5 C, various materials) ---")
    for mat in ['steel', 'brass', 'invar', 'fused_silica']:
        td = temperature_drift(1.0, 5.0, mat)
        print(f"  {mat:15s}: {td['seconds_gained_lost_per_day']:+.3f} s/day "
              f"({td['direction']})")

    # Example 5: Gear train calculation
    print("\n--- Example 5: Escape Wheel Gear Train ---")
    gt = escape_wheel_gear_train(escape_teeth=30, beat_period_s=0.5)
    for k, v in gt.items():
        print(f"  {k:30s}: {v}")

    print("\n" + "=" * 65)
    print("  Calculation complete.")
    print("=" * 65)

10. Exercises & Self-Assessment

Escapement Design Generator

Document your escapement or clockwork mechanism design:

Conclusion & Next Steps

You now understand the mechanical heart of timekeeping -- the escapement:

• Escapements control energy release and sustain oscillation, making precise timekeeping possible
• Verge to deadbeat -- each generation increased free arc and reduced disturbance to the oscillator
• Swiss lever dominates wristwatches: robust, shock-resistant, detached operation with 320-degree free arc
• Detent escapement achieves the highest accuracy (+/- 0.1 s/day) but is fragile -- ideal for marine chronometers
• Pendulum dynamics and temperature compensation are critical for stationary clock accuracy
• Harrison's H4 solved the longitude problem, saving countless lives at sea