Back to Sensors & Actuators Series

Thermal Actuators: SMA, Bimetallic & Wax Motors

April 10, 2026 Wasil Zafar 17 min read

Heat becomes motion — shape memory alloys, bimetallic strips, and wax motors offer remarkable force density with minimal complexity. Master SMA wire control, self-sensing techniques, and practical embedded code.

Contents

  1. Overview & Types
  2. Working Principle
  3. Specifications Comparison
  4. Driver Circuits
  5. Control Methods
  6. Code Example — Arduino & ESP32
  7. Real-World Applications
  8. Advantages vs. Alternatives
  9. Limitations & Considerations

Overview & Types

Thermal actuators convert heat energy into mechanical motion using materials that change shape, volume, or crystal structure with temperature. From shape memory alloy wires that contract like artificial muscles to bimetallic strips that bend in thermostats, thermal actuators provide simple, powerful, and often self-sensing motion with minimal electronics.

Key Insight: Shape Memory Alloys (SMA/Nitinol) generate extraordinary force-to-weight ratios — a single 0.5 mm SMA wire can lift 1.5 kg. They are among the highest power-density actuators available, but their speed is limited by cooling time.

Types

  • Shape Memory Alloy (SMA/Nitinol): Wire or spring contracts 3–5% of length when heated above transition temperature (typically 70°C). Produces enormous stress (200 MPa). Cools to return to original shape. Most common: Flexinol wire (Dynalloy).
  • Bimetallic Strip: Two metals with different thermal expansion coefficients bonded together. Bending occurs when heated. Self-resetting, no electronics needed. Used in thermostats and circuit breakers.
  • Wax Motor (Thermostatic Element): Paraffin wax expands ~15% when melting, driving a piston. High force, slow. Used in automotive thermostats, dishwasher valves, and greenhouse vents.
  • Thermal Bimorph (MEMS): Two thin-film layers with different CTE on a silicon substrate. Used in MEMS mirrors and micro-relays.
  • Electrothermal Actuator: Joule heating of a conductive beam causes expansion and bending. Common in MEMS for micro-grippers and switch arrays.

Working Principle

Shape Memory Alloy (SMA)

  1. Martensite Phase (Cool): Crystal structure is soft and deformable. Wire is in its extended (deformed) state.
  2. Heating Above As: Passing current through the wire causes Joule heating. At the austenite start temperature (As ≈ 68°C for standard Nitinol), the crystal structure begins transforming.
  3. Austenite Phase (Hot): The material "remembers" its original shorter shape and contracts by 3–5%. This generates tremendous force.
  4. Cooling Below Mf: When current is removed, the wire cools below martensite finish temperature (Mf ≈ 52°C) and becomes soft again. A bias spring or weight stretches it back.

SMA Performance

PropertyFlexinol 100µmFlexinol 250µmFlexinol 510µm
Pull Force150 g (1.5 N)930 g (9.1 N)3.5 kg (35 N)
Current200 mA1.0 A4.0 A
Resistance50 Ω/m8 Ω/m1.8 Ω/m
Contraction Time~1 s~1 s~1 s
Cooling Time (70°C→room)0.5–2 s2–5 s5–15 s

Bimetallic Strip

Two metals (e.g., brass + invar) bonded together. When heated, brass expands more than invar, causing the strip to bend toward the invar side. Deflection is proportional to temperature difference and strip length squared.

Specifications Comparison

ParameterSMA WireBimetallic StripWax Motor
Displacement3–5% of length~1mm deflection per 10°C5–15 mm stroke
Force150 MPa stress (very high)Low (mN–N range)High (50–500 N)
Response Time0.1–1 s heating, 1–15 s coolingSeconds to minutes30 s – 5 min
Operating Temp70°C transition (standard)−40°C to +300°C40–95°C melt range
DriveCurrent (Joule heating), 5–12 VAmbient temperature changeElectric heater or hot fluid
Cycle Life10K–1M (depends on strain)Unlimited (elastic bending)100K+ cycles
Efficiency1–5% (heat to mechanical)N/A (passive)~5%

