Mechanical Movements Part 21: Gearmotors, Sensors & Encoders

1. Gearmotor Fundamentals

What Is a Gearmotor?

A gearmotor combines an electric motor and a gear reducer into a single integrated package. The motor provides the base speed and power, while the gearbox reduces speed and multiplies torque by the gear ratio. The advantages of integration include compact size, pre-aligned components, sealed and lubricated gearing, and simplified installation.

Fundamental relationship:

DC Gearmotors

Brushed DC gearmotors use commutator brushes to switch current in the rotor windings. Simple to control (vary voltage to change speed), they are ideal for battery-powered applications, small robots, and consumer products. Permanent magnet types are the most common. Wound-field types allow field weakening for extended speed range. Drawback: brushes wear and require replacement.

Brushless DC (BLDC) gearmotors replace the mechanical commutator with electronic switching (using Hall sensors or encoder feedback). Benefits include longer life (no brush wear), higher efficiency, lower EMI, and better heat dissipation (windings on the stator). They require an electronic controller (ESC) but offer superior performance for demanding applications.

AC Gearmotors

AC induction gearmotors are the workhorses of industrial automation. The squirrel-cage rotor requires no electrical connection, making these motors extremely rugged and maintenance-free. Speed is determined primarily by supply frequency and the number of poles. Variable Frequency Drives (VFDs) enable precise speed control by varying the supply frequency.

AC synchronous gearmotors run at exact synchronous speed (locked to supply frequency). They provide precise speed control without slip and are used where multiple motors must maintain exact speed synchronization.

Stepper & Servo Gearmotors

Stepper motor gearmotors divide a full rotation into discrete steps (typically 200 steps/revolution = 1.8 degrees/step). With a 100:1 gear reducer, resolution becomes 0.018 degrees per step. Open-loop positioning is possible because each step is deterministic. Adding microstepping and a gearbox achieves excellent positioning resolution for 3D printers, CNC routers, and automation equipment.

Servo motor gearmotors combine a high-performance motor (brushless DC or AC synchronous) with a precision gearbox and an integrated encoder. The servo controller closes a position/velocity/current loop at kilohertz rates, providing the highest dynamic performance -- fast acceleration, precise trajectory tracking, and smooth velocity profiles. Used in robotics, semiconductor manufacturing, and CNC machine tools.

2. Gearmotor Types by Gear

Spur & Helical Gearmotors

Spur gearmotors use straight-cut gears with teeth parallel to the shaft axis. They are the simplest and cheapest gear type, with efficiency up to 98% per stage. However, they produce more noise and vibration than helical gears because tooth contact occurs suddenly across the full face width.

Helical gearmotors use gears with angled teeth, providing gradual tooth engagement and disengagement. This results in smoother, quieter operation and higher load capacity compared to equivalent-size spur gears. The trade-off is axial thrust forces that must be absorbed by thrust bearings, and slightly lower efficiency (95-97% per stage) due to sliding friction along the tooth helix.

Planetary Gearmotors

Planetary (epicyclic) gearmotors use a central sun gear, multiple planet gears, and a ring gear to achieve high torque density in a compact coaxial package. The load is shared among multiple planet gears (typically 3-5), distributing forces and enabling higher torque capacity than equivalent-size parallel shaft gearboxes.

Advantages: Coaxial input/output, high torque density, compact size, high efficiency (95-97% per stage), low backlash (precision types), high ratio per stage (3:1 to 10:1).

Applications: Robotic joints, servo actuators, electric vehicle drives, aerospace actuators, precision positioning stages.

Worm Gearmotors

Worm gearmotors use a worm (helical screw) meshing with a worm wheel to achieve very high single-stage ratios (5:1 to 100:1) with right-angle output. A unique feature: at high ratios, worm gears are self-locking -- the load cannot back-drive the motor. This provides built-in holding without a brake.

Disadvantages: Lower efficiency (40-90% depending on ratio and lubrication) due to significant sliding friction between worm and wheel. High ratios are the least efficient. The worm wheel is typically bronze or polymer, limiting operating temperature and requiring careful lubrication.

Gearmotor Comparison Table

3. Selection Criteria

Selecting the right gearmotor requires balancing multiple interrelated parameters:

• Torque: Continuous rated torque, peak (intermittent) torque, and starting torque must all be specified. The gearbox must handle peak loads without damage and continuous loads without overheating.
• Speed: Required output speed range and maximum speed. High ratios reduce speed but some gear types have maximum input speed limits.
• Duty cycle: Continuous, intermittent, or cyclic operation affects thermal rating. A gearmotor rated for continuous duty at 100% load may handle 150% load for short periods.
• Environment: Temperature range, ingress protection (IP rating), washdown requirements, explosive atmospheres (ATEX), food-grade lubrication.
• Efficiency: Critical for battery-powered or high-duty applications. Worm gear losses at high ratios can waste 30-60% of input power as heat.
• Noise: Hospital equipment, office machines, and consumer products demand quiet operation -- helical and planetary gears are preferred over spur.
• Backlash: For precision positioning, backlash (lost motion at gear mesh) must be minimized. Standard: 1-2 degrees. Precision planetary: 3-10 arcminutes. Harmonic drive: less than 1 arcminute.
• Cost: Spur and worm gearmotors are cheapest. Planetary and harmonic drives are premium.

4. Encoders

Incremental Encoders

Incremental encoders generate pulses as the shaft rotates. Each pulse represents a fixed angular increment. Two channels (A and B) in quadrature (90-degree phase offset) provide both position and direction information. A third channel (Z or index) provides one pulse per revolution for homing.

Optical incremental encoders use a glass or polymer disc with a pattern of opaque and transparent lines. An LED and photodetector pair reads the pattern. Resolutions from 100 to 100,000+ counts per revolution. High precision but sensitive to contamination, vibration, and extreme temperatures.

Magnetic incremental encoders use a magnetized ring or disc with alternating poles. Hall effect or magnetoresistive sensors detect the magnetic pattern. More robust than optical (immune to dust, oil, vibration) but typically lower resolution (up to ~10,000 CPR).

Absolute Encoders

Absolute encoders report a unique position code for every angular position -- position is known immediately at power-up without homing. This is critical for safety-related applications and systems that cannot tolerate loss of position after power failure.

Single-turn absolute encoders provide a unique code within one revolution (typically 10-20 bit resolution, giving 1,024 to 1,048,576 positions per turn).

Multi-turn absolute encoders additionally count revolutions (typically 12-16 bit turn counter), providing absolute position over millions of revolutions. Implemented via battery-backed electronic counters, mechanical gear trains (Wiegand wire), or energy-harvesting systems.

Resolution vs Accuracy

5. Sensors & Feedback Devices

Resolvers

A resolver is an electromagnetic rotary position sensor -- essentially a small, ruggedized transformer whose coupling varies with shaft angle. The rotor carries a single winding excited by a high-frequency AC signal. Two stator windings (sine and cosine) pick up signals whose amplitude varies as sin(theta) and cos(theta) of the shaft angle.

A resolver-to-digital converter (RDC) extracts the angle from the ratio of the two stator signals. Resolvers are extremely rugged (no electronics on the rotor, no optical components) and operate reliably from -55C to +175C, under severe vibration, and in high-radiation environments. They are standard in military, aerospace, and automotive applications (electric vehicle motor commutation).

Hall Effect Sensors

Hall effect sensors detect magnetic fields. In motor applications, three Hall sensors spaced 120 degrees apart inside a brushless DC motor detect the rotor magnet position, providing the commutation signals needed to energize the correct stator windings. Resolution is coarse (6 states per electrical revolution) but sufficient for basic motor commutation.

For higher precision, linear Hall sensors combined with a multi-pole magnetic ring can provide continuous analog position output, serving as a simpler alternative to encoders in cost-sensitive applications.

Limit Switches & Torque Sensors

Limit switches are simple on/off sensors that detect when a mechanism reaches its end-of-travel position. Mechanical (micro-switch), magnetic (reed switch), optical (through-beam), and inductive (proximity) types are used depending on the environment. They provide essential safety interlocks and homing references.

Torque sensors measure the torque transmitted through a shaft. Strain gauge-based sensors bonded to a torsion element are the most accurate method. Rotary transformers or slip rings transfer the signal from the rotating shaft to the stationary electronics. Torque measurement enables force-controlled assembly (bolt tightening to spec), process monitoring, and compliant robot control.

Current sensing for torque estimation: Motor torque is approximately proportional to current (T = Kt × I, where Kt is the motor torque constant). Measuring motor current with a shunt resistor or Hall sensor provides an indirect but inexpensive torque estimate. This is widely used in servo drives for current (torque) loop control, the innermost and fastest loop in a cascaded servo control architecture.

Back-EMF Measurement

