State-Space Models and Pole Placement

A single transfer function $G(s)$ elegantly describes a single-input single-output (SISO) loop — one voltage in, one angle out. But a 6-DOF robot arm has six joint angles, six torque inputs, and every joint couples to every other through centripetal and Coriolis terms. Stacking six transfer functions doesn't capture this coupling.

State-space is the answer. It represents all dynamics in a compact matrix equation:

$\dot{x} = Ax + Bu, \qquad y = Cx$

Here $x \in \mathbb{R}^n$ is the state vector (everything you need to predict the future), $u \in \mathbb{R}^m$ is the input, $y \in \mathbb{R}^p$ is the measured output, and $A$, $B$, $C$ are constant matrices. Multiple inputs and outputs? Just make $B$ have more columns and $C$ more rows. The framework scales effortlessly to MIMO systems.

The state vector $x$ must capture all information needed to predict future behavior. For a mechanical system, position and velocity are the natural choices — because Newton's law is second order.

For a robot joint (angle $q$, velocity $\dot{q}$):

$x = \begin{bmatrix} q \\ \dot{q} \end{bmatrix}, \quad \dot{x} = \begin{bmatrix} 0 & 1 \\ 0 & -b/m \end{bmatrix} x + \begin{bmatrix} 0 \\ 1/m \end{bmatrix} u$

where $b$ is damping and $m$ is effective inertia. This is the $\dot{x} = Ax + Bu$ form with $A = \begin{bmatrix}0 & 1 \\ 0 & -b/m\end{bmatrix}$ and $B = \begin{bmatrix}0 \\ 1/m\end{bmatrix}$.

The state-space model is just Newton's second law written in matrix form. No new physics — new notation that generalises to any number of coupled equations.

Both representations describe the same linear dynamics, but they have different strengths:

For a single joint with a PID controller, transfer functions are fine. For a quadrotor (12 states, 4 inputs) or a manipulator arm, state-space is the only practical framework.

Before designing a state-feedback controller, you must answer: can the inputs $u$ actually steer $x$ anywhere you want? This is controllability.

Formally, a system is controllable if the controllability matrix

$\mathcal{C} = \begin{bmatrix} B & AB & A^2B & \cdots & A^{n-1}B \end{bmatrix}$

has full row rank ($\text{rank} = n$).

Physical intuition: $B$ captures what states are directly driven by inputs. $AB$ captures what states are driven one step later via dynamics. $A^{n-1}B$ covers states reachable after $n-1$ dynamic steps. If any state is unreachable, the rank drops below $n$ and no controller can drive the system to an arbitrary target.

In practice: an unactuated degree of freedom (a freely spinning wheel with no motor) is uncontrollable. Check with np.linalg.matrix_rank(np.hstack([B, A@B, ...])) before designing anything.

If the system is controllable, you can place the closed-loop poles anywhere by choosing a state feedback gain matrix $K$:

$u = -Kx \quad \Rightarrow \quad \dot{x} = (A - BK)x$

The closed-loop eigenvalues are the eigenvalues of $(A - BK)$. Choose desired poles $\lambda_1, \dots, \lambda_n$ (all in the left half-plane), and there exists a unique $K$ that achieves them — found by Ackermann's formula or SciPy's place_poles.

import numpy as np
from scipy.signal import place_poles

A = np.array([[0, 1], [0, -2.0]])   # joint dynamics
B = np.array([[0], [10.0]])          # input matrix

# Desired poles: fast, well-damped
desired_poles = [-5 + 2j, -5 - 2j]
result = place_poles(A, B, desired_poles)
K = result.gain_matrix               # 1x2 gain vector
print("K =", K)  # e.g., [[2.9  0.8]]

With $u = -Kx$, the actuator applies a weighted combination of position and velocity — exactly the P and D terms of a PID, now systematically chosen to achieve target dynamics.

Pole placement requires you to specify exact pole locations, which is non-trivial in high dimensions. Linear Quadratic Regulator (LQR) replaces pole specifications with a more intuitive trade-off: how much do you care about state error vs. control effort?

LQR minimises the cost:

$J = \int_0^\infty \bigl( x^\top Q x + u^\top R u \bigr)\,dt$

$Q \succeq 0$ penalises state error; $R \succ 0$ penalises control effort. A large $Q/R$ ratio → aggressive controller (high bandwidth, lots of actuator effort). A small $Q/R$ ratio → gentle controller (low effort, slower correction).

The optimal gain is $K^* = R^{-1} B^\top P$, where $P$ solves the algebraic Riccati equation. SciPy computes it in one line: from scipy.linalg import solve_continuous_are.

LQR is the workhorse of aerospace and robotics: it handles MIMO coupling automatically, guarantees stability margins ($\geq 6$ dB gain margin, $\geq 60°$ phase margin for SISO), and requires only physical intuition about weights rather than pole arithmetic.

State feedback needs all of $x$. But sensors measure only $y = Cx$. A robot joint might have a position encoder but no velocity sensor — so $\dot{q}$ must be estimated.

A Luenberger observer (state estimator) runs a model of the plant in parallel with the real plant:

$\dot{\hat{x}} = A\hat{x} + Bu + L(y - C\hat{x})$

The term $L(y - C\hat{x})$ is a correction proportional to how much the predicted output $C\hat{x}$ differs from the measured $y$. Choose $L$ so that $(A - LC)$ has fast, stable eigenvalues and $\hat{x} \to x$ quickly.

The Kalman filter is the LQR-optimal observer: it picks $L$ to minimise estimation error variance given process and measurement noise covariances. LQR + Kalman = LQG (Linear Quadratic Gaussian), the backbone of modern spacecraft and autonomous vehicle control.

Both tools are valid — choose based on what you're controlling:

In practice, a 6-DOF industrial arm uses: per-joint PID for motor current (inner loop), state-space with LQR for position/velocity (outer loop), and feedforward from a dynamics model. The layers cooperate, not compete.