507 Ways to Move Part 16: Governors, Regulators & Feedback

1. Centrifugal Governor Principles

1.1 Watt's Flyball Governor

The Watt governor (also called the simple conical pendulum governor) consists of two heavy balls attached to arms that are hinged at the top of a rotating spindle driven by the engine. As the spindle speed increases, the balls swing outward due to centrifugal force, raising a sliding collar on the spindle. This collar is connected via levers to the steam throttle valve.

At equilibrium, the centrifugal force on each ball equals the restoring force of gravity:

m * omega^2 * r = m * g * tan(theta)

Simplifying: h = g / omega^2

Where h is the height of the cone traced by the governor arms, omega is the angular velocity, and g is gravity. A remarkable result: the equilibrium height depends only on speed, not on the ball mass. Heavier balls do not change the equilibrium position -- they only increase the force available to move the throttle linkage.

1.2 Mechanical Feedback Loops

The governor implements a classic negative feedback loop:

1. Sensor: The spinning balls sense engine speed through centrifugal force
2. Comparator: The balance between centrifugal force and gravity/spring force compares actual speed to the setpoint
3. Controller: The linkage geometry determines how much throttle correction is applied per unit speed error
4. Actuator: The collar and linkage physically move the throttle valve
5. Plant: The engine responds to the new throttle position
6. Feedback: The new engine speed changes the ball position, closing the loop

This is precisely the same structure as a modern electronic PID control loop, but implemented entirely through physics and geometry rather than software and electronics.

2. Governor Types

2.1 Porter Governor

The Porter governor adds a heavy central sliding weight to the Watt governor. This dead weight on the collar increases the centrifugal force needed to raise the balls, allowing the governor to operate at higher speeds while maintaining adequate sensitivity. The equilibrium equation becomes:

h = g * (m + M) / (m * omega^2)

Where M is the central dead weight mass. The Porter governor is more stable than the simple Watt governor and was widely used on stationary steam engines throughout the 19th century.

2.2 Proell Governor

The Proell governor extends the ball arms beyond the pivot point, placing the balls on the ends of extended lever arms rather than directly at the pivot. This amplifies the vertical displacement of the collar for a given change in ball position, increasing sensitivity -- the governor responds to smaller speed changes. The Proell governor was favored for applications requiring tight speed regulation, such as textile mill engines where speed variations would affect thread quality.

2.3 Hartnell Governor (Spring-Loaded)

The Hartnell governor replaces gravity with compression springs as the restoring force. The bell-crank lever arms carry the balls outward, compressing springs as speed increases. Advantages over gravity governors:

• Compact -- no need for tall conical pendulum height; can be made very small
• Adjustable -- spring preload sets the controlled speed; easily changed
• Orientation-independent -- works in any position (not reliant on gravity)
• Higher speeds -- springs can provide the large restoring forces needed at high RPM
• Better sensitivity -- spring rate can be precisely tuned

The Hartnell governor is the most widely used type in modern mechanical speed governors for diesel engines, small turbines, and portable generators.

3. Governor Characteristics

3.1 Sensitivity, Hunting & Stability

Sensitivity is the ratio of the speed range over which the governor operates to the mean speed: Sensitivity = (N2 - N1) / N_mean. A highly sensitive governor responds to small speed changes but may hunt -- oscillating continuously above and below the setpoint without settling. A governor that hunts is worse than no governor at all, because the speed oscillations can damage machinery and produce unacceptable output variations.

Hunting occurs when the governor is too sensitive and/or the feedback delay is too long. The governor over-corrects, then over-corrects again in the opposite direction, creating a sustained oscillation. Maxwell's 1868 analysis showed that stability requires the governor's response to be adequately damped -- it must not react so aggressively that it overshoots.

Solutions to hunting include:

• Dashpots -- hydraulic dampers that slow the governor's response, preventing overshoot
• Isochronous compensation -- adding a compensating mechanism that anticipates speed changes
• Friction damping -- controlled friction in the linkage absorbs oscillation energy
• Speed droop -- accepting a small steady-state speed error in exchange for stability

3.2 Isochronous vs Astatic vs Stable Governors

