Compared to electric motors (Lesson 1) and geared transmissions (Lesson 2), hydraulic actuators deliver very large forces/torques at compact size. This comes from using pressurized fluid as the energy carrier. Hydraulics are common in heavy manipulators, legged robots for rough terrain, and high-impact tasks. The main costs are complexity, leakage risk, and nonlinear flow/valve dynamics.

flowchart TD
  PWR["Prime mover (electric motor)"] --> PUMP["Pump converts mech -> fluid power"]
  PUMP --> ACC["Accumulator (stores pressure)"]
  ACC --> VALVE["Servo/proportional valve"]
  VALVE --> ACT["Cylinder or hydraulic motor"]
  ACT --> LOAD["Robot joint/load"]
  ACT --> RET["Return line to tank"]
  RET --> TANK["Reservoir + filtration"]
        

Fluid power is characterized by pressure \( p \) (energy per unit volume) and flow rate \( q \). The instantaneous hydraulic power is:

\[ P_h = p\,q . \]

Pascal's law states that pressure applied to a confined incompressible fluid is transmitted undiminished in all directions. Consider a static fluid element with surface normal \( \mathbf{n} \) and area \( dA \). The traction on that surface is \( d\mathbf{F} = -p\,\mathbf{n}\,dA \).

Proof sketch (from force balance):

For a small tetrahedral fluid element in static equilibrium (no acceleration), the sum of forces on its faces must be zero. Let the three orthogonal faces have areas \( A_x, A_y, A_z \) with pressures \( p_x, p_y, p_z \), and the oblique face have area \( A \) with pressure \( p \). Force balance in the x-direction gives \( p_x A_x = p A \cos\alpha \), and similarly for y, z. Using geometry \( A_x = A \cos\alpha \), etc., yields \( p_x=p_y=p_z=p \). Hence pressure is isotropic.

For a single-rod cylinder with chamber pressure \( p_A \) acting on piston area \( A_p \) and rod-side pressure \( p_B \) on area \( A_r \), the net force is

\[ F = A_p\,p_A - A_r\,p_B - F_f , \]

where \( F_f \) models friction/seal losses. For a double-acting symmetric cylinder \( A_p = A_r = A \), so \( F = A (p_A - p_B) - F_f \).

For a hydraulic motor with displacement (volume per revolution) \( D_m \), pressure drop \( \Delta p \) generates torque:

\[ \tau_m = \frac{D_m}{2\pi}\,\Delta p - \tau_f , \]

consistent with energy: one revolution consumes volume \( D_m \) at pressure \( \Delta p \), giving work \( \Delta p D_m \) which equals \( 2\pi \tau_m \).

Hydraulic actuation is controlled by valves which modulate flow. The continuity equation for a control volume states that net inflow equals the rate of volume change:

\[ q_{in} - q_{out} = \frac{dV}{dt}. \]

Most servo valves behave like sharp-edged orifices. For an orifice of effective area \( A_v \) between upstream pressure \( p_u \) and downstream pressure \( p_d \), Bernoulli's equation plus discharge losses gives the orifice flow law:

\[ q = C_d A_v \sqrt{\frac{2}{\rho}\,(p_u - p_d)}, \]

where \( C_d \in (0,1) \) is discharge coefficient and \( \rho \) fluid density.

Derivation: Bernoulli for incompressible flow between large reservoir and jet:

\[ \frac{p_u}{\rho} + \frac{v_u^2}{2} = \frac{p_d}{\rho} + \frac{v_d^2}{2}. \]

With \( v_u \approx 0 \) (large upstream chamber), \( v_d = q/A_v \), we obtain \( v_d = \sqrt{2(p_u-p_d)/\rho} \). Empirical contraction and viscous losses scale flow by \( C_d \), yielding the stated law.

Around an operating point, we often linearize for control design. Let \( p_u - p_d = \Delta p_0 + \delta(\Delta p) \) and \( A_v = A_{v0} + \delta A_v \). First-order Taylor expansion gives:

\[ \delta q \approx \underbrace{C_d \sqrt{\frac{2\Delta p_0}{\rho}}}_{K_q}\,\delta A_v + \underbrace{\frac{C_d A_{v0}}{\sqrt{2\rho \Delta p_0}}}_{K_p}\,\delta(\Delta p). \]

The constants \( K_q \) and \( K_p \) are the valve flow and pressure gains.

Hydraulic fluid is slightly compressible, modeled by the effective bulk modulus \( \beta_e \). For chamber volume \( V \) and pressure \( p \),

\[ \beta_e = -V \frac{dp}{dV} \quad \Rightarrow \quad \frac{dp}{dt} = \frac{\beta_e}{V}\,\frac{dV}{dt}. \]

In a cylinder chamber, volume changes due to piston motion and net inflow: \( dV/dt = q - A\,\dot{x} \). Thus,

\[ \dot{p} = \frac{\beta_e}{V}\,(q - A\dot{x}). \]

Hydraulic stiffness. Suppose motion is slow so flow is negligible (\( q \approx 0 \)). A small displacement \( \delta x \) changes volume by \( \delta V = A\,\delta x \) and pressure by \( \delta p = (\beta_e/V)\,\delta V \). Force change is \( \delta F = A\,\delta p \), hence the effective stiffness:

\[ K_h = \frac{\delta F}{\delta x} = \frac{A^2 \beta_e}{V}. \]

This explains why small trapped volumes yield very stiff actuators, but also why air entrainment (reducing \( \beta_e \)) makes hydraulics “spongy”.

We model a symmetric double-acting cylinder driven by a servo valve. Let \( x \) be piston displacement, \( p \) the load pressure (difference between chambers), and \( q \) the valve-controlled flow into the chambers (positive extending). Using the compressibility relation (Section 4),

\[ \dot{p} = \frac{\beta_e}{V_t}\,(q - A\dot{x} - C_t p), \]

where \( V_t \) is the total effective chamber volume and \( C_t \) is internal leakage coefficient.

The mechanical equation for a load mass \( m \) with viscous friction \( b \) and external load \( F_L \) is

\[ m\ddot{x} = A p - b\dot{x} - F_L. \]

Combining gives a 2nd-order coupled fluid–mechanical system. For control we insert the linearized valve flow (Section 3): \( q = K_q u - K_p p \), where \( u \) is the valve spool command.

\[ \dot{p} = \frac{\beta_e}{V_t} \bigl(K_q u - (K_p + C_t) p - A\dot{x}\bigr). \]

flowchart TD
  U["Valve command u"] -->|Kq| Q["Flow q"]
  P["Load pressure p"] -->| -Kp | Q
  Q --> FLUID["Compressibility: p_dot = (beta_e/Vt)(q - A x_dot - Ct p)"]
  FLUID --> P
  P -->|A p| MECH["Mass/friction: m x_ddot = A p - b x_dot - F_L"]
  MECH --> X["Position x"]
  X -->|x_dot| FLUID
        

In state form with \( \mathbf{x}_s = [x,\; \dot{x},\; p]^T \),

\[ \dot{\mathbf{x}}_s = \begin{bmatrix} 0 & 1 & 0 \\ 0 & -\frac{b}{m} & \frac{A}{m} \\ 0 & -\frac{A\beta_e}{V_t} & -\frac{(K_p+C_t)\beta_e}{V_t} \end{bmatrix} \mathbf{x}_s + \begin{bmatrix} 0 \\ 0 \\ \frac{K_q\beta_e}{V_t} \end{bmatrix} u + \begin{bmatrix} 0 \\ -\frac{1}{m} \\ 0 \end{bmatrix} F_L . \]

This model is the hydraulic analog of a motor–gear–load model, but with pressure dynamics playing the role of “current” storage.