When a DC motor spins, it generates a voltage proportional to speed called back-EMF (V_emf = Ke × omega). Measuring the back-EMF during brief periods when the drive transistors are off (in PWM gaps) provides sensorless speed measurement. This eliminates the need for a tachometer or encoder for basic speed control, reducing cost and complexity in applications like fans, pumps, and simple conveyors.

6. Closed-Loop Speed & Position Control

Closed-loop control compares the desired setpoint with measured feedback and adjusts the motor drive to minimize the error. Modern servo systems use a cascaded control architecture with three nested loops:

1. Current (torque) loop (innermost, fastest): Measures motor current via shunt/Hall sensor, compares to commanded torque (current setpoint), and adjusts PWM duty cycle. Bandwidth: 1-10 kHz. This loop ensures the motor produces the commanded torque regardless of speed or load changes.
2. Velocity loop (middle): Measures speed via encoder differentiation or direct velocity feedback, compares to commanded speed, and generates a current (torque) command for the inner loop. Bandwidth: 100-1000 Hz. Controls speed precisely during motion profiles.
3. Position loop (outermost, slowest): Measures position via encoder count, compares to commanded position from the trajectory planner, and generates a velocity command for the middle loop. Bandwidth: 10-100 Hz. Ensures the actuator follows the desired motion profile with minimal following error.

The standard controller for each loop is the PID controller (Proportional-Integral-Derivative). The proportional term responds to current error, the integral term eliminates steady-state error, and the derivative term provides damping. Proper tuning of PID gains at each level is essential for stable, responsive performance.

7. Historical Development

8. Case Studies

Case Study 1: Robotic Joint Servo Gearmotor

A 6-axis industrial robot (e.g., ABB IRB 6700) uses servo gearmotors at each joint. The wrist joints (J4, J5, J6) typically use brushless AC servo motors with harmonic drive reducers (ratios of 100:1 to 160:1). The harmonic drive provides near-zero backlash (under 1 arcminute), essential for the 0.05mm repeatability specification.

Each joint has a 17-bit absolute encoder (131,072 counts/revolution) providing position feedback. The servo drive runs the cascaded PID loops at 8 kHz (current loop), 2 kHz (velocity loop), and 1 kHz (position loop). The robot controller coordinates all six joints simultaneously to move the end effector along programmed paths.

Case Study 2: Conveyor Drive Helical Gearmotor

A package sorting conveyor uses a 5 HP AC induction motor with a helical gear reducer (25:1 ratio, 95% efficiency). The motor runs at 1,750 RPM; the output shaft delivers 70 RPM at approximately 300 lb-ft of torque to the conveyor drive sprocket.

A VFD controls motor speed for smooth acceleration/deceleration and adjustable conveyor speed. An incremental encoder on the motor shaft provides speed feedback to the VFD for precise speed regulation. Helical gears are chosen over spur for quiet operation in the warehouse environment.

Case Study 3: CNC Stepper with Planetary Gearbox

A desktop CNC router uses NEMA 23 stepper motors with 5:1 planetary gearboxes on each axis. The stepper motor provides 200 steps/revolution; with 16x microstepping, this becomes 3,200 microsteps/revolution. Through the 5:1 planetary gearbox, the output resolution becomes 16,000 microsteps/revolution.

Driving a 5mm pitch ball screw, this yields a theoretical resolution of 5mm / 16,000 = 0.0003125 mm (0.3 micrometers) per microstep. In practice, the planetary gearbox backlash (~6 arcminutes) and ball screw accuracy limit actual positioning to approximately 0.01mm -- more than sufficient for wood and aluminum routing.

9. Python Gearmotor Selection Calculator

This Python script helps select a gearmotor by calculating required motor specifications from the load requirements:

"""
Gearmotor Selection Calculator
Calculates motor requirements from load specifications and recommends gear types.
"""

import math

