5.3 State feedback control

State feedback control overview

State feedback control uses knowledge of a system's internal state variables to generate control inputs that drive the system toward a desired behavior. Unlike classical output feedback (where you only use the measured output), state feedback gives you access to the full internal picture, which means you can shape the system's dynamics much more precisely.

This technique is especially valuable for MIMO (multiple-input, multiple-output) systems, where classical transfer function methods become unwieldy. The core idea: measure (or estimate) all the state variables, multiply them by a gain matrix, and feed the result back as your control input.

State space representation

A state-space model captures a system's dynamics using four matrices. The standard continuous-time linear model looks like this:

$\dot{x}(t) = Ax(t) + Bu(t)$

$y(t) = Cx(t) + Du(t)$

where $x$ is the state vector, $u$ is the input vector, and $y$ is the output vector.

State variables

State variables are the minimum set of variables that fully describe a system's condition at any point in time. If you know the current state and all future inputs, you can predict the system's entire future behavior.

• Common physical examples: position, velocity, current, temperature, pressure
• The number of state variables equals the system order and defines the dimension of the state space
• The choice of state variables isn't unique. Different valid choices lead to different (but equivalent) state-space representations related by a similarity transformation

State transition matrix

The $A$ matrix (sometimes called the system matrix or state matrix) governs how the states evolve on their own, without any external input. Its entries encode the linear relationships between state variables and their derivatives.

• $A$ is a square $n \times n$ matrix, where $n$ is the number of state variables
• The eigenvalues of $A$ are the open-loop poles of the system, which determine natural stability and dynamic behavior
• Note: the term "state transition matrix" more precisely refers to $e^{At}$ (the matrix exponential of $A$), which maps the state from one time to another. The matrix $A$ itself is the system matrix.

Input matrix

The $B$ matrix maps control inputs to changes in the state variables. It tells you which states are directly influenced by each input and how strongly.

• Dimensions: $n \times m$, where $n$ is the number of states and $m$ is the number of inputs
• If a column of $B$ is all zeros, that input has no direct effect on any state variable

Output matrix

The $C$ matrix relates the internal states to the measurable outputs. It defines which linear combinations of state variables you can actually observe through your sensors.

• Dimensions: $p \times n$, where $p$ is the number of outputs and $n$ is the number of states

Feedthrough matrix

The $D$ matrix captures any direct path from the input to the output that bypasses the state dynamics entirely.

• Dimensions: $p \times m$
• In most physical systems, $D = 0$ because inputs must propagate through the system dynamics before affecting outputs. A nonzero $D$ appears in systems where the input instantaneously influences the output.

Pole placement

Desired pole locations

Pole placement is the technique of choosing a feedback gain so that the closed-loop system has poles exactly where you want them in the complex plane. Since pole locations dictate transient behavior, this gives you direct control over how the system responds.

• Poles further left in the complex plane produce faster responses
• Complex conjugate poles with larger real-to-imaginary ratios yield higher damping (less oscillation)
• You pick pole locations based on specs like settling time, overshoot, and damping ratio

Characteristic equation

The characteristic equation of the open-loop system is:

$\det(sI - A) = 0$

The roots of this polynomial are the open-loop poles. With state feedback $u = -Kx$, the closed-loop system matrix becomes $(A - BK)$, and the new characteristic equation is:

$\det(sI - (A - BK)) = 0$

By choosing $K$, you manipulate the coefficients of this polynomial to place the roots at your desired locations.

Controllability

Before attempting pole placement, you must verify that the system is controllable. Controllability means you can steer the state from any initial condition to any final condition in finite time.

The controllability matrix is:

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

The system is controllable if and only if $\mathcal{C}$ has full row rank (rank $n$). If the system is not controllable, you cannot place all poles arbitrarily.

State feedback gain matrix

Feedback gain calculations

The state feedback control law is:

$u = -Kx$

where $K$ is the $m \times n$ gain matrix. The goal is to find $K$ such that the eigenvalues of $(A - BK)$ match your desired pole locations.

For a single-input system, the procedure is:

1. Write out the desired characteristic polynomial from your chosen pole locations: $(s - p_1)(s - p_2)\cdots(s - p_n)$

2. Expand the closed-loop characteristic polynomial $\det(sI - (A - BK))$ in terms of the unknown gains

3. Match coefficients between the two polynomials

4. Solve the resulting system of equations for the entries of $K$

Ackermann's formula

For single-input systems, Ackermann's formula provides a direct, closed-form solution:

$K = \begin{bmatrix} 0 & 0 & \cdots & 1 \end{bmatrix} \mathcal{C}^{-1} \, \phi(A)$

where $\mathcal{C}$ is the controllability matrix and $\phi(A)$ is the desired characteristic polynomial evaluated at the matrix $A$. This avoids coefficient matching entirely, but it requires $\mathcal{C}$ to be invertible (i.e., the system must be controllable). For multi-input systems or high-order systems, numerical methods are generally preferred.

Linear quadratic regulator (LQR)

Pole placement lets you put poles wherever you want, but it doesn't tell you where to put them. LQR solves this by framing the problem as an optimization: find the gain $K$ that minimizes a cost function balancing state regulation against control effort.

Cost function

The standard LQR cost function is:

$J = \int_0^{\infty} \left( x^T Q x + u^T R u \right) dt$

• $Q$ is a positive semi-definite matrix that penalizes deviations in the state variables
• $R$ is a positive definite matrix that penalizes control effort
• Increasing the weight on $Q$ relative to $R$ produces a more aggressive controller (faster response, larger control signals). Increasing $R$ relative to $Q$ produces a more conservative controller.

Riccati equation

The optimal gain requires solving the continuous-time algebraic Riccati equation (CARE):

$A^T P + PA - PBR^{-1}B^T P + Q = 0$

where $P$ is a positive definite symmetric matrix. This is a nonlinear matrix equation, but standard software (MATLAB's lqr, Python's scipy.linalg.solve_continuous_are) handles it reliably.

LQR gain matrix

Once you have $P$, the optimal gain is:

$K = R^{-1} B^T P$

The resulting closed-loop system $\dot{x} = (A - BK)x$ is guaranteed to be stable (assuming controllability) and has good robustness properties, including at least 60° of phase margin and infinite gain margin at each input channel for single-input systems.

Observer design

In practice, you rarely have direct access to all state variables. Observers (state estimators) reconstruct the full state vector from the available outputs.

Observability

Observability determines whether you can infer the full internal state from the output measurements. The observability matrix is:

$\mathcal{O} = \begin{bmatrix} C \\ CA \\ CA^2 \\ \vdots \\ CA^{n-1} \end{bmatrix}$

The system is observable if and only if $\mathcal{O}$ has full column rank (rank $n$). Without observability, no observer can reconstruct the complete state.

Luenberger observer

A Luenberger observer is a model-based estimator with the following structure:

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

where $\hat{x}$ is the estimated state and $L$ is the observer gain matrix. The term $L(y - C\hat{x})$ corrects the estimate based on the difference between the actual output $y$ and the predicted output $C\hat{x}$.

The estimation error $e = x - \hat{x}$ evolves as:

$\dot{e} = (A - LC)e$

By choosing $L$ so that $(A - LC)$ has eigenvalues with negative real parts (placed further left than the controller poles, typically 2-5 times faster), the estimate converges to the true state.

Kalman filter

The Kalman filter is the optimal observer when process noise and measurement noise are present. It minimizes the mean square estimation error under the assumption that:

• Process noise $w$ and measurement noise $v$ are zero-mean, white, and Gaussian
• Their covariance matrices $Q_n$ and $R_n$ are known

The Kalman gain is computed by solving a Riccati equation analogous to the LQR problem, but for the estimation side. The Kalman filter automatically balances trust in the model versus trust in the measurements based on the noise covariances.

Separation principle

Controller and observer design

The separation principle is what makes the observer-based controller design tractable. It states that for linear systems, you can:

1. Design the state feedback gain $K$ as if you had perfect state measurements
2. Design the observer gain $L$ independently to estimate the states
3. Combine them: use $u = -K\hat{x}$ where $\hat{x}$ comes from the observer

The two designs do not interfere with each other.

Closed-loop stability

The combined controller-observer system has a characteristic polynomial that factors into two independent parts:

$\det(sI - (A - BK)) \cdot \det(sI - (A - LC)) = 0$

This means the closed-loop poles are simply the union of the controller poles and the observer poles. If both sets of poles are in the left half-plane, the overall system is stable. This factoring property is specific to linear systems and does not generally hold for nonlinear systems.

Integral control

Steady-state error

A standard state feedback controller $u = -Kx$ can regulate the state to zero, but it won't necessarily track a nonzero reference or reject constant disturbances with zero steady-state error. The problem is that there's nothing in the control law that "remembers" accumulated error.

Augmented state space model

To fix this, you augment the state vector with an integral state:

$x_I(t) = \int_0^t (r(\tau) - y(\tau)) \, d\tau$

where $r$ is the reference and $y$ is the output. The augmented state vector becomes:

$x_a = \begin{bmatrix} x \\ x_I \end{bmatrix}$

The augmented system matrices are constructed to include the integrator dynamics, and you design a gain $K_a = \begin{bmatrix} K & K_I \end{bmatrix}$ for the augmented system. The $K_I$ portion provides the integral action that drives steady-state error to zero for constant references and disturbances.

Robust control

Parameter uncertainties

Real systems never match their models perfectly. Parameter uncertainties come from modeling approximations, manufacturing tolerances, component aging, and varying operating conditions. A controller that works perfectly for the nominal model but fails under small perturbations is not useful.

Sensitivity analysis

Sensitivity functions quantify how much the closed-loop behavior changes when parameters vary. The sensitivity transfer function $S(s)$ and complementary sensitivity function $T(s)$ satisfy:

$S(s) + T(s) = I$

Low sensitivity (small $\|S\|$) at a given frequency means good disturbance rejection there, but the constraint $S + T = I$ means you can't have low sensitivity everywhere. Sensitivity analysis identifies which parameters matter most and guides robust design.

H-infinity control

$H_\infty$ control minimizes the worst-case gain (the $H_\infty$ norm) of a specified closed-loop transfer function. The $H_\infty$ norm is the peak value of the maximum singular value across all frequencies:

$\|T_{zw}\|_\infty = \sup_\omega \bar{\sigma}(T_{zw}(j\omega))$

This approach provides hard guarantees on performance and stability under the modeled uncertainty. The design involves solving two Riccati equations (or an equivalent LMI problem) and produces a controller that is robust by construction, though often more conservative than LQR.

Digital implementation

Discretization methods

To implement state feedback on a digital computer, you need discrete-time equivalents of the continuous-time system and controller.

Common discretization methods:

• Zero-order hold (ZOH): Assumes the control input is held constant between samples. Produces exact discrete-time matrices $A_d = e^{AT}$ and $B_d = \int_0^T e^{A\tau} d\tau \, B$, where $T$ is the sampling period. This is the most common choice.
• Tustin (bilinear) approximation: Maps the $s$-plane to the $z$-plane using $s = \frac{2}{T}\frac{z-1}{z+1}$. Preserves frequency-domain properties better than ZOH for some applications.

Sampling and reconstruction

• The sampling rate must satisfy the Nyquist-Shannon theorem: sample at least twice the highest frequency of interest to avoid aliasing. In practice, sampling 10-20 times the closed-loop bandwidth is a common rule of thumb.
• A zero-order hold on the output side reconstructs the continuous-time control signal by holding each computed value constant until the next sample.

Digital controller design

Once you have the discrete-time model $x[k+1] = A_d x[k] + B_d u[k]$, you can apply the same design techniques (pole placement, LQR) using the discrete-time matrices. MATLAB's dlqr and place functions handle this directly. The key consideration is that desired pole locations must be mapped from the $s$-plane to the $z$-plane using $z = e^{sT}$, so stable poles must lie inside the unit circle rather than in the left half-plane.