Soft Robotics Actuators: PneuNets, McKibben & Grippers

Overview & Types

Soft robotics actuators are made from compliant, deformable materials — silicone elastomers, fabrics, and gels — that move by inflation, tendon-pulling, or material phase change. Unlike rigid robots, soft actuators inherently conform to objects, making them ideal for handling delicate items, interacting safely with humans, and navigating unstructured environments.

Types

• Pneumatic Soft Actuator (PneuNet/Fiber-Reinforced): Silicone body with internal chambers that inflate asymmetrically, causing bending, twisting, or extension. The most common soft actuator. Examples: PneuNet bending fingers, fiber-reinforced extending actuators.
• Vacuum-Driven Actuator: Chambers collapse under vacuum, producing contraction and bending. Safer than pressure-driven (no pop risk), self-limiting. Used in grippers and locomotion.
• McKibben Muscle (Pneumatic Artificial Muscle): Braided mesh sleeve over inflatable bladder. Inflation causes radial expansion and axial contraction, mimicking biological muscle. High force-to-weight ratio.
• Tendon-Driven Soft Actuator: Flexible body with embedded tendons (cables/threads) that are pulled by external motors. Combines soft compliance with precise motor control. Used in soft robotic hands.
• Jamming Gripper: Flexible membrane filled with granular material (coffee grounds, glass beads). Vacuum packing transitions from soft to rigid, conforming to and gripping arbitrary objects.
• Hydraulic Soft Actuator: Similar to pneumatic but uses incompressible fluid. Higher force, no compressibility issues, but heavier. Suitable for underwater or high-force applications.
• Dielectric Elastomer Soft Actuator: DEA membranes integrated into soft structures for electrically-driven soft actuation without pneumatics. See Smart Material Actuators.

Working Principle

PneuNet Bending

1. Fabrication: Multi-layer silicone casting creates chambers connected by channels. A strain-limiting layer (paper, fabric, or stiffer silicone) is bonded to one side.
2. Inflation: Air pressure (10–100 kPa) inflates the chambers. The expandable side stretches while the strain-limiting side doesn’t, causing the actuator to curl toward the stiffer side.
3. Bending Angle: Proportional to pressure. Typical PneuNet achieves 0–270° bending at 0–70 kPa.
4. Deflation: Releasing pressure allows elastic restoring force to straighten the actuator.

Soft Actuator Specifications

Parameter	PneuNet Finger	McKibben Muscle	Vacuum Actuator
Material	Ecoflex/Dragon Skin silicone	Latex bladder + braided sleeve	Ecoflex silicone
Operating Pressure	0–70 kPa	100–600 kPa	−50 to −90 kPa (vacuum)
Motion	Bending 0–270°	Contraction 20–35%	Bending/contraction
Force	0.5–5 N per finger	50–500 N	0.5–3 N
Response Time	0.1–2 s	0.1–1 s	0.2–3 s
Weight	5–30 g per finger	20–200 g	5–20 g
Lifecycle	10K–100K cycles	100K+ cycles	10K–100K cycles

Pneumatic Control Hardware

Miniature Pump + Valve

Small diaphragm pumps (3–12 V, 1–5 L/min) with solenoid valves provide portable inflation. Key components:

• Air Pump: 6V or 12V DC diaphragm pump (e.g., KPM27H). Driven via MOSFET from GPIO.
• Solenoid Valve: 3/2-way normally-closed valve directs air to actuator or vents to atmosphere.
• Pressure Sensor: BMP280 or MPXV7025 monitors chamber pressure for closed-loop control.

Syringe Pump (Lab/Prototype)

Stepper-driven syringe provides precise volume control for low-pressure applications. Ideal for prototyping and characterization.

Vacuum Generator

For vacuum actuators: small vacuum pump or venturi generator connected to collapsible chambers.

Control Methods

Pressure Regulation

Closed-loop pressure control: sensor reads chamber pressure, PID adjusts pump/valve duty cycle. This provides repeatable bending angles.

Volume Control

In syringe-pump systems, controlling the injected volume directly determines actuator configuration. More precise than pressure control for some geometries.

Feedforward + Feedback

Model-based feedforward (pressure-to-curvature mapping) combined with sensor feedback (flex sensor, IMU, or camera vision) enables accurate trajectory tracking.

Code Example — Arduino & ESP32

Arduino: Soft Gripper with Pressure Control

// Soft pneumatic gripper with pressure feedback
// Wiring: Pump→MOSFET→D5, Valve→MOSFET→D6
// Pressure sensor (MPXV7025) → A0
// Grip button → D2, Release button → D3

const int PUMP_PIN = 5;
const int VALVE_PIN = 6;  // Vent valve (normally closed)
const int PRESSURE_PIN = A0;
const int GRIP_BTN = 2;
const int RELEASE_BTN = 3;

const float TARGET_PRESSURE = 40.0;  // kPa for gentle grip
const float MAX_PRESSURE = 70.0;     // Safety limit

void setup() {
    Serial.begin(9600);
    pinMode(PUMP_PIN, OUTPUT);
    pinMode(VALVE_PIN, OUTPUT);
    pinMode(GRIP_BTN, INPUT_PULLUP);
    pinMode(RELEASE_BTN, INPUT_PULLUP);
    release();
    Serial.println("Soft Gripper Ready");
}

float readPressure() {
    int raw = analogRead(PRESSURE_PIN);
    float voltage = (raw / 1023.0) * 5.0;
    // MPXV7025: 0.2V=0kPa, 4.7V=25kPa (adjust for sensor)
    return ((voltage - 0.2) / 4.5) * 100.0;  // kPa
}

