507 Ways to Move Part 17: Parallel & Straight-Line Motions

1. The Straight-Line Problem

1.1 Why Is Straight-Line Motion Difficult?

A linkage consists of rigid bars connected by pivot joints. Each joint allows rotation but not translation. A point on a linkage traces a coupler curve -- and coupler curves of four-bar linkages are generally sixth-degree algebraic curves. Getting a sixth-degree curve to approximate a straight line (a first-degree curve) over a useful range is a non-trivial geometric challenge.

The simplest approach -- a slider (prismatic joint) -- seems obvious but has serious practical drawbacks in the context of 18th-century steam engines:

• Friction -- sliding surfaces wear rapidly under heavy loads and contamination
• Sealing -- a piston rod passing through a cylinder head needs a seal; any lateral force from a non-straight guide path destroys the seal
• Lubrication -- sliding joints are harder to lubricate than pivots
• Manufacturing -- precision flat surfaces were extremely difficult to produce before machine tools matured

1.2 Approximate vs Exact Solutions

2. Approximate Straight-Line Linkages

2.1 Watt's Linkage (Brown's #332)

Brown's movement #332 shows Watt's parallel motion, patented in 1784. It consists of three bars: two long links (the "beam" arms) pivoted to the frame at their upper ends, and a short coupler link connecting their lower ends. The midpoint of the coupler traces an approximate straight line -- actually a figure-eight (lemniscate) curve, but the portion near the center is nearly linear.

The brilliance of Watt's design is its simplicity: only three moving links and four pivot joints. For the Watt beam engine, the piston rod was connected to the midpoint of the coupler, and as the beam rocked back and forth, the piston rod moved very nearly in a straight line. The deviation from perfect straightness was typically less than 1 mm over the full piston stroke -- acceptable for the seal technology of the era.

The optimal proportions for Watt's linkage (minimizing deviation) are approximately:

• The two grounded links should be of equal length
• The coupler should be approximately 1/3 the length of the grounded links
• The fixed pivot spacing should equal the coupler length
• The near-straight portion extends over roughly 1/6 of the full arc

2.2 Chebyshev Linkage

Pafnuty Chebyshev (1821-1894), the great Russian mathematician, attacked the straight-line problem with mathematical optimization. His linkage uses the same three-bar topology as Watt's, but with different proportions optimized using what we now call Chebyshev polynomials and minimax approximation theory.

The Chebyshev linkage achieves a better approximation over a longer stroke: the deviation from a straight line is distributed more evenly (the curve oscillates equally above and below the ideal line, rather than accumulating error at the extremes). The standard proportions are:

• Fixed pivot spacing d = 1 (normalized)
• Two cranks of length 1.25
• Coupler of length 0.5
• The tracing point is at the coupler midpoint

Chebyshev spent decades of his career on the straight-line problem and linkage synthesis. His work on minimax approximation theory, initially motivated by linkage optimization, became one of the foundations of approximation theory in mathematics -- a field with applications far beyond mechanism design, including signal processing, numerical analysis, and computer graphics.

2.3 Roberts Linkage

Samuel Roberts (1827-1913) designed a symmetric approximate straight-line linkage. Both grounded links and the coupler form an isoceles triangle arrangement. The tracing point follows a path very close to a straight line, with the deviation symmetric about the center of travel. The Roberts linkage is related to the Chebyshev and Watt linkages through the Roberts-Chebyshev theorem, which states that for every four-bar approximate straight-line mechanism, there exist two other four-bar mechanisms (called cognates) that trace the same coupler curve.

3. Exact Straight-Line Linkages

3.1 Peaucellier-Lipkin Linkage (1864)

The Peaucellier-Lipkin linkage was the first planar linkage to produce mathematically exact straight-line motion. It solved the 80-year problem that Watt, Chebyshev, and others could only approximate.

The mechanism consists of 7 bars and 6 joints:

• A rhombus (diamond) of four equal bars of length a
• Two longer bars of length b connecting opposite corners of the rhombus to a fixed pivot
• An additional bar connecting one corner of the rhombus to a second fixed pivot, constrained so that corner moves on a circle passing through the first fixed pivot

The mathematical principle is circle inversion. If a point P moves on a circle passing through the center of inversion O, then the inverse point P' (where OP * OP' = constant) traces a straight line. The rhombus and long bars implement the inversion: if one corner of the rhombus is at distance d from the fixed pivot, the opposite corner is at distance (b^2 - a^2) / d from the same pivot. This is precisely the inversion relationship.

The constraint requirement is: b > a (the long bars must be longer than the rhombus bars).

3.2 Hart's Linkage (5 Bars)

Harry Hart discovered in 1874 that an exact straight-line linkage could be built with only 5 bars (plus the frame), fewer than Peaucellier's 7. Hart's linkage uses an antiparallelogram (a crossed four-bar linkage) as the inversor. The mechanism is more compact but has a more limited range of motion and is harder to construct precisely.

Hart's inversor satisfies the inversion relationship OP * OP' = constant, just like Peaucellier's, but achieves it through a different geometric construction. With the addition of a constraining link (making 5 total moving bars), one point traces an exact straight line.

3.3 Sarrus Linkage (3D Spatial)

Pierre Frederic Sarrus published in 1853 -- eleven years before Peaucellier -- a mechanism that produces exact straight-line motion, but in three dimensions. The Sarrus linkage consists of two sets of three hinged plates arranged so that the top plate moves in pure translation (straight line) relative to the bottom plate. It is technically the first exact straight-line mechanism, but being spatial rather than planar, it was not considered a solution to the classical planar straight-line problem.

The Sarrus linkage has found modern applications in deployable structures, satellite mechanisms, and architectural kinetic systems where constrained linear translation is needed in 3D.

3.4 Scott-Russell Mechanism

The Scott-Russell mechanism produces exact straight-line motion using two bars and one slider (prismatic joint). A bar of length L has one end constrained to slide along a straight line (the slider), while a fixed pivot is located at the midpoint of a perpendicular to the slider line. The free end of the bar traces an exact straight line perpendicular to the slider direction.

While it does use a slider (making it not a pure linkage solution), the Scott-Russell is important because it is the simplest exact straight-line mechanism and demonstrates the underlying geometry clearly. It is essentially a degenerate case of the isoceles linkage.

4. Parallel Motion Devices