For insight, neglect leakage (\( C_t=0 \)) and valve pressure gain (\( K_p =0 \)). Eliminating \( p \) yields an approximate 2nd-order relation between \( u \) and \( x \). Differentiate the mechanical equation:

\[ m\dddot{x} = A\dot{p} - b\ddot{x}. \]

Substitute \( \dot{p} = (\beta_e/V_t)(K_q u - A\dot{x}) \):

\[ m\dddot{x} + b\ddot{x} + \frac{A^2\beta_e}{V_t}\dot{x} = \frac{A\beta_e K_q}{V_t} u. \]

Interpreting the dominant dynamics as a mass–spring–damper, the hydraulic stiffness from Section 4 appears directly. The (undamped) natural frequency is

\[ \omega_n \approx \sqrt{\frac{K_h}{m}} = \sqrt{\frac{A^2\beta_e}{m V_t}}. \]

Thus high bulk modulus, large piston area, and small trapped volume increase bandwidth.

Hydraulic systems lose power through: (i) pump inefficiency, (ii) valve throttling, (iii) leakage, and (iv) friction in actuators.

Mechanical output power is \( P_{out}=F\dot{x}=Ap\dot{x} \). Input hydraulic power is \( P_{in}=p_s q \), where \( p_s \) is supply pressure. Overall efficiency:

\[ \eta = \frac{P_{out}}{P_{in}} = \frac{A p \dot{x}}{p_s q}. \]

Throttling valves reduce efficiency at partial loads because flow is forced through pressure drops. This is one reason modern robots often add energy recovery or variable-displacement pumping.

We simulate the linearized servo-hydraulic cylinder model from Section 5. Useful libraries: numpy, scipy, and the control toolbox for state-space systems.

import numpy as np
from scipy.integrate import solve_ivp
import matplotlib.pyplot as plt

# Parameters (illustrative)
A = 3.0e-3          # piston area [m^2]
beta_e = 1.2e9      # effective bulk modulus [Pa]
Vt = 6.0e-5         # total chamber volume [m^3]
m = 8.0             # load mass [kg]
b = 120.0           # viscous friction [N s/m]
Kq = 2.5e-5         # valve-flow gain [m^3/(s*V)]
Kp = 1.0e-11        # valve pressure gain [m^3/(s*Pa)]
Ct = 5.0e-12        # leakage [m^3/(s*Pa)]

def dynamics(t, xs, u_func, FL_func):
    x, xd, p = xs
    u = u_func(t)
    FL = FL_func(t)

    # Valve flow (linearized)
    q = Kq*u - Kp*p

    # Pressure dynamics
    pd = (beta_e/Vt)*(q - A*xd - Ct*p)

    # Mechanical dynamics
    xdd = (A*p - b*xd - FL)/m

    return [xd, xdd, pd]

# Step input in valve command (e.g., volts)
u_func = lambda t: 2.0 if t >= 0.1 else 0.0
FL_func = lambda t: 0.0

xs0 = [0.0, 0.0, 0.0]  # initial [x, x_dot, p]
sol = solve_ivp(lambda t, xs: dynamics(t, xs, u_func, FL_func),
                [0.0, 1.0], xs0, max_step=1e-3)

t = sol.t
x = sol.y[0]
p = sol.y[2]

plt.figure()
plt.plot(t, x)
plt.xlabel("time [s]")
plt.ylabel("position x [m]")
plt.grid(True)

plt.figure()
plt.plot(t, p)
plt.xlabel("time [s]")
plt.ylabel("load pressure p [Pa]")
plt.grid(True)
plt.show()
      

You can vary \( V_t \) and \( \beta_e \) to see the stiffness/bandwidth effects predicted by \( \omega_n \approx \sqrt{A^2\beta_e/(mV_t)} \).

Below is a small-time-step Euler simulation. In robotics C++ stacks, linear algebra is often handled with Eigen, but we keep it from scratch here.

