507 Ways to Move Part 8: Planetary & Epicyclic Gear Trains

Planetary Gear Structure

Sun Gear

The sun gear sits at the center of the planetary system, coaxial with the ring gear and carrier. It is an external gear (teeth pointing outward) that meshes with each of the planet gears. In many configurations, the sun gear serves as the input, connected to the motor or prime mover.

The sun gear must have teeth compatible with the planet and ring gears. The fundamental constraint is the assembly condition: N_s + N_r = 2 × N_p (for equal spacing with integer constraints), and N_r = N_s + 2 × N_p, where N denotes tooth count.

Planet Gears & Carrier

The planet gears (typically 3 to 5 in number) are external gears that mesh simultaneously with the sun gear on their inner side and the ring gear on their outer side. They are mounted on bearings on the planet carrier, which itself rotates around the central axis.

The planet carrier is a structural frame that holds the planet gear shafts at equal angular spacing. Its rotation speed is independent of the individual planet gear rotation speeds -- the planets spin on their own axes while also orbiting with the carrier, much like the Earth spins on its axis while orbiting the Sun.

Key design considerations for planet gears:

• Number of planets: More planets share the load better but must fit physically within the ring gear. Typically 3-5 for standard designs, up to 7 for high-torque applications.
• Equal spacing: Planets must be equally spaced for balanced loading. This imposes a constraint: (N_s + N_r) must be evenly divisible by the number of planets.
• Mesh phasing: Even when equally spaced, the mesh phase (position in the tooth engagement cycle) differs between planets. Proper phasing can cancel certain vibration harmonics.

Ring (Annular) Gear

The ring gear (or annular gear, or internal gear) has teeth on its inner surface, facing inward to mesh with the planet gears. It is the largest component and often serves as the housing or is integrated into it. The ring gear tooth count must satisfy: N_r = N_s + 2 × N_p.

In many automotive applications, the ring gear is held stationary (fixed to the casing) to create a speed reduction from sun to carrier. In other configurations, it serves as the input or output.

Degrees of Freedom

Two Inputs, One Output

A simple planetary gear set has two degrees of freedom. This means you need two independent constraints (inputs, fixed elements, or speed specifications) to fully determine the motion of the system. With three rotating elements (sun, carrier, ring), fixing or driving any two determines the third.

This two-degree-of-freedom property is what makes planetary gears so versatile in automatic transmissions: by selectively applying brakes and clutches to different elements, a single planetary set can produce multiple distinct speed ratios, reverse, and even direct drive (1:1).

Fixing One Element

The three most common configurations of a simple planetary set are:

The negative ratio for the carrier-fixed case indicates direction reversal -- the output rotates opposite to the input. This is how automatic transmissions achieve reverse gear using the same planetary set that provides forward ratios.

The Willis Equation

Basic Ratio Equation

The Willis equation (named after Robert Willis, 1841) is the fundamental kinematic equation governing all epicyclic gear trains. It relates the angular velocities of the three main elements:

The beauty of the Willis equation is its generality: by setting any one angular velocity to zero (fixing that element), you immediately get the speed ratio between the other two. By substituting known speeds for any two elements, you can solve for the third.

All Six Configurations

A single planetary set with three elements can produce six distinct configurations (three choices for input × two remaining choices for output/fixed). Each yields a different ratio:

Compound Planetary Systems

A compound planetary (or multi-stage planetary) uses two or more planetary stages in series to achieve higher ratios or more speed combinations. Each stage adds its own set of sun, planet, and ring gears, and stages are connected by sharing elements between them.

Common compound arrangements include:

• Series stacking: The carrier of one stage drives the sun of the next. Two stages of 4:1 each give 16:1 total. Three stages can reach 64:1 or more.
• Compound planets: Each planet actually consists of two gears of different sizes rigidly connected on the same shaft. The larger gear meshes with one sun/ring and the smaller with another. This allows non-standard ratios in a single stage.
• Ravigneaux set: Two sun gears of different sizes sharing a common ring gear with two sets of planet gears -- the standard configuration for many automotive transmissions.

Ravigneaux Gear Set

The Ravigneaux gear set, patented by Pol Ravigneaux in 1940, is a compound planetary system that combines two simple planetary sets into a single compact unit. It uses:

• A small sun gear and a large sun gear on the same axis
• A set of short planet gears meshing with the small sun and a set of long planet gears meshing with the large sun and the ring
• The short and long planets also mesh with each other
• A common ring gear and common carrier

With appropriate clutches and brakes, a Ravigneaux set can provide four forward speeds and reverse in a remarkably compact package. It was the basis for many 4-speed and 5-speed automatic transmissions from the 1950s through the 2000s. Ford's C6 transmission and many GM Turbo-Hydramatic units used Ravigneaux-derived layouts.

Advantages & Comparison with Parallel-Shaft Gears

Sun-and-Planet Motion (Brown's #39)

Brown's Movement #39 illustrates the famous sun-and-planet mechanism, one of the most historically significant epicyclic devices. Invented by William Murdoch and patented by James Watt in 1781, it was a clever workaround to James Pickard's patent on the crank mechanism.

In Watt's sun-and-planet, a gear (the "planet") is fixed to the end of a connecting rod from the beam engine. This planet gear meshes with a gear (the "sun") fixed to the flywheel shaft. As the beam reciprocates, the planet orbits around the sun without rotating on its own axis (because it's attached to the rigid connecting rod). This produces continuous rotation of the flywheel.

The remarkable bonus: because the planet orbits the sun without spinning, the flywheel makes two revolutions for each stroke cycle, rather than the one revolution a crank would produce. This effectively doubled the rotational speed, which was beneficial for many industrial applications.

Historical Context

The Antikythera Mechanism

The oldest known application of epicyclic gearing is the Antikythera mechanism, an ancient Greek analog computer recovered from a shipwreck dating to approximately 100 BC. This remarkable device used a complex train of at least 30 bronze gears, including epicyclic gear trains, to predict astronomical positions, eclipses, and even the dates of the ancient Olympic Games.

The Antikythera mechanism demonstrates that epicyclic gearing was understood over 2,000 years ago. Its gear trains achieve specific astronomical ratios (like the Metonic cycle of 19 years = 235 lunar months) with extraordinary precision, using compound epicyclic stages to produce the required non-obvious ratios.

The Model T Ford Transmission

Henry Ford's Model T (1908-1927) used a planetary gear transmission controlled by foot pedals and a hand lever. It had two forward speeds and reverse, all produced by a single planetary gear set with brake bands. Pushing the left pedal engaged low gear (ring held); releasing it allowed the transmission spring to engage high gear (direct drive, all elements locked). The center pedal was reverse (sun held). This simple, rugged design was part of what made the Model T so successful -- anyone could learn to operate it.

Case Studies

Case Study 1: Automatic Transmission (6-speed)

A modern 6-speed automatic transmission uses two simple planetary sets (front and rear) with five shift elements (three clutches and two brakes). Each gear is achieved by engaging exactly two shift elements:

Case Study 2: Wind Turbine Gearbox

Large wind turbines (2-5 MW class) use multi-stage planetary gearboxes to step up the slow rotor speed (10-20 RPM) to the generator speed (1000-1800 RPM). A typical 3-stage configuration uses one or two planetary stages followed by a parallel-shaft helical stage, achieving total ratios of 80:1 to 120:1.

The planetary stages are preferred for the low-speed, high-torque first stage because of load sharing among the planets. The first-stage ring gear in a 5 MW turbine can exceed 2 meters in diameter and transmit over 5 million Nm of torque. Three to five planet gears share this enormous load, making the gear sizes manageable.

Case Study 3: Cordless Drill Planetary Gearbox

Every cordless drill contains a 2-speed or 3-speed planetary gearbox between the motor and the chuck. The high-speed motor (15,000-25,000 RPM) is reduced through two planetary stages to produce the required chuck speeds (0-500 RPM for drilling, 0-2000 RPM for driving).

Speed selection is achieved by a mechanical selector that either holds or releases the ring gear of the first stage. When the ring is held, both stages reduce (low speed, high torque for drilling). When the ring is released and locked to the carrier (all elements rotate together), that stage passes through at 1:1, giving high speed for driving screws.

Python Planetary Ratio Calculator

This Python script implements the Willis equation and calculates all possible speed ratios for a simple planetary gear set.