4.1 Parallel Rulers (Brown's #322-325, #349, #367)

Brown dedicates several movements (#322-325, #349, #367) to parallel rulers and parallel motion mechanisms. A parallel ruler consists of two straightedges connected by two equal-length cross links forming a parallelogram linkage. When one ruler is held stationary, the other can be translated to any position while remaining exactly parallel to the first.

Applications include:

• Navigation -- plotting courses on nautical charts by translating a line parallel to a compass rose
• Drafting -- drawing parallel lines at specified spacings for architectural and engineering drawings
• Rolling rulers -- a variant that rolls rather than lifts, preventing smudging of ink
• Printing registration -- maintaining parallel alignment of print plates

4.2 Pantograph (Brown's #246)

The pantograph is a remarkable scaling linkage -- it copies a shape at a different size. It consists of four bars forming a parallelogram, with one pivot fixed, a tracing point on one arm, and a drawing point on the extension of another arm. The ratio of distances from the fixed pivot determines the scaling factor.

If the tracing point is at distance d1 from the fixed pivot and the drawing point is at distance d2, the scaling ratio is d2/d1. By adjusting the pivot positions along the arms, the scaling ratio can be varied continuously.

4.3 Lazy-Tongs (Brown's #144)

Brown's movement #144 shows lazy-tongs (also called Nuremberg scissors or scissor linkages). This is a series of interconnected pantograph units that can extend and retract linearly. Each parallelogram unit contributes a fixed ratio of extension, and cascading N units gives N-times the extension of a single unit.

Lazy-tongs appear in: expanding gates, accordion-style barriers, scissor lifts, extendable mirrors, extending grab tools, and deployable space structures (satellite solar panel booms). The mechanism converts a small input motion at one end into a large extension at the other, while maintaining approximate parallelism of the end effector.

5. Historical Development

6. Case Studies

7. Python Linkage Position Solver

"""
Straight-Line Linkage Position Solver
Brown's 507 Mechanical Movements - Part 17
Computes coupler curve points for Watt, Chebyshev, and Peaucellier linkages.
"""

import math


def watt_linkage_position(
    theta_deg: float,
    L1: float = 100.0,
    L2: float = 100.0,
    coupler: float = 33.0,
    pivot_spacing: float = 33.0
) -> dict:
    """
    Compute the coupler midpoint position for Watt's linkage.

    Parameters
    ----------
    theta_deg : float     Angle of left arm from vertical (degrees)
    L1 : float            Left arm length (mm)
    L2 : float            Right arm length (mm)
    coupler : float       Coupler length (mm)
    pivot_spacing : float  Horizontal distance between fixed pivots (mm)

    Returns
    -------
    dict with x, y position of coupler midpoint and deviation from straight line
    """
    theta = math.radians(theta_deg)

    # Left pivot at origin, right pivot at (pivot_spacing, 0)
    # Left arm endpoint
    Ax = L1 * math.sin(theta)
    Ay = -L1 * math.cos(theta)

    # Right arm must connect to coupler
    # Find right arm angle from geometry
    dx = pivot_spacing + L2 * math.sin(0) - Ax  # Simplified
    # Use circle-circle intersection for exact solution
    Bx_target = Ax + coupler  # Simplified horizontal coupler
    # For demonstration, use the symmetric case
    Bx = pivot_spacing + L2 * math.sin(-theta * L1 / L2)
    By = -L2 * math.cos(-theta * L1 / L2)

    # Coupler midpoint
    Mx = (Ax + Bx) / 2
    My = (Ay + By) / 2

    # Reference straight line (at theta=0)
    My_ref = -(L1 + L2) / 2  # Approximate reference

    return {
        'theta_deg': theta_deg,
        'midpoint_x_mm': round(Mx, 4),
        'midpoint_y_mm': round(My, 4),
        'deviation_from_vertical_mm': round(Mx - pivot_spacing / 2, 4),
        'arm_endpoint_A': (round(Ax, 2), round(Ay, 2)),
        'arm_endpoint_B': (round(Bx, 2), round(By, 2))
    }


def chebyshev_linkage_position(
    theta_deg: float,
    d: float = 100.0
) -> dict:
    """
    Compute tracer point for Chebyshev linkage (standard proportions).

    Standard Chebyshev: fixed pivots at distance d apart,
    cranks of length 1.25*d, coupler of length 0.5*d.

    Parameters
    ----------
    theta_deg : float     Crank angle in degrees
    d : float             Fixed pivot spacing (mm)

    Returns
    -------
    dict with tracer position and deviation
    """
    theta = math.radians(theta_deg)
    L_crank = 1.25 * d  # Crank length
    L_coupler = 0.5 * d  # Coupler length

    # Left crank endpoint
    Ax = L_crank * math.cos(theta)
    Ay = L_crank * math.sin(theta)

    # Right crank endpoint (must close the loop)
    # Solve circle-circle intersection
    # Circle 1: center A, radius L_coupler
    # Circle 2: center (d, 0), radius L_crank
    cx, cy = d, 0  # Right fixed pivot

    dist_AB = math.sqrt((cx - Ax)**2 + (cy - Ay)**2)

    if dist_AB > L_coupler + L_crank or dist_AB < abs(L_coupler - L_crank):
        return {'theta_deg': theta_deg, 'error': 'No valid configuration'}

    # Circle intersection
    a_param = (L_coupler**2 - L_crank**2 + dist_AB**2) / (2 * dist_AB)
    h = math.sqrt(max(0, L_coupler**2 - a_param**2))

    px = Ax + a_param * (cx - Ax) / dist_AB
    py = Ay + a_param * (cy - Ay) / dist_AB

    # Two solutions; take the one below the x-axis (conventional)
    Bx1 = px + h * (cy - Ay) / dist_AB
    By1 = py - h * (cx - Ax) / dist_AB
    Bx2 = px - h * (cy - Ay) / dist_AB
    By2 = py + h * (cx - Ax) / dist_AB

    # Choose solution (typically the lower one)
    Bx, By = (Bx1, By1) if By1 < By2 else (Bx2, By2)

    # Coupler midpoint
    Mx = (Ax + Bx) / 2
    My = (Ay + By) / 2

    # Ideal Y for perfect straight line (approximate center)
    ideal_y = -d * math.sqrt(1.25**2 - 0.5**2)  # Rough reference

    return {
        'theta_deg': theta_deg,
        'tracer_x_mm': round(Mx, 4),
        'tracer_y_mm': round(My, 4),
        'deviation_mm': round(My - ideal_y, 4) if 'ideal_y' in dir() else 'N/A',
        'crank_A': (round(Ax, 2), round(Ay, 2)),
        'crank_B': (round(Bx, 2), round(By, 2))
    }


def peaucellier_lipkin_position(
    theta_deg: float,
    a: float = 50.0,
    b: float = 80.0,
    constraint_radius: float = None
) -> dict:
    """
    Compute the output point of a Peaucellier-Lipkin linkage.

    Parameters
    ----------
    theta_deg : float   Angle of the input arm (degrees)
    a : float           Rhombus bar length (mm)
    b : float           Long bar length (mm)
    constraint_radius : float  Radius of constraint circle (default = b)

    Returns
    -------
    dict with input point, output point (on straight line), and verification
    """
    if constraint_radius is None:
        constraint_radius = b

    theta = math.radians(theta_deg)

    # Fixed pivot O at origin
    # Constraint pivot O' at (constraint_radius, 0)
    # Input point P moves on a circle of radius constraint_radius
    # centered at O', passing through O

    # Input point position (on circle centered at O')
    Px = constraint_radius + constraint_radius * math.cos(theta)
    Py = constraint_radius * math.sin(theta)

    # Distance from O to P
    OP = math.sqrt(Px**2 + Py**2)

    if OP < 1e-10:
        return {'theta_deg': theta_deg, 'error': 'Input at center of inversion'}

    # Inversion constant k^2 = b^2 - a^2
    k_sq = b**2 - a**2

    if k_sq <= 0:
        return {'theta_deg': theta_deg, 'error': 'b must be greater than a'}

    # Output point P' is the inversion of P: OP * OP' = k^2
    OP_prime = k_sq / OP

    # P' is along the same radial line from O as P
    scale = OP_prime / OP
    Qx = Px * scale
    Qy = Py * scale

    return {
        'theta_deg': theta_deg,
        'input_point': (round(Px, 3), round(Py, 3)),
        'output_point': (round(Qx, 3), round(Qy, 3)),
        'output_x_mm': round(Qx, 4),
        'output_y_mm': round(Qy, 4),
        'OP_mm': round(OP, 3),
        'OP_prime_mm': round(OP_prime, 3),
        'product_OP_x_OP_prime': round(OP * OP_prime, 3),
        'inversion_constant_k_sq': round(k_sq, 3),
        'is_exact_straight_line': True
    }


def pantograph_scaling(
    trace_x: float,
    trace_y: float,
    scaling_ratio: float = 0.5,
    pivot_x: float = 0,
    pivot_y: float = 0
) -> dict:
    """
    Compute pantograph output point for a given tracing point.

    Parameters
    ----------
    trace_x, trace_y : float    Tracing point position (mm)
    scaling_ratio : float        Output / input scaling ratio
    pivot_x, pivot_y : float     Fixed pivot position

    Returns
    -------
    dict with output position and scaling verification
    """
    # Pantograph scales relative to the fixed pivot
    out_x = pivot_x + scaling_ratio * (trace_x - pivot_x)
    out_y = pivot_y + scaling_ratio * (trace_y - pivot_y)

    trace_dist = math.sqrt((trace_x - pivot_x)**2 + (trace_y - pivot_y)**2)
    out_dist = math.sqrt((out_x - pivot_x)**2 + (out_y - pivot_y)**2)

    return {
        'trace_point': (round(trace_x, 2), round(trace_y, 2)),
        'output_point': (round(out_x, 2), round(out_y, 2)),
        'scaling_ratio': scaling_ratio,
        'trace_distance_from_pivot': round(trace_dist, 2),
        'output_distance_from_pivot': round(out_dist, 2),
        'actual_ratio': round(out_dist / trace_dist, 4) if trace_dist > 0 else 'N/A'
    }


# ── Example Usage ──
if __name__ == '__main__':
    print("=" * 65)
    print("  STRAIGHT-LINE LINKAGE POSITION SOLVER")
    print("  Brown's 507 Mechanical Movements - Part 17")
    print("=" * 65)

    # Example 1: Peaucellier-Lipkin linkage (exact straight line)
    print("\n--- Example 1: Peaucellier-Lipkin Linkage (Exact) ---")
    print(f"  {'Angle':>8s} | {'Output X':>10s} | {'Output Y':>10s} | "
          f"{'OP*OP_prime':>12s}")
    print("  " + "-" * 50)
    for angle in range(-60, 61, 15):
        p = peaucellier_lipkin_position(angle, a=50, b=80)
        if 'error' not in p:
            print(f"  {angle:8d} | {p['output_x_mm']:10.3f} | "
                  f"{p['output_y_mm']:10.3f} | "
                  f"{p['product_OP_x_OP_prime']:12.1f}")

    # Verify: output_x should be constant (straight line is vertical)
    print("  Note: Constant output_x confirms exact straight line!")

    # Example 2: Chebyshev linkage
    print("\n--- Example 2: Chebyshev Linkage (Approximate) ---")
    for angle in range(160, 201, 5):
        c = chebyshev_linkage_position(angle, d=100)
        if 'error' not in c:
            print(f"  theta={angle:4d} deg: x={c['tracer_x_mm']:8.2f}, "
                  f"y={c['tracer_y_mm']:8.2f}")

    # Example 3: Pantograph scaling
    print("\n--- Example 3: Pantograph Scaling (1:2 reduction) ---")
    for x, y in [(100, 0), (100, 50), (50, 100), (0, 100)]:
        ps = pantograph_scaling(x, y, scaling_ratio=0.5)
        print(f"  Trace ({x:4d},{y:4d}) -> Output "
              f"({ps['output_point'][0]:6.1f},{ps['output_point'][1]:6.1f})")

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

8. Exercises & Self-Assessment

Straight-Line Mechanism Design Generator

Document your straight-line or parallel motion linkage design:

Conclusion & Next Steps

You now understand one of the most celebrated problems in mechanism design:

• The straight-line problem -- converting rotary to exact linear motion without sliding guides -- challenged engineers for 80 years
• Watt's linkage (1784) provided a practical approximate solution that enabled the double-acting steam engine and the Industrial Revolution
• Chebyshev's linkage optimized the approximation mathematically, founding approximation theory along the way
• Peaucellier-Lipkin (1864) solved the problem exactly using 7 bars and the principle of circle inversion from pure mathematics
• Hart's linkage achieved exact straight-line with only 5 bars, the minimum for a planar inversor
• Pantographs and parallel rulers solve related problems of scaling and parallel translation