void grip() {
    digitalWrite(VALVE_PIN, LOW);  // Close vent
    float pressure = readPressure();
    while (pressure < TARGET_PRESSURE) {
        if (pressure > MAX_PRESSURE) {
            digitalWrite(PUMP_PIN, LOW);
            Serial.println("OVER-PRESSURE!");
            return;
        }
        digitalWrite(PUMP_PIN, HIGH);
        delay(50);
        pressure = readPressure();
        Serial.print("Inflating: ");
        Serial.print(pressure, 1);
        Serial.println(" kPa");
    }
    digitalWrite(PUMP_PIN, LOW);
    Serial.println("Grip achieved!");
}

void release() {
    digitalWrite(PUMP_PIN, LOW);
    digitalWrite(VALVE_PIN, HIGH);  // Open vent
    delay(1000);
    digitalWrite(VALVE_PIN, LOW);
    Serial.println("Released");
}

void loop() {
    if (digitalRead(GRIP_BTN) == LOW) {
        delay(50);
        grip();
        while (digitalRead(GRIP_BTN) == LOW);
    }
    if (digitalRead(RELEASE_BTN) == LOW) {
        delay(50);
        release();
        while (digitalRead(RELEASE_BTN) == LOW);
    }
}

ESP32: Multi-Chamber Soft Actuator

// ESP32 controlling 3 independent soft actuator chambers
// Each chamber: pump + valve + pressure sensor
// Enables bending in multiple directions

#include <Arduino.h>

struct Chamber {
    int pumpPin, valvePin, sensePin;
    float pressure, target;
    const char* name;
};

Chamber chambers[] = {
    {25, 26, 34, 0, 0, "Thumb"},
    {27, 14, 35, 0, 0, "Index"},
    {12, 13, 32, 0, 0, "Middle"}
};
const int NUM_CHAMBERS = 3;

void setup() {
    Serial.begin(115200);
    for (int i = 0; i < NUM_CHAMBERS; i++) {
        pinMode(chambers[i].pumpPin, OUTPUT);
        pinMode(chambers[i].valvePin, OUTPUT);
        digitalWrite(chambers[i].valvePin, HIGH); // Vent all
        delay(500);
        digitalWrite(chambers[i].valvePin, LOW);
    }
    analogReadResolution(12);
    Serial.println("3-Finger Soft Gripper Ready");
    Serial.println("Commands: G=grip, R=release, 1/2/3=toggle");
}

float readPressure(int pin) {
    return (analogRead(pin) / 4095.0) * 100.0;  // kPa estimate
}

void updateChamber(Chamber &ch) {
    ch.pressure = readPressure(ch.sensePin);
    if (ch.target > 0 && ch.pressure < ch.target) {
        digitalWrite(ch.pumpPin, HIGH);
        digitalWrite(ch.valvePin, LOW);
    } else if (ch.target == 0) {
        digitalWrite(ch.pumpPin, LOW);
        digitalWrite(ch.valvePin, HIGH);  // Vent
    } else {
        digitalWrite(ch.pumpPin, LOW);  // Hold
    }
}

void loop() {
    for (int i = 0; i < NUM_CHAMBERS; i++) {
        updateChamber(chambers[i]);
    }

    if (Serial.available()) {
        char cmd = Serial.read();
        if (cmd == 'G' || cmd == 'g') {
            for (int i = 0; i < NUM_CHAMBERS; i++) chambers[i].target = 40.0;
            Serial.println("GRIPPING all fingers");
        } else if (cmd == 'R' || cmd == 'r') {
            for (int i = 0; i < NUM_CHAMBERS; i++) chambers[i].target = 0;
            Serial.println("RELEASING all fingers");
        }
    }

    static unsigned long lastPrint = 0;
    if (millis() - lastPrint > 500) {
        for (int i = 0; i < NUM_CHAMBERS; i++) {
            Serial.printf("%s: %.1f/%.1f kPa  ",
                          chambers[i].name,
                          chambers[i].pressure,
                          chambers[i].target);
        }
        Serial.println();
        lastPrint = millis();
    }
    delay(20);
}

Real-World Applications

Advantages vs. Alternatives

vs. Actuator	Soft Robotics Advantage	Soft Robotics Disadvantage
Rigid Gripper	Conforms to any shape, inherently gentle, no crush risk	Lower precision, lower force, harder to model
Servo Motor	No gears/bearings, waterproof, lightweight	Needs air supply, slower, less repeatable
Linear Actuator	Smooth continuous deformation, safe human interaction	Lower stiffness, harder to achieve precise positions
Smart Material	Much cheaper materials, easier fabrication (mold casting)	Requires pneumatic infrastructure

Limitations & Considerations

• Air Supply: Most soft actuators need pumps, valves, and tubing. Miniature systems exist but add bulk and noise.
• Slow Response: Inflation/deflation takes 0.1–3 seconds. Not suitable for high-speed pick-and-place (rigid grippers win here).
• Low Precision: Silicone deformation is difficult to model precisely. Bending angle varies with load, temperature, and material aging.
• Durability: Silicone fatigues with cycling, especially at creases and strain concentrations. Typical life: 10K–100K cycles for PneuNets.
• Limited Force: Soft fingers typically generate 0.5–5 N. For heavier payloads, McKibben muscles or fiber-reinforced designs are needed.
• Modeling Difficulty: Non-linear material behavior, large deformations, and contact mechanics make simulation and control design challenging.