Part 5: Actuators Deep Dive

graph TD
    A["⚡ Actuators"] --> E["Electric Motors"]
    A --> EM["Electromagnetic"]
    A --> FP["Fluid Power"]
    A --> AD["Advanced"]
    E --> E1["Brushed DC"]
    E --> E2["Brushless DC"]
    E --> E3["Stepper"]
    E --> E4["Servo"]
    EM --> EM1["Solenoids"]
    EM --> EM2["Relays"]
    FP --> FP1["Pneumatic"]
    FP --> FP2["Hydraulic"]
    AD --> AD1["Piezoelectric"]
    AD --> AD2["Shape Memory
Alloy"]
    AD --> AD3["Soft Robotics"]
    style A fill:#3B9797,stroke:#3B9797,color:#fff
    style E fill:#e8f4f4,stroke:#3B9797,color:#132440
    style EM fill:#f0f4f8,stroke:#16476A,color:#132440
    style FP fill:#e8f4f4,stroke:#3B9797,color:#132440
    style AD fill:#f0f4f8,stroke:#16476A,color:#132440
                            

DC Motors

Brushed DC Motors

The simplest and most ubiquitous electric motor. Brushed DC motors use mechanical commutation through carbon brushes that contact a rotating commutator, switching current direction in the armature coils to maintain rotation.

// PWM motor control with STM32 timer
#include "stm32f4xx.h"

// TIM3 CH1 on PA6 → motor driver PWM input
void motor_pwm_init(void) {
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
    RCC->APB1ENR |= RCC_APB1ENR_TIM3EN;

    // PA6 alternate function (AF2 = TIM3_CH1)
    GPIOA->MODER  |= (2U << 12);
    GPIOA->AFR[0] |= (2U << 24);

    // TIM3: 20 kHz PWM (84 MHz / (84 * 50) = 20 kHz)
    TIM3->PSC  = 84 - 1;     // 1 MHz timer clock
    TIM3->ARR  = 50 - 1;     // 20 kHz period
    TIM3->CCR1 = 0;          // Start at 0% duty
    TIM3->CCMR1 = (6U << 4) | TIM_CCMR1_OC1PE;  // PWM mode 1
    TIM3->CCER  = TIM_CCER_CC1E;
    TIM3->CR1  |= TIM_CR1_CEN;
}

// Set motor speed (0-100%)
void motor_set_speed(uint8_t percent) {
    if (percent > 100) percent = 100;
    TIM3->CCR1 = (uint32_t)percent * (TIM3->ARR + 1) / 100;
}

// Direction control via GPIO (connected to H-Bridge IN1/IN2)
void motor_set_direction(uint8_t forward) {
    if (forward) {
        GPIOB->BSRR = (1U << 0);          // PB0 = IN1 HIGH
        GPIOB->BSRR = (1U << (1 + 16));   // PB1 = IN2 LOW
    } else {
        GPIOB->BSRR = (1U << (0 + 16));   // PB0 = IN1 LOW
        GPIOB->BSRR = (1U << 1);          // PB1 = IN2 HIGH
    }
}

Brushless DC (BLDC) Motors

BLDC motors replace mechanical brushes with electronic commutation. Permanent magnets are on the rotor; stator coils are energized in sequence by an Electronic Speed Controller (ESC). Advantages include higher efficiency, longer life, less noise, and better power-to-weight ratio.

Gear Motors & Encoders

Gear motors combine a DC motor with a gearbox to trade speed for torque. Common gear ratios range from 10:1 to 300:1. Adding a rotary encoder enables closed-loop position and speed control.

Stepper Motors

Stepper motors rotate in precise, discrete steps (typically 1.8° = 200 steps/revolution). They provide open-loop position control — each pulse advances exactly one step — making them ideal for CNC machines, 3D printers, and precision positioning.

Unipolar vs Bipolar

Stepping Modes

Stepper Drivers

// A4988 stepper driver control (Step/Dir interface)
#include "stm32f4xx.h"

#define STEP_PIN  (1U << 0)   // PA0 = STEP
#define DIR_PIN   (1U << 1)   // PA1 = DIR
#define EN_PIN    (1U << 2)   // PA2 = ENABLE (active low)

void stepper_init(void) {
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
    GPIOA->MODER |= (1U << 0) | (1U << 2) | (1U << 4);  // Output

    GPIOA->BSRR = EN_PIN;     // Disable driver (active low)
}

void stepper_enable(void) {
    GPIOA->BSRR = (EN_PIN << 16);  // EN = LOW (enable)
}

void stepper_set_direction(uint8_t clockwise) {
    if (clockwise)
        GPIOA->BSRR = DIR_PIN;
    else
        GPIOA->BSRR = (DIR_PIN << 16);
}

void stepper_step(void) {
    GPIOA->BSRR = STEP_PIN;         // STEP HIGH
    for (volatile int i = 0; i < 84; i++);  // ~1us pulse
    GPIOA->BSRR = (STEP_PIN << 16); // STEP LOW
}

void stepper_move_steps(int32_t steps) {
    stepper_set_direction(steps > 0);
    uint32_t abs_steps = (steps > 0) ? steps : -steps;

    for (uint32_t i = 0; i < abs_steps; i++) {
        stepper_step();
        // Delay for desired speed (e.g., 1ms = 1000 steps/sec)
        for (volatile int d = 0; d < 84000; d++);
    }
}

Servo Motors

Hobby Servos (PWM)

Hobby servos are closed-loop actuators with a built-in motor, gearbox, position potentiometer, and control circuit. They accept a 50 Hz PWM signal where pulse width determines position:

#!/usr/bin/env python3
"""Control servo motor with Raspberry Pi PWM"""

import RPi.GPIO as GPIO
import time

SERVO_PIN = 18  # GPIO18 (hardware PWM)

GPIO.setmode(GPIO.BCM)
GPIO.setup(SERVO_PIN, GPIO.OUT)

# 50 Hz PWM for servo
pwm = GPIO.PWM(SERVO_PIN, 50)
pwm.start(0)

def set_angle(angle):
    """Set servo angle (0-180 degrees)"""
    # Map angle to duty cycle: 0° = 2.5%, 180° = 12.5%
    duty_cycle = 2.5 + (angle / 180.0) * 10.0
    pwm.ChangeDutyCycle(duty_cycle)
    time.sleep(0.5)  # Wait for servo to reach position

# Sweep servo through positions
positions = [0, 45, 90, 135, 180, 90]
for angle in positions:
    print(f"Moving to {angle}°")
    set_angle(angle)

pwm.stop()
GPIO.cleanup()

Industrial Servo Systems

Solenoids & Relays

Linear Solenoids

A solenoid is an electromagnetic actuator that converts electrical energy into linear (push/pull) motion. When current flows through the coil, the magnetic field pulls a ferromagnetic plunger into the core.

// Solenoid control with MOSFET and flyback diode
#include "stm32f4xx.h"

#define SOLENOID_PIN (1U << 5)  // PA5 → N-MOSFET gate

void solenoid_init(void) {
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
    GPIOA->MODER |= (1U << 10);  // PA5 output
    GPIOA->BSRR = (SOLENOID_PIN << 16);  // Start OFF
}

void solenoid_activate(void) {
    GPIOA->BSRR = SOLENOID_PIN;  // Gate HIGH → MOSFET ON → solenoid energized
}

void solenoid_deactivate(void) {
    GPIOA->BSRR = (SOLENOID_PIN << 16);  // Gate LOW → MOSFET OFF
    // Flyback diode (across solenoid) handles back-EMF safely
}

// PWM hold: reduce power after initial pull-in
// Solenoids need full power to pull in, but only ~30% to hold
void solenoid_activate_with_hold(void) {
    solenoid_activate();
    // Full power for 50ms pull-in
    for (volatile int i = 0; i < 4200000; i++);
    // Reduce to 30% PWM for hold (saves power and heat)
    // Switch to timer PWM output on PA5
}

Electromechanical Relays

A relay is a solenoid-actuated switch that uses a small control current to switch a much larger load current. They provide galvanic isolation between control and load circuits.

Piezoelectric Actuators

Piezoelectric materials (PZT ceramics) expand or contract when voltage is applied, providing sub-nanometer positioning precision. They require high voltage (100-1000V) but consume almost no current (capacitive load).

Pneumatic & Hydraulic Systems

Pneumatic actuators use compressed air, while hydraulic actuators use pressurized fluid. Both convert fluid pressure into linear or rotary motion.

Conclusion & Next Steps

Actuators are the muscles of embedded systems — converting electrical signals into physical motion. From the simplicity of brushed DC motors to the precision of piezoelectric stacks, each technology serves different force, speed, precision, and cost requirements.

In Part 6, we cover Actuator Control Systems — PWM generation, H-Bridge circuit design, PID control theory, and closed-loop feedback implementation.