def gearmotor_calc(load_torque_nm, output_rpm, gear_ratio, gear_efficiency=0.95,
                   service_factor=1.5):
    """
    Calculate motor requirements for a gearmotor application.

    Parameters:
        load_torque_nm: Required output torque in Nm
        output_rpm: Required output speed in RPM
        gear_ratio: Gear reduction ratio
        gear_efficiency: Gearbox efficiency (0-1)
        service_factor: Safety factor for intermittent loads

    Returns:
        Dictionary with motor requirements and system specifications
    """
    # Motor speed
    motor_rpm = output_rpm * gear_ratio

    # Motor torque (accounting for gear efficiency)
    motor_torque = (load_torque_nm * service_factor) / (gear_ratio * gear_efficiency)

    # Power calculations
    output_power_w = load_torque_nm * output_rpm * 2 * math.pi / 60
    motor_power_w = output_power_w / gear_efficiency
    motor_power_hp = motor_power_w / 745.7

    # Angular velocity
    output_rad_s = output_rpm * 2 * math.pi / 60
    motor_rad_s = motor_rpm * 2 * math.pi / 60

    return {
        'load_torque_nm': load_torque_nm,
        'output_rpm': output_rpm,
        'gear_ratio': gear_ratio,
        'gear_efficiency_pct': round(gear_efficiency * 100, 1),
        'service_factor': service_factor,
        'motor_rpm': round(motor_rpm, 0),
        'motor_torque_nm': round(motor_torque, 3),
        'motor_torque_oz_in': round(motor_torque * 141.612, 1),
        'output_power_w': round(output_power_w, 1),
        'motor_power_w': round(motor_power_w, 1),
        'motor_power_hp': round(motor_power_hp, 3),
        'output_rad_s': round(output_rad_s, 2),
        'motor_rad_s': round(motor_rad_s, 2)
    }

def encoder_resolution(encoder_cpr, gear_ratio, screw_pitch_mm=None):
    """
    Calculate positioning resolution with encoder and gearbox.

    Parameters:
        encoder_cpr: Encoder counts per revolution
        gear_ratio: Gear reduction ratio
        screw_pitch_mm: Lead screw pitch in mm (if linear application)

    Returns:
        Dictionary with resolution calculations
    """
    # Quadrature decoding (4x) is standard
    effective_cpr = encoder_cpr * 4  # quadrature
    output_counts_per_rev = effective_cpr * gear_ratio

    angular_res_deg = 360.0 / output_counts_per_rev
    angular_res_arcmin = angular_res_deg * 60
    angular_res_arcsec = angular_res_arcmin * 60

    result = {
        'encoder_cpr': encoder_cpr,
        'quadrature_cpr': effective_cpr,
        'gear_ratio': gear_ratio,
        'output_counts_per_rev': int(output_counts_per_rev),
        'angular_resolution_deg': round(angular_res_deg, 6),
        'angular_resolution_arcmin': round(angular_res_arcmin, 4),
        'angular_resolution_arcsec': round(angular_res_arcsec, 2)
    }

    if screw_pitch_mm:
        linear_res_mm = screw_pitch_mm / output_counts_per_rev
        linear_res_um = linear_res_mm * 1000
        result['screw_pitch_mm'] = screw_pitch_mm
        result['linear_resolution_mm'] = round(linear_res_mm, 6)
        result['linear_resolution_um'] = round(linear_res_um, 3)

    return result

def recommend_gear_type(ratio, backlash_req_arcmin=None,
                        self_locking=False, noise_sensitive=False):
    """Recommend gear type based on requirements."""
    recommendations = []

    if self_locking:
        recommendations.append(("Worm", "Self-locking at high ratios, simple, compact"))

    if backlash_req_arcmin is not None and backlash_req_arcmin < 3:
        recommendations.append(("Harmonic Drive", "Near-zero backlash, very high ratio"))
        recommendations.append(("Precision Planetary", "Low backlash, high efficiency"))
    elif ratio <= 10:
        if noise_sensitive:
            recommendations.append(("Helical", "Quiet, efficient, moderate cost"))
        else:
            recommendations.append(("Spur", "Lowest cost, high efficiency"))
        recommendations.append(("Planetary", "Compact, coaxial, high torque density"))
    elif ratio <= 100:
        recommendations.append(("Multi-stage Planetary", "High ratio with good efficiency"))
        recommendations.append(("Worm", "Single stage high ratio, self-locking option"))
    else:
        recommendations.append(("Harmonic Drive", "Extreme ratios with zero backlash"))
        recommendations.append(("Cycloidal", "High ratio, high torque, rugged"))

    return recommendations