"""
Planetary Gear Train Ratio Calculator
Implements Willis equation for all configurations of a simple planetary set.
Reference: Brown's 507 Mechanical Movements #39, #502-507
"""

import math
from dataclasses import dataclass, field
from typing import Dict, Optional


@dataclass
class PlanetaryConfig:
    """A single planetary gear configuration."""
    name: str
    input_element: str
    output_element: str
    fixed_element: str
    ratio: float
    output_speed: float = 0.0
    direction: str = ""


@dataclass
class PlanetaryResults:
    """Complete analysis of a planetary gear set."""
    sun_teeth: int
    ring_teeth: int
    planet_teeth: int
    max_planets: int
    assembly_valid: bool
    configurations: list = field(default_factory=list)


def analyze_planetary(
    sun_teeth: int,
    ring_teeth: int,
    input_speed_rpm: float = 1000.0,
    num_planets: int = 3
) -> PlanetaryResults:
    """
    Analyze all configurations of a simple planetary gear set.

    Parameters
    ----------
    sun_teeth : int
        Number of teeth on the sun gear.
    ring_teeth : int
        Number of teeth on the ring (annular) gear.
    input_speed_rpm : float
        Input speed in RPM (default 1000).
    num_planets : int
        Desired number of planet gears (default 3).

    Returns
    -------
    PlanetaryResults
        Complete analysis with all configurations.
    """
    # Planet teeth from geometry constraint
    planet_teeth = (ring_teeth - sun_teeth) // 2

    # Verify ring = sun + 2*planet
    valid_geometry = (ring_teeth == sun_teeth + 2 * planet_teeth)

    # Assembly condition: (Ns + Nr) divisible by number of planets
    assembly_ok = (sun_teeth + ring_teeth) % num_planets == 0

    # Maximum planets that fit (approximate)
    # Planet pitch radius = planet_teeth * module / 2
    # Carrier radius = (sun_teeth + planet_teeth) * module / 2
    # Planet must fit: 2 * planet_pitch_radius < 2 * carrier_radius * sin(pi/n)
    max_planets = 3  # minimum
    for n in range(3, 12):
        carrier_r = (sun_teeth + planet_teeth) / 2.0
        planet_r = planet_teeth / 2.0
        gap = carrier_r * math.sin(math.pi / n) - planet_r
        if gap > 0 and (sun_teeth + ring_teeth) % n == 0:
            max_planets = n
        elif gap <= 0:
            break

    configs = []

    # Configuration 1: Ring fixed, Sun input, Carrier output
    ratio1 = 1.0 / (1.0 + ring_teeth / sun_teeth)
    speed1 = input_speed_rpm * ratio1
    configs.append(PlanetaryConfig(
        name="Ring Fixed (Reduction)",
        input_element="Sun", output_element="Carrier", fixed_element="Ring",
        ratio=1.0 / ratio1,
        output_speed=speed1,
        direction="Same" if ratio1 > 0 else "Reverse"
    ))

    # Configuration 2: Carrier fixed, Sun input, Ring output
    ratio2 = -ring_teeth / sun_teeth
    speed2 = input_speed_rpm / ratio2
    configs.append(PlanetaryConfig(
        name="Carrier Fixed (Reverse)",
        input_element="Sun", output_element="Ring", fixed_element="Carrier",
        ratio=abs(ratio2),
        output_speed=abs(speed2),
        direction="Reverse"
    ))

    # Configuration 3: Sun fixed, Ring input, Carrier output
    ratio3 = 1.0 / (1.0 + sun_teeth / ring_teeth)
    speed3 = input_speed_rpm * ratio3
    configs.append(PlanetaryConfig(
        name="Sun Fixed (Overdrive reduction)",
        input_element="Ring", output_element="Carrier", fixed_element="Sun",
        ratio=1.0 / ratio3,
        output_speed=speed3,
        direction="Same"
    ))

    # Configuration 4: All locked (direct drive)
    configs.append(PlanetaryConfig(
        name="All Locked (Direct Drive)",
        input_element="Any", output_element="All", fixed_element="None",
        ratio=1.0,
        output_speed=input_speed_rpm,
        direction="Same"
    ))

    return PlanetaryResults(
        sun_teeth=sun_teeth,
        ring_teeth=ring_teeth,
        planet_teeth=planet_teeth,
        max_planets=max_planets,
        assembly_valid=assembly_ok and valid_geometry,
        configurations=configs,
    )


