Linear Actuators: Lead Screw, Ball Screw & Voice Coil

Overview & Types

Linear actuators convert energy into straight-line motion, providing push or pull force along a single axis. They are essential wherever rotary-to-linear conversion or direct linear force is needed – from adjustable desks to CNC machines to camera autofocus systems.

Major Types

• Lead Screw Actuator: A motor (DC or stepper) drives a threaded rod through a nut. Simple, self-locking at rest, widely used in 3D printers (Z-axis), adjustable furniture, and automation. Typical efficiency: 25–50%.
• Ball Screw Actuator: Uses recirculating steel balls between screw and nut for rolling contact instead of sliding. Higher efficiency (85–95%), lower friction, used in CNC machines and precision positioning. Not self-locking.
• Belt/Rack-and-Pinion: Motor drives a belt or gear that moves a carriage linearly. High speed, long travel, used in 3D printers (X/Y axes), pick-and-place, and sliding doors.
• Voice Coil Actuator (VCA): A coil in a magnetic field produces force proportional to current. Extremely fast response (sub-millisecond), short stroke (0.1–25 mm), used in hard disk heads, camera autofocus, and haptic devices.
• Electric Linear Actuator (enclosed): Self-contained units with motor, gearbox, lead screw, and limit switches in a sealed housing. “Plug and play” for automation, furniture, medical equipment.
• Linear Stepper Motor: Direct electromagnetic linear motion without rotary-to-linear conversion. High precision, used in semiconductor manufacturing.

Working Principle

Rotary-to-Linear Conversion

Most linear actuators use a rotary motor coupled to a mechanical converter:

• Lead Screw: Thread pitch determines travel per revolution. Example: 8 mm lead × 200 steps/rev = 0.04 mm per full step. Lead angle determines self-locking capability.
• Ball Screw: Balls in helical grooves convert rotation to translation with minimal friction. Preloaded designs eliminate backlash.
• Rack and Pinion: Pinion gear on motor shaft meshes with linear rack. Travel per revolution = π × pitch diameter.

Direct Linear Actuation

Voice coil actuators work on the Lorentz force principle directly:

• A coil moves within a radial magnetic field.
• Force is proportional to current: F = BIL (B=field, I=current, L=coil length).
• No mechanical conversion losses → near-instantaneous response.
• Position proportional to current (with spring return) or requires feedback for positioning.

Electrical & Mechanical Specifications

Parameter	Lead Screw	Ball Screw	Voice Coil	Electric Linear
Stroke	50–1000 mm	100–3000 mm	0.1–25 mm	50–600 mm
Force	10–500 N	50–50,000 N	0.1–100 N	50–10,000 N
Speed	1–50 mm/s	10–500 mm/s	1–100 m/s	5–50 mm/s
Precision	0.01–0.1 mm	0.001–0.01 mm	0.001 mm	0.5–2 mm
Efficiency	25–50%	85–95%	30–50%	20–40%
Self-Locking	Yes (low lead angle)	No	No	Yes (worm gear)
Cost	Low	Medium–High	Medium	Low–Medium
Voltage	5–48 V (motor)	24–400 V	5–48 V	12–36 V

Driver Circuits

DC Motor-Based Linear Actuators

Self-contained electric linear actuators use a DC motor and accept H-bridge control (same as DC motors):

• L298N / BTS7960: For actuators up to 10 A. Direction via H-bridge, speed via PWM.
• IBT-2 (BTS7960 module): 43 A capacity for heavy-duty actuators.
• Limit Switches: Most enclosed linear actuators have built-in limit switches that cut power at full extension/retraction.

Stepper-Based Linear Systems

Lead screw / ball screw driven by stepper motors use standard stepper drivers (A4988, TMC2209). Position accuracy comes from step counting.

Voice Coil Drivers

Voice coils need current-mode amplifiers (not voltage-mode). A linear amplifier or high-bandwidth current-controlled PWM driver is used. Position feedback typically from an LVDT, encoder, or Hall sensor.

Control Methods

Bang-Bang (On/Off)

Simplest control: extend fully or retract fully using direction pins. Common for door locks, window openers, and simple automation.

Position Control with Feedback

Read the built-in potentiometer or external encoder, and use PID control to hold a precise position. The potentiometer provides absolute position without homing.

Force-Limiting Control

Monitor motor current to detect when the actuator hits an obstacle or reaches the desired clamping force. Cut power or reduce PWM to prevent damage. Essential for safety-critical applications (pinch protection).

Code Example — Arduino & ESP32

Arduino: Position Control with Feedback Pot

// Linear actuator position control with feedback potentiometer
// Wiring: RPWM→D5, LPWM→D6, POT→A0, VCC→12V via BTS7960

const int RPWM = 5;   // Extend
const int LPWM = 6;   // Retract
const int POT_PIN = A0;

// Calibrate these values for your actuator
const int POS_MIN = 50;    // ADC at full retract
const int POS_MAX = 950;   // ADC at full extend
const int DEADBAND = 10;   // ± tolerance

void setup() {
    pinMode(RPWM, OUTPUT);
    pinMode(LPWM, OUTPUT);
    Serial.begin(9600);
    Serial.println("Linear Actuator Position Control");
    Serial.println("Send position 0-100 via Serial");
}