Driver Circuits

SMA Wire Driver (MOSFET)

SMA wire is essentially a resistive heater. Drive with N-channel MOSFET from GPIO. PWM controls the average current and thus the heating rate and temperature.

  • MOSFET: IRLZ44N (logic-level, handles 4+ A)
  • Flyback diode: not needed (purely resistive load)
  • Current sensing: 0.1 Ω sense resistor for feedback
  • No flyback diode needed — SMA is resistive, not inductive

PWM Temperature Control

SMA resistance changes with phase: higher in martensite (~+20%). By monitoring resistance during PWM off-time, you can infer temperature and create a closed-loop controller without a separate thermometer.

H-Bridge for Two-Way SMA

For antagonistic SMA pairs (one contracts while the other stretches), use an H-bridge to alternately heat each wire. This enables bidirectional actuation without a bias spring.

Control Methods

Bang-Bang (On/Off)

Apply current to heat, remove to cool. Simplest approach. Limited by cooling time — the primary bottleneck for SMA cycle speed.

PWM Position Control

Modulating PWM duty cycle controls the equilibrium temperature and thus the degree of contraction. Combined with position feedback (potentiometer or encoder), this enables proportional positioning.

Resistance Feedback (Self-Sensing)

SMA resistance correlates with phase state (and thus contraction). By measuring resistance during brief current-off windows, you get position feedback without external sensors — the wire is both actuator and sensor.

Forced Cooling

Active cooling (fans, heat sinks, water channels) dramatically reduces cycling time. A 250 µm wire can cycle at 2–3 Hz with forced air vs. 0.2 Hz with natural convection.

Code Example — Arduino & ESP32

Arduino: SMA Wire with PWM Control

// SMA (Flexinol) wire actuator with PWM position control
// Wiring: MOSFET gate→D9(PWM), SMA wire drain→V+(5V), source→GND
// Position feedback: potentiometer on A0 (attached to linkage)

const int SMA_PIN = 9;    // PWM to MOSFET gate
const int POS_PIN = A0;   // Position feedback
const int TARGET_PIN = A1; // Target position pot

void setup() {
    Serial.begin(9600);
    pinMode(SMA_PIN, OUTPUT);
    analogWrite(SMA_PIN, 0);
    Serial.println("SMA Wire Controller");
    Serial.println("Adjust target pot to set position");
}

void loop() {
    int target = analogRead(TARGET_PIN);  // 0-1023
    int position = analogRead(POS_PIN);   // 0-1023

    int error = target - position;

    // Simple proportional control
    int pwm = 0;
    if (error > 10) {
        // Need to contract (heat SMA)
        pwm = constrain(map(error, 10, 200, 80, 255), 0, 255);
    } else if (error < -10) {
        // Need to extend (let cool)
        pwm = 0;
    }

    analogWrite(SMA_PIN, pwm);

    Serial.print("Target: "); Serial.print(target);
    Serial.print(" | Pos: "); Serial.print(position);
    Serial.print(" | PWM: "); Serial.println(pwm);

    delay(50);
}

ESP32: SMA with Resistance Self-Sensing

// ESP32 SMA self-sensing: measure wire resistance to infer position
// Wiring: GPIO25 → MOSFET gate → SMA wire → sense resistor (1Ω) → GND
// ADC (GPIO34) measures voltage across sense resistor

#include <Arduino.h>

#define SMA_PWM_PIN   25
#define SENSE_PIN     34   // Voltage across sense resistor
#define SUPPLY_PIN    35   // Voltage at SMA+sense junction

const int PWM_CHANNEL = 0;
const int PWM_FREQ = 1000;   // 1 kHz PWM
const int PWM_RESOLUTION = 8;
const float SENSE_R = 1.0;   // 1 ohm sense resistor