#include <iostream>
#include <vector>
#include <cmath>

int main() {
    // Parameters
    const double A = 3.0e-3;
    const double beta_e = 1.2e9;
    const double Vt = 6.0e-5;
    const double m = 8.0;
    const double b = 120.0;
    const double Kq = 2.5e-5;
    const double Kp = 1.0e-11;
    const double Ct = 5.0e-12;

    double x = 0.0, xd = 0.0, p = 0.0;
    double dt = 1e-4;
    double T = 1.0;

    auto u_func = [](double t){ return (t >= 0.1) ? 2.0 : 0.0; };
    auto FL_func = [](double t){ return 0.0; };

    for (double t=0.0; t<=T; t+=dt) {
        double u = u_func(t);
        double FL = FL_func(t);

        double q = Kq*u - Kp*p;
        double pd = (beta_e/Vt)*(q - A*xd - Ct*p);
        double xdd = (A*p - b*xd - FL)/m;

        // Euler integration
        x  += xd*dt;
        xd += xdd*dt;
        p  += pd*dt;

        if (static_cast<int>(t/dt) % 1000 == 0) {
            std::cout << t << " " << x << " " << p << std::endl;
        }
    }
    return 0;
}
      

Java robotics code often uses numerical libraries such as Apache Commons Math. Here we implement a simple fixed-step integrator from scratch for clarity.

public class HydraulicCylinderSim {

    static final double A = 3.0e-3;
    static final double beta_e = 1.2e9;
    static final double Vt = 6.0e-5;
    static final double m = 8.0;
    static final double b = 120.0;
    static final double Kq = 2.5e-5;
    static final double Kp = 1.0e-11;
    static final double Ct = 5.0e-12;

    static double uFunc(double t) {
        return (t >= 0.1) ? 2.0 : 0.0;
    }

    public static void main(String[] args) {
        double x = 0.0, xd = 0.0, p = 0.0;
        double dt = 1e-4;
        double T = 1.0;

        for (double t = 0.0; t <= T; t += dt) {
            double u = uFunc(t);
            double FL = 0.0;

            double q = Kq * u - Kp * p;
            double pd = (beta_e / Vt) * (q - A * xd - Ct * p);
            double xdd = (A * p - b * xd - FL) / m;

            x  += xd * dt;
            xd += xdd * dt;
            p  += pd * dt;

            if (((int)(t/dt)) % 1000 == 0) {
                System.out.println(t + " " + x + " " + p);
            }
        }
    }
}
      

Matlab supports state-space simulation directly, and Simulink/Simscape Fluids provides component-level hydraulic modeling.

% Parameters
A = 3.0e-3;
beta_e = 1.2e9;
Vt = 6.0e-5;
m = 8.0;
b = 120.0;
Kq = 2.5e-5;
Kp = 1.0e-11;
Ct = 5.0e-12;

% State-space matrices from Section 5
Axs = [0 1 0;
       0 -b/m A/m;
       0 -(A*beta_e)/Vt -((Kp+Ct)*beta_e)/Vt];
Bxs = [0; 0; (Kq*beta_e)/Vt];

sys = ss(Axs, Bxs, eye(3), zeros(3,1));
t = 0:1e-3:1;
u = 2*(t>=0.1);  % step at 0.1 s

[y, t_out, x_out] = lsim(sys, u, t);

figure; plot(t_out, x_out(:,1));
xlabel('time [s]'); ylabel('position x [m]'); grid on;

figure; plot(t_out, x_out(:,3));
xlabel('time [s]'); ylabel('pressure p [Pa]'); grid on;
      

Simulink suggestion: Use Simscape Fluids blocks: Variable Displacement Pump → Servo Valve → Double-Acting Cylinder, and connect to a translational mass. This lets you compare nonlinear vs. linearized behavior.