def print_selection_report(torque, rpm, ratio, efficiency=0.95):
    """Print complete gearmotor selection report."""
    print("=" * 60)
    print("  GEARMOTOR SELECTION REPORT")
    print("=" * 60)

    calc = gearmotor_calc(torque, rpm, ratio, efficiency)

    print(f"\n  --- Load Requirements ---")
    print(f"  Output Torque:    {calc['load_torque_nm']} Nm")
    print(f"  Output Speed:     {calc['output_rpm']} RPM")
    print(f"  Output Power:     {calc['output_power_w']} W")

    print(f"\n  --- Gearbox ---")
    print(f"  Gear Ratio:       {calc['gear_ratio']}:1")
    print(f"  Efficiency:       {calc['gear_efficiency_pct']}%")

    print(f"\n  --- Motor Requirements ---")
    print(f"  Motor Speed:      {calc['motor_rpm']} RPM")
    print(f"  Motor Torque:     {calc['motor_torque_nm']} Nm "
          f"({calc['motor_torque_oz_in']} oz-in)")
    print(f"  Motor Power:      {calc['motor_power_w']} W "
          f"({calc['motor_power_hp']} HP)")

    recs = recommend_gear_type(ratio)
    print(f"\n  --- Recommended Gear Types ---")
    for name, reason in recs:
        print(f"    {name}: {reason}")

    print("=" * 60)

if __name__ == "__main__":
    print("\n--- Robot Joint Servo ---")
    print_selection_report(torque=50, rpm=30, ratio=100, efficiency=0.80)

    print("\n--- Conveyor Drive ---")
    print_selection_report(torque=40, rpm=70, ratio=25, efficiency=0.95)

    print("\n--- Encoder Resolution Example ---")
    enc = encoder_resolution(encoder_cpr=2500, gear_ratio=50, screw_pitch_mm=5)
    print(f"\n  Encoder: 2500 CPR, Gear: 50:1, Screw: 5mm pitch")
    print(f"  Output counts/rev: {enc['output_counts_per_rev']}")
    print(f"  Angular res: {enc['angular_resolution_arcsec']} arcsec")
    print(f"  Linear res: {enc['linear_resolution_um']} um")

10. Exercises & Self-Assessment

1. Gearmotor Selection: A conveyor requires 25 Nm of torque at the drive roller, running at 60 RPM. Select a gear ratio to use a standard 1,750 RPM AC motor. Calculate the required motor torque assuming 94% gear efficiency and a 1.5 service factor.
2. Encoder Resolution: A CNC lathe uses a 2,048-line incremental encoder on a servo motor with a 10:1 planetary gearbox driving a 6mm pitch ball screw. Calculate the theoretical linear positioning resolution using 4x quadrature decoding.
3. Efficiency Comparison: Compare total system efficiency for two options delivering 100 RPM, 30 Nm output: (a) 3,000 RPM motor with 30:1 worm gear (70% efficiency), and (b) 1,000 RPM motor with two-stage 10:1 planetary (94% each stage). Calculate input power for each and the annual energy cost difference at $0.12/kWh, running 16 hours/day.
4. Backlash Impact: A robotic arm joint has 5 arcminutes of gearbox backlash. If the arm length from the joint to the end effector is 500mm, calculate the maximum positioning error at the tool tip caused by backlash alone.
5. Servo Tuning: Explain why the cascaded control architecture (current-velocity-position) is superior to a single position loop that directly commands PWM. What happens if you try to tune a position loop without an inner current loop?
6. Resolver vs Encoder: An electric vehicle traction motor operates at 180C ambient, 15g vibration, and must provide rotor position for field-oriented control. Recommend and justify the position sensor type. Why is an optical encoder unsuitable?
7. Self-Locking Analysis: A worm gearmotor (50:1 ratio) drives a vertical lift. Calculate the minimum worm lead angle that would allow the load to back-drive the motor (assume friction coefficient of 0.08). Is this ratio inherently self-locking?

11. Gearmotor Specification Generator

Document your gearmotor selection and specification. Fill in the fields below and generate professional documentation.

Conclusion & Next Steps

You now understand how modern electromechanical actuators combine motors, gearboxes, sensors, and control loops into integrated systems. Here are the key takeaways from Part 21:

• Gearmotors integrate motors and gearboxes for optimized torque/speed conversion -- the gear type (spur, helical, planetary, worm, harmonic) is selected based on ratio, efficiency, backlash, noise, and cost requirements
• Planetary gearmotors offer the best torque density and efficiency for precision applications, while worm gearmotors provide self-locking and high single-stage ratios
• Incremental encoders provide relative position via pulse counting, while absolute encoders report unique position at power-up -- both are essential for different applications
• Resolvers are the preferred sensor for harsh environments (extreme temperature, vibration, radiation) where optical encoders cannot survive
• Closed-loop cascaded control (current, velocity, position) provides the foundation for all modern servo systems -- always tune from the inside out
• Resolution is not accuracy -- high-resolution encoders can still report inaccurate positions if mounting, disc eccentricity, or interpolation errors are present