enum State { HEATING, SENSING, COOLING };
State state = COOLING;
unsigned long stateStart = 0;

void setup() {
    Serial.begin(115200);
    ledcSetup(PWM_CHANNEL, PWM_FREQ, PWM_RESOLUTION);
    ledcAttachPin(SMA_PWM_PIN, PWM_CHANNEL);
    analogReadResolution(12);
    Serial.println("SMA Self-Sensing Controller");
}

float measureResistance() {
    // Brief full-on pulse to measure
    ledcWrite(PWM_CHANNEL, 255);
    delayMicroseconds(500);

    float vSense = (analogRead(SENSE_PIN) / 4095.0) * 3.3;
    float vTotal = (analogRead(SUPPLY_PIN) / 4095.0) * 3.3;

    ledcWrite(PWM_CHANNEL, 0); // Turn off

    float current = vSense / SENSE_R;
    if (current < 0.01) return -1; // No current
    float vSMA = vTotal - vSense;
    return vSMA / current;
}

void loop() {
    float resistance = measureResistance();
    // SMA resistance drops ~20% when transitioning to austenite
    // Typical: 8 Ω/m martensite → 6.5 Ω/m austenite (for 250µm)

    float contractionEst = 0;
    if (resistance > 0) {
        // Normalize: assume 8Ω=0%, 6.5Ω=100% contracted
        contractionEst = constrain((8.0 - resistance) / 1.5 * 100.0, 0, 100);
    }

    Serial.printf("R: %.2f Ω | Contraction: %.1f%%\n",
                  resistance, contractionEst);

    // Simple cycle: heat for 2s, cool for 5s
    unsigned long elapsed = millis() - stateStart;
    if (state == COOLING && elapsed > 5000) {
        state = HEATING; stateStart = millis();
        ledcWrite(PWM_CHANNEL, 180); // ~70% duty
        Serial.println(">> HEATING");
    } else if (state == HEATING && elapsed > 2000) {
        state = COOLING; stateStart = millis();
        ledcWrite(PWM_CHANNEL, 0);
        Serial.println(">> COOLING");
    }

    delay(200);
}

Real-World Applications

Robotics & Prosthetics

  • SMA-driven robotic fingers and grippers
  • Prosthetic hand actuators
  • Micro-robots and swimming robots
  • Morphing aircraft wing structures

Consumer & Industrial

  • Automotive thermostat valves (wax motor)
  • HVAC damper actuators (bimetallic)
  • Fire sprinkler triggers
  • Coffee machine brew valves

Advantages vs. Alternatives

vs. ActuatorThermal AdvantageThermal Disadvantage
DC MotorNo gears, silent, lightweight, simple (just a wire)Much slower cycle rate, 1–5% efficiency
SolenoidHigher force-to-weight, quieter, proportional controlSlower response, limited to 3–5% strain
PiezoMuch larger displacement (mm vs µm), lower voltageOrders of magnitude slower, significant hysteresis
PneumaticNo compressor, silent, extremely compactMuch lower power output and cycle rate

Limitations & Considerations

  • Slow Cycling: Cooling is the bottleneck — natural convection limits cycle rate to 0.1–0.5 Hz. Forced cooling improves to 1–3 Hz but adds complexity.
  • Low Efficiency: Only 1–5% of electrical energy becomes mechanical work. The rest is waste heat. Not suitable for continuous high-power applications.
  • Fatigue Life: SMA wires degrade with cycling. Keeping strain under 3% and limiting peak temperature extends life to 1M+ cycles. Higher strains drastically reduce lifespan.
  • Temperature Dependence: Transition temperature is fixed by alloy composition. Ambient temperature near the transition point causes unreliable operation.
  • One-Way Only: Standard SMA contracts when heated but needs external force (spring/weight) to return. Two-way SMA exists but has lower force and shorter life.
  • Non-Linear: The force-displacement-temperature relationship is highly non-linear with significant hysteresis (~20°C between heating and cooling transitions).