void stopActuator() {
    analogWrite(RPWM, 0);
    analogWrite(LPWM, 0);
}

void moveToPosition(int targetPercent) {
    int target = map(targetPercent, 0, 100, POS_MIN, POS_MAX);
    Serial.print("Moving to ");
    Serial.print(targetPercent);
    Serial.println("%");

    unsigned long timeout = millis() + 10000; // 10s safety timeout

    while (millis() < timeout) {
        int current = analogRead(POT_PIN);
        int error = target - current;

        if (abs(error) <= DEADBAND) {
            stopActuator();
            Serial.println("Position reached");
            return;
        }

        // Proportional speed control
        int speed = constrain(abs(error), 80, 255);

        if (error > 0) {
            analogWrite(RPWM, speed);
            analogWrite(LPWM, 0);
        } else {
            analogWrite(RPWM, 0);
            analogWrite(LPWM, speed);
        }
        delay(10);
    }
    stopActuator();
    Serial.println("Timeout - position not reached");
}

void loop() {
    if (Serial.available()) {
        int pos = Serial.parseInt();
        pos = constrain(pos, 0, 100);
        moveToPosition(pos);
    }
}

ESP32: Stepper-Driven Lead Screw with Homing

// Linear motion via stepper + lead screw on ESP32
// Wiring: STEP→GPIO18, DIR→GPIO19, LIMIT→GPIO21
// Lead screw: 8mm lead, stepper 200 steps/rev, 1/16 microstep

#include <Arduino.h>

#define STEP_PIN  18
#define DIR_PIN   19
#define LIMIT_PIN 21  // Limit switch (normally open, active LOW)

const float LEAD_MM = 8.0;
const int STEPS_PER_REV = 200 * 16;  // 3200 microsteps/rev
const float MM_PER_STEP = LEAD_MM / STEPS_PER_REV;

long currentPosition = 0; // steps from home

void setup() {
    Serial.begin(115200);
    pinMode(STEP_PIN, OUTPUT);
    pinMode(DIR_PIN, OUTPUT);
    pinMode(LIMIT_PIN, INPUT_PULLUP);
    Serial.println("Homing...");
    homeAxis();
    Serial.println("Homed. Send distance in mm via Serial.");
}

void stepMotor(int delayUs) {
    digitalWrite(STEP_PIN, HIGH);
    delayMicroseconds(2);
    digitalWrite(STEP_PIN, LOW);
    delayMicroseconds(delayUs);
}

void homeAxis() {
    digitalWrite(DIR_PIN, LOW); // Retract direction
    while (digitalRead(LIMIT_PIN) == HIGH) {
        stepMotor(500);
    }
    currentPosition = 0;
    // Back off limit switch
    digitalWrite(DIR_PIN, HIGH);
    for (int i = 0; i < 100; i++) stepMotor(500);
    currentPosition = 100;
}

void moveToMM(float targetMM) {
    long targetSteps = (long)(targetMM / MM_PER_STEP);
    long stepsToMove = targetSteps - currentPosition;
    digitalWrite(DIR_PIN, stepsToMove > 0 ? HIGH : LOW);

    long absSteps = abs(stepsToMove);
    Serial.printf("Moving %.2f mm (%ld steps)\n", targetMM, absSteps);

    for (long i = 0; i < absSteps; i++) {
        if (digitalRead(LIMIT_PIN) == LOW && stepsToMove < 0) {
            Serial.println("Limit hit!");
            break;
        }
        stepMotor(200); // ~2500 steps/s ≈ 6.25 mm/s
        currentPosition += (stepsToMove > 0) ? 1 : -1;
    }
    Serial.printf("Position: %.2f mm\n",
                  currentPosition * MM_PER_STEP);
}

void loop() {
    if (Serial.available()) {
        float mm = Serial.parseFloat();
        moveToMM(mm);
    }
}

Real-World Applications

Advantages vs. Alternatives

vs. Actuator	Linear Actuator Advantage	Linear Actuator Disadvantage
Pneumatic Cylinder	Precise positioning, no air supply needed, quieter	Generally slower, lower force-to-size ratio
Hydraulic Cylinder	Cleaner, no fluid leaks, simpler maintenance	Much lower force capacity
Solenoid	Variable position (not just two states), higher force	Slower response, more complex
Rotary Motor + Linkage	True linear motion, no complex linkage design	Limited to single-axis motion

Limitations & Considerations

• Speed: Lead screw types are inherently slow (5–50 mm/s). Ball screws are faster but more expensive. For high speed, use belt or rack-and-pinion.
• Load Rating: Duty cycle affects load capacity. Most electric linear actuators specify load at 25% duty cycle. Continuous operation reduces maximum force.
• Backlash: Lead screws and rack-and-pinion systems have backlash. Ball screws minimize it via preload. Voice coils have zero backlash.
• Temperature: Motor heating at high duty cycles reduces performance. IP-rated enclosures may limit heat dissipation.
• Side Loading: Avoid applying forces perpendicular to the axis of motion. Side loads accelerate wear and can bend the shaft.
• End-of-Stroke Protection: Always include limit switches or current monitoring to prevent the actuator from driving past its travel limits.