Problem 1 (Cylinder Force): A symmetric cylinder has area \( A = 4\times 10^{-3}\,\text{m}^2 \). Chamber pressures are \( p_A = 12\,\text{MPa} \) and \( p_B = 3\,\text{MPa} \). Neglect friction. Compute the net actuator force.

Solution:

\[ F = A (p_A - p_B) = 4\times 10^{-3}\,(12-3)\times 10^6 = 4\times 10^{-3}\,9\times 10^6 = 36\times 10^3 \ \text{N}. \]

The cylinder produces \( 36\,\text{kN} \).

Problem 2 (Hydraulic Stiffness): The same cylinder traps a total volume \( V_t = 8\times 10^{-5}\,\text{m}^3 \). The effective bulk modulus is \( \beta_e = 1.0\,\text{GPa} \). Find the hydraulic stiffness \( K_h \) and the natural frequency for a load of \( m=10\,\text{kg} \).

Solution:

\[ K_h = \frac{A^2\beta_e}{V_t} = \frac{(4\times 10^{-3})^2(1.0\times 10^9)}{8\times 10^{-5}} = \frac{16\times 10^{-6}\times 10^9}{8\times 10^{-5}} = \frac{16\times 10^3}{8\times 10^{-5}} = 2.0\times 10^8 \ \text{N/m}. \]

\[ \omega_n \approx \sqrt{\frac{K_h}{m}} = \sqrt{\frac{2.0\times 10^8}{10}} = \sqrt{2.0\times 10^7} \approx 4472\ \text{rad/s}. \]

This corresponds to about \( 712\,\text{Hz} \) (since \( f=\omega_n/2\pi \)).

Problem 3 (Valve Linearization): An orifice has flow \( q = C_d A_v \sqrt{2\Delta p/\rho} \). Linearize about \( A_{v0} \), \( \Delta p_0 \). Show the small-signal form \( \delta q = K_q \delta A_v + K_p \delta(\Delta p) \) and derive \( K_q, K_p \).

Solution:

Define \( f(A_v,\Delta p)=C_d A_v \sqrt{2\Delta p/\rho} \). First-order Taylor: \( \delta q = \frac{\partial f}{\partial A_v}\big|_0 \delta A_v + \frac{\partial f}{\partial \Delta p}\big|_0 \delta(\Delta p) \).

\[ \frac{\partial f}{\partial A_v}=C_d \sqrt{\frac{2\Delta p}{\rho}} \ \Rightarrow\ K_q = C_d \sqrt{\frac{2\Delta p_0}{\rho}}, \]

\[ \frac{\partial f}{\partial \Delta p} = C_d A_v \frac{1}{2}\sqrt{\frac{2}{\rho}}\,(\Delta p)^{-1/2} = \frac{C_d A_v}{\sqrt{2\rho \Delta p}} \ \Rightarrow\ K_p=\frac{C_d A_{v0}}{\sqrt{2\rho \Delta p_0}}. \]

Problem 4 (Pressure Dynamics Response): Using \( \dot{p} = (\beta_e/V_t)(q - A\dot{x}) \), consider a blocked cylinder (\( \dot{x}=0 \)) with constant inflow \( q=q_0 \). Starting from \( p(0)=0 \), find \( p(t) \).

Solution:

With \( \dot{x}=0 \): \( \dot{p} = (\beta_e/V_t)\,q_0 \), a constant. Integrate:

\[ p(t) = \frac{\beta_e q_0}{V_t}\,t. \]

The pressure ramps linearly until a relief or supply limit intervenes.

We established hydraulic actuation principles from Pascal’s law, derived static force/torque generation, modeled valve flow with the orifice equation, and built a coupled fluid–mechanical dynamic model. Key control-relevant outcomes were hydraulic stiffness \( K_h = A^2\beta_e/V \) and the bandwidth scaling \( \omega_n \approx \sqrt{A^2\beta_e/(mV_t)} \). Implementations in multiple languages illustrated simulation and sizing. These foundations prepare us for pneumatic actuation in the next lesson.