An isochronous governor maintains exactly the same speed at all load conditions -- zero droop. This sounds ideal but is actually inherently unstable (it hunts) without additional damping or compensation. An astatic governor is one where equilibrium can exist at any height/position -- it too is unstable. A stable governor accepts a small speed droop in exchange for stable, non-hunting operation.

3.3 Speed Droop & Dead Band

Speed droop is the intentional decrease in speed from no-load to full-load, expressed as a percentage:

Droop (%) = ((N_no_load - N_full_load) / N_rated) * 100

Typical droop values: 3-5% for diesel engine generators, 4-5% for steam turbines. Droop is essential for load sharing between parallel generators -- without droop, generators would fight each other, with one trying to carry all the load.

The dead band is the speed range within which the governor does not respond (due to friction, backlash, or hysteresis). A typical mechanical governor has a dead band of 0.3-1.0% of rated speed. Excessive dead band causes coarse, jerky regulation.

4. Gyroscopes & Stabilization

4.1 Gyroscopic Precession (Brown's #355-356)

Brown's movements #355-356 describe the gyroscope -- a spinning body that exhibits remarkable properties due to conservation of angular momentum. The key phenomena are:

• Rigidity in space -- a spinning gyroscope resists changes to its orientation, maintaining its spin axis fixed in inertial space regardless of how the frame is moved
• Precession -- when a torque is applied to tilt the spin axis, the gyroscope responds by rotating (precessing) about an axis perpendicular to both the spin axis and the applied torque
• Nutation -- a rapid oscillation superimposed on precession when torque is suddenly applied

The precession rate is: omega_precession = torque / (I * omega_spin)

A faster-spinning, heavier gyroscope precesses more slowly -- it is more "rigid" and resistant to disturbance.

4.2 Stabilization Applications

5. Historical Development

6. Case Studies

7. Python Governor Simulation

"""
Governor Speed Control Simulator
Brown's 507 Mechanical Movements - Part 16
Simulates centrifugal governor dynamics and speed regulation.
"""

import math


def watt_governor_equilibrium(
    speed_rpm: float,
    arm_length_m: float = 0.3,
    ball_mass_kg: float = 4.0,
    gravity: float = 9.80665
) -> dict:
    """
    Calculate Watt governor equilibrium position at a given speed.

    Parameters
    ----------
    speed_rpm : float       Spindle speed in RPM
    arm_length_m : float    Governor arm length in meters
    ball_mass_kg : float    Mass of each ball in kg
    gravity : float         Gravitational acceleration

    Returns
    -------
    dict with cone height, ball angle, ball radius, centrifugal force, etc.
    """
    omega = 2 * math.pi * speed_rpm / 60.0

    # Equilibrium height of the cone
    if omega > 0:
        h = gravity / omega**2
    else:
        h = float('inf')

    # Check if height is achievable with given arm length
    if h > arm_length_m:
        h_actual = arm_length_m
        achievable = False
    else:
        h_actual = h
        achievable = True

    # Angle from vertical
    if arm_length_m > 0 and h_actual <= arm_length_m:
        theta = math.acos(h_actual / arm_length_m)
    else:
        theta = 0

    # Ball radius from spindle
    r = arm_length_m * math.sin(theta)

    # Centrifugal force on each ball
    F_centrifugal = ball_mass_kg * omega**2 * r

    # Restoring force (gravity component)
    F_gravity = ball_mass_kg * gravity * math.tan(theta) if theta > 0 else 0

    return {
        'speed_rpm': speed_rpm,
        'omega_rad_s': round(omega, 3),
        'cone_height_mm': round(h_actual * 1000, 1),
        'theoretical_height_mm': round(h * 1000, 1) if h != float('inf') else 'Infinite',
        'ball_angle_deg': round(math.degrees(theta), 2),
        'ball_radius_mm': round(r * 1000, 1),
        'centrifugal_force_N': round(F_centrifugal, 2),
        'equilibrium_achievable': achievable
    }


def porter_governor_equilibrium(
    speed_rpm: float,
    arm_length_m: float = 0.3,
    ball_mass_kg: float = 4.0,
    central_weight_kg: float = 15.0,
    gravity: float = 9.80665
) -> dict:
    """
    Calculate Porter governor equilibrium.

    Parameters
    ----------
    speed_rpm : float           Spindle speed in RPM
    arm_length_m : float        Arm length
    ball_mass_kg : float        Ball mass
    central_weight_kg : float   Central dead weight mass
    gravity : float             Gravitational acceleration

    Returns
    -------
    dict with equilibrium parameters
    """
    omega = 2 * math.pi * speed_rpm / 60.0
    m = ball_mass_kg
    M = central_weight_kg

    if omega > 0:
        h = gravity * (m + M) / (m * omega**2)
    else:
        h = float('inf')

    h_actual = min(h, arm_length_m) if h != float('inf') else arm_length_m

    theta = math.acos(h_actual / arm_length_m) if h_actual <= arm_length_m else 0
    r = arm_length_m * math.sin(theta)

    # Sleeve lift from minimum position
    sleeve_lift = arm_length_m - h_actual

    return {
        'speed_rpm': speed_rpm,
        'cone_height_mm': round(h_actual * 1000, 1),
        'ball_angle_deg': round(math.degrees(theta), 2),
        'ball_radius_mm': round(r * 1000, 1),
        'sleeve_lift_mm': round(sleeve_lift * 1000, 1),
        'central_weight_kg': central_weight_kg,
        'speed_increase_vs_watt_pct': round(
            (math.sqrt((m + M) / m) - 1) * 100, 1
        )
    }


def hartnell_governor(
    speed_rpm: float,
    ball_mass_kg: float = 0.5,
    spring_rate_n_per_m: float = 5000,
    spring_preload_n: float = 50,
    arm_ratio: float = 1.5,
    initial_radius_m: float = 0.05,
    rated_speed_rpm: float = 1500
) -> dict:
    """
    Calculate Hartnell spring-loaded governor equilibrium.

    Parameters
    ----------
    speed_rpm : float               Operating speed
    ball_mass_kg : float            Ball mass
    spring_rate_n_per_m : float     Spring stiffness (N/m)
    spring_preload_n : float        Initial spring compression force
    arm_ratio : float               Ratio of ball arm to sleeve arm
    initial_radius_m : float        Ball radius at minimum speed
    rated_speed_rpm : float         Design rated speed

    Returns
    -------
    dict with spring force, ball radius, sleeve position, etc.
    """
    omega = 2 * math.pi * speed_rpm / 60.0
    omega_rated = 2 * math.pi * rated_speed_rpm / 60.0

    # Centrifugal force at current speed
    Fc = ball_mass_kg * omega**2 * initial_radius_m

    # Spring force required for equilibrium (simplified)
    Fs_required = 2 * Fc / arm_ratio

    # Sleeve displacement from spring equilibrium
    if spring_rate_n_per_m > 0:
        sleeve_disp = (Fs_required - spring_preload_n) / spring_rate_n_per_m
    else:
        sleeve_disp = 0

    # Ball radius change
    ball_radius_change = sleeve_disp * arm_ratio
    current_radius = initial_radius_m + ball_radius_change

    # Sensitivity (speed change for full sleeve travel)
    max_sleeve_travel = 0.015  # 15mm typical
    speed_for_full_travel = math.sqrt(
        (spring_preload_n + spring_rate_n_per_m * max_sleeve_travel) *
        arm_ratio / (2 * ball_mass_kg * (initial_radius_m + max_sleeve_travel * arm_ratio))
    ) * 60 / (2 * math.pi) if ball_mass_kg > 0 else 0

    return {
        'speed_rpm': speed_rpm,
        'centrifugal_force_N': round(Fc, 2),
        'spring_force_required_N': round(Fs_required, 2),
        'sleeve_displacement_mm': round(sleeve_disp * 1000, 2),
        'ball_radius_mm': round(current_radius * 1000, 1),
        'spring_preload_N': spring_preload_n,
        'spring_rate_N_per_m': spring_rate_n_per_m,
        'speed_for_full_travel_rpm': round(speed_for_full_travel, 0)
    }


def speed_droop_calculation(
    no_load_speed_rpm: float,
    full_load_speed_rpm: float,
    rated_speed_rpm: float = None
) -> dict:
    """
    Calculate governor speed droop and regulation.

    Parameters
    ----------
    no_load_speed_rpm : float     Speed at zero load
    full_load_speed_rpm : float   Speed at maximum load
    rated_speed_rpm : float       Nominal rated speed (default = average)

    Returns
    -------
    dict with droop percentage, regulation, speed range, etc.
    """
    if rated_speed_rpm is None:
        rated_speed_rpm = (no_load_speed_rpm + full_load_speed_rpm) / 2

    droop_pct = ((no_load_speed_rpm - full_load_speed_rpm) / rated_speed_rpm) * 100
    regulation = ((no_load_speed_rpm - full_load_speed_rpm) / full_load_speed_rpm) * 100
    speed_range = no_load_speed_rpm - full_load_speed_rpm

    return {
        'no_load_speed_rpm': no_load_speed_rpm,
        'full_load_speed_rpm': full_load_speed_rpm,
        'rated_speed_rpm': rated_speed_rpm,
        'droop_pct': round(droop_pct, 2),
        'regulation_pct': round(regulation, 2),
        'speed_range_rpm': round(speed_range, 1),
        'classification': 'Isochronous' if droop_pct < 0.1 else
                          'Tight regulation' if droop_pct < 2 else
                          'Normal' if droop_pct < 6 else 'Wide droop'
    }


# ── Example Usage ──
if __name__ == '__main__':
    print("=" * 65)
    print("  GOVERNOR SPEED CONTROL SIMULATOR")
    print("  Brown's 507 Mechanical Movements - Part 16")
    print("=" * 65)

    # Example 1: Watt governor at various speeds
    print("\n--- Example 1: Watt Governor vs Speed ---")
    for rpm in [20, 30, 40, 50, 60, 80, 100]:
        w = watt_governor_equilibrium(rpm, arm_length_m=0.3, ball_mass_kg=4.0)
        print(f"  {rpm:4d} RPM: h={str(w['cone_height_mm']):>8s} mm, "
              f"angle={w['ball_angle_deg']:6.2f} deg, "
              f"r={w['ball_radius_mm']:6.1f} mm")

    # Example 2: Porter governor
    print("\n--- Example 2: Porter Governor (15 kg central weight) ---")
    for rpm in [40, 60, 80, 100, 120]:
        p = porter_governor_equilibrium(rpm, central_weight_kg=15.0)
        print(f"  {rpm:4d} RPM: h={p['cone_height_mm']:6.1f} mm, "
              f"sleeve={p['sleeve_lift_mm']:5.1f} mm, "
              f"angle={p['ball_angle_deg']:5.1f} deg")

    # Example 3: Hartnell governor for diesel engine
    print("\n--- Example 3: Hartnell Governor (Diesel 1500 RPM) ---")
    for rpm in [1400, 1450, 1500, 1550, 1600]:
        h = hartnell_governor(rpm, rated_speed_rpm=1500)
        print(f"  {rpm} RPM: Fc={h['centrifugal_force_N']:6.1f} N, "
              f"sleeve={h['sleeve_displacement_mm']:5.2f} mm")

    # Example 4: Speed droop
    print("\n--- Example 4: Speed Droop Calculations ---")
    scenarios = [
        (1500, 1440, 1500, "Diesel generator (4% droop)"),
        (3000, 2850, 3000, "Turbine (5% droop)"),
        (1800, 1800, 1800, "Isochronous mode"),
    ]
    for nl, fl, rated, desc in scenarios:
        d = speed_droop_calculation(nl, fl, rated)
        print(f"  {desc}: droop={d['droop_pct']:.1f}%, "
              f"class={d['classification']}")

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

8. Exercises & Self-Assessment

Governor Design Generator

Document your governor or regulation system design:

Conclusion & Next Steps

You now understand the mechanical origins of automatic control:

• Centrifugal governors sense speed through spinning masses and correct errors through mechanical linkages -- the first feedback controllers
• Watt, Porter, Proell, Hartnell governors each improve on their predecessors in sensitivity, speed range, and compactness
• Sensitivity vs stability is the fundamental trade-off -- too sensitive causes hunting, too insensitive causes poor regulation
• Speed droop is essential for parallel generator operation and overall system stability
• Gyroscopes exploit angular momentum for stabilization, navigation, and attitude reference
• Maxwell's 1868 paper on governors founded control theory, connecting a mechanical device to the mathematics that now governs all automated systems