def willis_equation(
    sun_teeth: int,
    ring_teeth: int,
    omega_sun: Optional[float] = None,
    omega_carrier: Optional[float] = None,
    omega_ring: Optional[float] = None
) -> Dict[str, float]:
    """
    Solve Willis equation given any two angular velocities.

    Provide exactly two of the three speeds; the third is calculated.
    """
    R = -ring_teeth / sun_teeth  # fundamental ratio

    known = sum(v is not None for v in [omega_sun, omega_carrier, omega_ring])
    if known != 2:
        raise ValueError("Provide exactly two angular velocities.")

    if omega_sun is None:
        omega_sun = R * (omega_ring - omega_carrier) + omega_carrier
    elif omega_ring is None:
        omega_ring = (omega_sun - omega_carrier) / R + omega_carrier
    else:
        omega_carrier = (omega_sun - R * omega_ring) / (1 - R)

    return {
        "omega_sun": omega_sun,
        "omega_carrier": omega_carrier,
        "omega_ring": omega_ring,
    }


def print_results(r: PlanetaryResults, input_rpm: float = 1000.0) -> None:
    """Pretty-print planetary gear analysis."""
    print("=" * 65)
    print("  PLANETARY GEAR TRAIN ANALYSIS")
    print("=" * 65)
    print(f"  Sun teeth:        {r.sun_teeth}")
    print(f"  Planet teeth:     {r.planet_teeth}")
    print(f"  Ring teeth:       {r.ring_teeth}")
    print(f"  Max planets:      {r.max_planets}")
    valid = "YES" if r.assembly_valid else "NO - check geometry!"
    print(f"  Assembly valid:   {valid}")
    print(f"  Input speed:      {input_rpm:.0f} RPM")
    print("-" * 65)
    for c in r.configurations:
        print(f"\n  [{c.name}]")
        print(f"    Input: {c.input_element} | Output: {c.output_element} | Fixed: {c.fixed_element}")
        print(f"    Ratio: {c.ratio:.3f}:1 | Output: {c.output_speed:.1f} RPM | Dir: {c.direction}")
    print("=" * 65)


# --- Example Usage ---
if __name__ == "__main__":
    # Example 1: Common automotive planetary set
    print("\n--- Automotive Planetary (Sun=30, Ring=70) ---")
    auto = analyze_planetary(sun_teeth=30, ring_teeth=70, input_speed_rpm=3000)
    print_results(auto, 3000)

    # Example 2: Cordless drill planetary
    print("\n--- Cordless Drill Planetary (Sun=9, Ring=33) ---")
    drill = analyze_planetary(sun_teeth=9, ring_teeth=33, input_speed_rpm=20000)
    print_results(drill, 20000)

    # Example 3: Willis equation - find carrier speed
    print("\n--- Willis Equation Example ---")
    result = willis_equation(sun_teeth=30, ring_teeth=70,
                             omega_sun=3000, omega_ring=0)
    print(f"  Sun: {result['omega_sun']:.1f} RPM")
    print(f"  Carrier: {result['omega_carrier']:.1f} RPM")
    print(f"  Ring: {result['omega_ring']:.1f} RPM")

Exercises & Self-Assessment

Conclusion & Next Steps

Planetary gear trains are the pinnacle of gear system design -- compact, powerful, and extraordinarily versatile. Here are the key takeaways from Part 8:

• Planetary gears consist of sun, planet, carrier, and ring elements in a coaxial arrangement with two degrees of freedom
• The Willis equation is the master key to all epicyclic gear train analysis -- one equation governs all configurations
• Fixing different elements produces reduction, reverse, overdrive, or direct drive from the same gear set
• Load sharing among multiple planets gives planetary gears the highest power density of any gear type
• Compound planetary and Ravigneaux sets enable multi-speed transmissions with minimal hardware
• Sun-and-planet motion (Brown's #39) shows how epicyclic principles solve real engineering constraints creatively
• Assembly conditions (tooth count divisibility) must be satisfied for equal planet spacing