Controllers that know their limits
Every real robot lives inside limits. Motors deliver a maximum torque; joints stop at their end stops; a car's steering turns only so far and its passengers tolerate only so much sideways acceleration; a walking robot's feet can push on the ground but not pull, and only within a cone of friction before they slip; a drone's propellers spin between a minimum and a maximum speed. The controllers of the previous lessons ignore all of this. PID, LQR and computed torque compute a command as if any value were available, and then the actuator clips it. We saw in the PID lesson what clipping does to an integrator; it does similar damage to any controller that was designed assuming the clipped value would be delivered.
Model predictive control (MPC) builds the limits in. At every control step it uses a model to predict how the robot will move over the next second or two for any sequence of future inputs, chooses the sequence that is best according to a cost while respecting every limit, applies only the first input of that sequence, and then, at the next step, measures again and repeats. It began in oil refineries in the 1970s, where the plants are slow and the constraints valuable, and has become, with fast solvers, one of the main tools of robot control: in the 2020s it plans the footstep forces of legged robots, steers autonomous vehicles and flies racing drones.
Look ahead, commit to one move, look again
Analogy, not a formal construction
A good driver approaching a bend does not steer by the car's present position alone. They look ahead, imagine a path through the bend that the car can actually follow at this speed, start braking and turning at the right moment, and keep revising the plan as the road unfolds. They never execute a plan to the end: every glance replaces it with a new one.
MPC does the same thing with a model and an optimiser.
Three features distinguish this from the controllers so far. It is predictive: the cost is charged on the future, so the controller acts early when it sees trouble coming. It is constrained: limits are part of the problem, not an afterthought. And it is still feedback: because it plans again from each new measurement, a disturbance that pushes the robot off its plan is corrected at the next step.
Definitions
Definition— finite-horizon optimal control problem
Given the measured state , a model , weights , , a terminal weight and constraint sets, linear MPC solves
where is the horizon. With and described by linear inequalities, this is a quadratic program (QP): a convex quadratic cost under linear constraints.
Definition— receding-horizon control
Receding-horizon control solves the problem above at every step from the newly measured state, applies the first input , and discards the rest. The resulting control law is a feedback law, in general nonlinear (piecewise affine for linear MPC with linear constraints).
Definition— warm start
A warm start initialises the solver at step with the previous solution shifted by one step, which is usually close to the new optimum and saves most of the iterations.
Linear MPC as a least-squares problem
The states are determined by and the inputs, so we can eliminate them. Stacking the predictions,
or . With and , the cost (dropping the constant ) is
with and . This is the condensed form: only the inputs remain as variables.
Without constraints, minimising is a linear least-squares problem: writing , it is , and its solution is linear in . So unconstrained MPC is a linear state feedback, . The block below computes for a 2 kg cart pushed by a force, sampled at 20 Hz, for several horizons, first with terminal weight and then with the LQR's Riccati matrix from the LQR lesson.
import numpy as np
# A cart of mass 2 kg pushed by a force: state x = [position, velocity], input u = force.
m, T = 2.0, 0.05 # MPC runs at 20 Hz
A = np.array([[1.0, T], [0.0, 1.0]])
B = np.array([[T * T / (2 * m)], [T / m]])
Q, R = np.diag([10.0, 1.0]), np.array([[0.01]])
def prediction_matrices(A, B, N):
"""Stack the predictions: [x_1; ...; x_N] = Phi x_0 + Gamma [u_0; ...; u_{N-1}]."""
n, k = B.shape
Phi = np.vstack([np.linalg.matrix_power(A, i + 1) for i in range(N)])
Gamma = np.zeros((N * n, N * k))
for i in range(N):
for j in range(i + 1):
Gamma[i * n:(i + 1) * n, j * k:(j + 1) * k] = np.linalg.matrix_power(A, i - j) @ B
return Phi, Gamma
def mpc_unconstrained(x0, N, P):
"""Minimise sum_{k<N} x'Qx + u'Ru + x_N' P x_N as one least-squares problem."""
Phi, Gamma = prediction_matrices(A, B, N)
Qbar = np.kron(np.eye(N), Q)
Qbar[-2:, -2:] = P # terminal weight on x_N
Lq = np.linalg.cholesky(Qbar).T # Qbar = Lq' Lq
Lr = np.sqrt(R[0, 0]) * np.eye(N)
lhs = np.vstack([Lq @ Gamma, Lr]) # || Lq (Phi x0 + Gamma U) ||^2 + || Lr U ||^2
rhs = np.concatenate([-Lq @ Phi @ x0, np.zeros(N)])
U, *_ = np.linalg.lstsq(lhs, rhs, rcond=None)
return U
def dare(A, B, Q, R, iters=5000):
P = Q.copy()
for _ in range(iters):
K = np.linalg.solve(R + B.T @ P @ B, B.T @ P @ A)
P = Q + A.T @ P @ (A - B @ K)
return P, K
P_lqr, K_lqr = dare(A, B, Q, R)
print("LQR gain K =", np.round(K_lqr.ravel(), 3))
# The unconstrained MPC law is linear: its first move is u_0 = -K_N x_0. Recover K_N column by column.
for N in [3, 10, 30]:
for name, P in [("terminal Q", Q), ("terminal P", P_lqr)]:
K_N = -np.column_stack([mpc_unconstrained(e, N, P)[0:1] for e in np.eye(2)])
print(f"N = {N:2d}, {name}: K_N = {np.round(K_N.ravel(), 3)}")With terminal weight , a short horizon gives a timid controller ( is about a sixth of the LQR gain on position), and creeps towards the LQR as grows. With terminal weight , the MPC gain is the LQR gain exactly, for every horizon, even .
Adding limits: a projected-gradient solver
Now limit the cart's force to N. The QP becomes
with . There is no closed form any more, but for limits on the inputs alone there is a beautifully simple method: take a gradient step, and if it leaves the box of allowed inputs, project back onto the box, which for a box just means clipping each component.
Theorem— Projected gradient for a box-constrained QP
Let be symmetric positive definite with largest eigenvalue , and let be the projection onto a box . The iteration converges to the unique minimiser of over , and the cost error after steps is at most .
Proof
A sketch. The gradient is Lipschitz with constant , so the quadratic lies below its tangent plus ; a step of length minimises that upper bound, and projection onto a convex set is non-expansive (it never increases distances to points of the set). Combining the two gives a decrease of the cost at every step and the bound, the standard result for projected gradient methods on smooth convex problems. A fixed point satisfies the optimality conditions: each component is either interior with zero gradient, or held at a bound by a gradient pointing outward.
∎
The rate depends on the condition number of : badly conditioned problems converge slowly. Adding Nesterov's momentum (the FISTA variant used below) improves the bound to , and warm starting does the rest. The block compares MPC with "clipped LQR", the LQR gain with its output clipped to the limit, moving the cart 1 m with stronger weights on position.
import numpy as np
m, T = 2.0, 0.05
A = np.array([[1.0, T], [0.0, 1.0]])
B = np.array([[T * T / (2 * m)], [T / m]])
Q, R = np.diag([100.0, 1.0]), np.array([[0.01]])
U_MAX, N = 4.0, 40 # the motor gives at most 4 N; look 2 s ahead
def prediction_matrices(A, B, N):
n, k = B.shape
Phi = np.vstack([np.linalg.matrix_power(A, i + 1) for i in range(N)])
Gamma = np.zeros((N * n, N * k))
for i in range(N):
for j in range(i + 1):
Gamma[i * n:(i + 1) * n, j * k:(j + 1) * k] = np.linalg.matrix_power(A, i - j) @ B
return Phi, Gamma
P = Q.copy()
for _ in range(5000): # the LQR's P, used as terminal cost
K = np.linalg.solve(R + B.T @ P @ B, B.T @ P @ A)
P = Q + A.T @ P @ (A - B @ K)
Phi, Gamma = prediction_matrices(A, B, N)
Qbar = np.kron(np.eye(N), Q); Qbar[-2:, -2:] = P
H = 2 * (Gamma.T @ Qbar @ Gamma + R[0, 0] * np.eye(N)) # cost = 1/2 U'HU + f'U + const
F = 2 * Gamma.T @ Qbar @ Phi # f = F x0
L = np.linalg.eigvalsh(H).max() # step size 1/L is always safe
def solve_qp(x0, U, tol=1e-4, max_iter=5000):
"""Accelerated projected gradient (FISTA) for min 1/2 U'HU + f'U with |U| <= U_MAX."""
f = F @ x0
Y, t = U.copy(), 1.0
for it in range(1, max_iter + 1):
U_new = np.clip(Y - (H @ Y + f) / L, -U_MAX, U_MAX) # gradient step, then project
t_new = 0.5 * (1 + np.sqrt(1 + 4 * t * t))
Y = U_new + (t - 1) / t_new * (U_new - U) # momentum
if np.abs(U_new - U).max() < tol:
return U_new, it
U, t = U_new, t_new
return U, max_iter
def simulate(policy, seconds=4.0):
x, xs, us, iters = np.array([-1.0, 0.0]), [], [], [] # start 1 m short of the target
U = np.zeros(N)
for _ in range(int(seconds / T)):
u, U, it = policy(x, U)
x = A @ x + B.ravel() * u
xs.append(x); us.append(u); iters.append(it)
return np.array(xs), np.array(us), iters
def clipped_lqr(x, U):
return float(np.clip(-(K @ x)[0], -U_MAX, U_MAX)), U, 0
def mpc(x, U):
U, it = solve_qp(x, np.append(U[1:], U[-1])) # warm start: shift last plan
return U[0], U, it
print(f"{'controller':14} {'overshoot':>9} {'within 1 cm after':>18} {'peak |u|':>9}")
for name, policy in [("clipped LQR", clipped_lqr), ("MPC", mpc)]:
xs, us, iters = simulate(policy)
late = np.nonzero(np.abs(xs[:, 0]) > 0.01)[0][-1] + 1
print(f"{name:14} {max(xs[:, 0].max(), 0) * 100:7.1f} cm {late * T:16.2f} s {np.abs(us).max():7.1f} N")
ev = np.linalg.eigvalsh(H)
print(f"\nQP: {N} variables, Hessian condition number {ev.max() / ev.min():.0f}")
print(f"iterations: {iters[0]} for the first (cold) solve, then {np.mean(iters[1:]):.0f} on average"
f" (max {max(iters[1:])}) with warm starts")Both controllers push with the full 4 N, but the clipped LQR overshoots by 30 cm. Its gain was designed assuming it could always brake as hard as needed; by the time it starts braking at 4 N, the cart is going too fast. MPC sees the 4 N limit in its predictions and starts braking early enough, overshooting by only 4 cm and settling half a second sooner.
Box constraints on the inputs are the easy case. Limits on states (the cart must not pass the end of its rail, a joint must stay within its range) become general linear inequalities on the condensed variables, and projection onto them is no longer a simple clip. Practical solvers handle them with active-set, interior-point or splitting methods (next section). Often they are made soft: the constraint may be violated, but at a high price in the cost, so that the QP always has a solution even after a disturbance has pushed the state somewhere no feasible plan exists.
Example: a car-like robot changing lanes
MPC's second strength is preview: if the controller knows the future reference, its cost can charge for future errors, and it will act before they happen. A car-like robot (wheelbase 0.5 m) drives along a warehouse corridor at 2 m/s and must move 1 m sideways into the next lane, which begins at m. Its steering is limited to rad. Both controllers use the same model, linearised about straight driving: the lateral offset and heading obey and for steering angle (the kinematic bicycle of the wheeled-robots lesson, linearised). The simulation itself runs the full nonlinear bicycle model at 10 Hz. The clipped LQR tracks the lane centre at its current position; MPC tracks the lane centre at each point it will reach over the next 2 s.
import numpy as np
# A car-like robot (wheelbase 0.5 m) driving at 2 m/s along a corridor must shift 1 m sideways
# into the next lane, which starts at x = 6 m. Steering is limited to |delta| <= 0.3 rad.
V, WB, T, D_MAX, N = 2.0, 0.5, 0.1, 0.3, 20 # speed, wheelbase, step (10 Hz), limit, 2 s ahead
def bicycle(s, delta):
"""Nonlinear kinematic bicycle, s = [x, y, heading], integrated over one step in 10 parts."""
x, y, h = s
for _ in range(10):
x += T / 10 * V * np.cos(h)
y += T / 10 * V * np.sin(h)
h += T / 10 * V * np.tan(delta) / WB
return np.array([x, y, h])
# Linearised about driving straight: z = [y, heading], z+ = A z + B delta
A = np.array([[1.0, V * T], [0.0, 1.0]])
B = np.array([[V * V * T * T / (2 * WB)], [V * T / WB]])
Q, R = np.diag([10.0, 1.0]), np.array([[1.0]])
P = Q.copy()
for _ in range(5000):
K = np.linalg.solve(R + B.T @ P @ B, B.T @ P @ A)
P = Q + A.T @ P @ (A - B @ K)
Phi = np.vstack([np.linalg.matrix_power(A, i + 1) for i in range(N)])
Gamma = np.zeros((2 * N, N))
for i in range(N):
for j in range(i + 1):
Gamma[2 * i:2 * i + 2, j:j + 1] = np.linalg.matrix_power(A, i - j) @ B
Qbar = np.kron(np.eye(N), Q); Qbar[-2:, -2:] = P
H = 2 * (Gamma.T @ Qbar @ Gamma + R[0, 0] * np.eye(N))
L = np.linalg.eigvalsh(H).max()
def lane(x):
return 1.0 if x >= 6.0 else 0.0
def mpc(s, U):
"""Track the lane centre the car will reach at each future step (it knows the map)."""
ref = np.concatenate([[lane(s[0] + V * T * (k + 1)), 0.0] for k in range(N)])
f = 2 * Gamma.T @ Qbar @ (Phi @ s[1:] - ref)
U = np.append(U[1:], U[-1]) # warm start
Y, t = U.copy(), 1.0
for _ in range(2000): # accelerated projected gradient
U_new = np.clip(Y - (H @ Y + f) / L, -D_MAX, D_MAX)
t_new = 0.5 * (1 + np.sqrt(1 + 4 * t * t))
Y = U_new + (t - 1) / t_new * (U_new - U)
if np.abs(U_new - U).max() < 1e-5:
break
U, t = U_new, t_new
return U_new[0], U_new
def lqr(s, U):
z = s[1:] - np.array([lane(s[0]), 0.0]) # error from the current lane centre
return float(np.clip(-(K @ z)[0], -D_MAX, D_MAX)), U
print(f"{'controller':12} {'starts turning at x':>20} {'overshoot':>10} {'in the lane (5 cm) at x':>24} {'peak steer':>11}")
plots = {}
for name, ctrl in [("clipped LQR", lqr), ("MPC", mpc)]:
s, U, path = np.array([0.0, 0.0, 0.0]), np.zeros(N), []
while s[0] < 14.0:
delta, U = ctrl(s, U)
path.append((s[0], s[1], delta))
s = bicycle(s, delta)
path = np.array(path)
start = path[np.nonzero(np.abs(path[:, 2]) > 0.01)[0][0], 0]
settled = path[np.nonzero(np.abs(path[:, 1] - 1.0) > 0.05)[0][-1] + 1, 0]
print(f"{name:12} {start:17.1f} m {max(path[:, 1].max() - 1.0, 0) * 100:8.1f} cm {settled:21.1f} m"
f" {np.abs(path[:, 2]).max():8.2f} rad")
plots[name] = path[::2]
print("\n y (m) lane centre '-', path '*', x from 0 to 14 m")
for name, cols in plots.items():
print(f" {name}")
for level in [1.0, 0.8, 0.6, 0.4, 0.2, 0.0]:
row = "".join("*" if abs(y - level) < 0.1 else ("-" if abs(lane(x) - level) < 0.1 else " ")
for x, y, _ in cols)
print(f" {level:4.1f} {row}")MPC starts steering at 4.2 m, almost two metres before the new lane begins, and is centred in it by 6.9 m. The clipped LQR cannot see the step coming: it starts turning only when it is already 1 m off its new lane centre, saturates the steering, overshoots, and is in the lane only by 8.1 m.
Stability, feasibility and robustness
An optimiser that re-plans every step is not automatically stable. With a short horizon and no terminal cost, MPC can be myopic: each plan looks fine over its window, but the sequence of first moves drives the system somewhere bad, or into a state from which no plan satisfies the constraints. The theory developed in the 1990s and summarised by Mayne, Rawlings, Rao and Scokaert in 2000 gives a recipe:
- a terminal cost that bounds the cost-to-go beyond the horizon (the LQR's is the natural choice), and
- a terminal set , a region around the target in which the LQR alone would satisfy all constraints forever.
With both, the optimal cost decreases from one step to the next, so it acts as a Lyapunov function (closed-loop stability), and a plan that was feasible at one step, shifted and extended by the LQR, remains feasible at the next (recursive feasibility). In practice many robot MPCs use only the terminal cost, a horizon long enough that it rarely matters, and soft state constraints. Disturbances and model errors break the guarantees, and robust variants handle them: tube MPC keeps the real state within a tube around the nominal plan by an extra feedback law, and stochastic MPC uses chance constraints.
Computational cost and real-time solvers
The price of MPC is solving an optimisation problem every control period. Its size grows with the horizon , the number of states and inputs :
- Condensed QPs have variables but a dense Hessian; building and factorising it costs about , fine for small problems like ours.
- Sparse formulations keep the states as variables too ( of them) with the dynamics as equality constraints. The matrices are block-banded, and structure-exploiting solvers (Riccati-based interior-point methods such as those in HPIPM) cost only , linear in the horizon.
Solver families each have their niche. Active-set solvers (qpOASES) are fast when the set of active constraints changes little between steps. Interior-point solvers (HPIPM) have predictable iteration counts. Operator-splitting methods such as OSQP use cheap iterations, warm-start well and generate embedded C code. For nonlinear models, acados implements the real-time iteration scheme of Moritz Diehl and colleagues: rather than solving each nonlinear problem to convergence, perform one quadratic approximation per control step, warm-started from the last, which tracks the optimum closely when the sampling is fast. CasADi and Drake are widely used to formulate such problems. Commercial embedded solvers exist too, such as Embotech's FORCESPRO from Switzerland. At the other extreme, explicit MPC (Bemporad, Morari, Dua and Pistikopoulos, 2002) solves the QP offline for every possible state: the solution is piecewise affine over polyhedral regions, so the online controller is a lookup, practical for a handful of states.
Our cart QP set up for a real solver looks like this. The sketch uses the OSQP Python interface and is not run here (it needs packages this page does not have); check the documentation of the version you install.
# Not run here: the cart's QP passed to OSQP (pip install osqp scipy).
import numpy as np
import osqp
from scipy import sparse
solver = osqp.OSQP()
solver.setup(P=sparse.csc_matrix(H), q=F @ x0, # cost 1/2 U'HU + q'U
A=sparse.identity(N, format="csc"), # constraint rows: U itself
l=-U_MAX * np.ones(N), u=U_MAX * np.ones(N), # -U_MAX <= U <= U_MAX
verbose=False) # warm starts by default
while robot_is_running():
x = measure_state()
solver.update(q=F @ x) # only the linear term changes
u0 = solver.solve().x[0] # apply the first input only
apply_force(u0)Where MPC runs today
- Process industry. MPC was born in refineries and chemical plants in the 1970s (Jacques Richalet's IDCOM in France, Charles Cutler and Brian Ramaker's dynamic matrix control at Shell in the United States), where it still runs thousands of multivariable units, with control periods of seconds to minutes.
- Legged robots. In 2018 the MIT Cheetah 3 team showed that a small convex QP over a single-rigid-body model, choosing ground-reaction forces within friction cones, could control dynamic gaits in real time. Variants of this "convex MPC" and nonlinear whole-body MPC (for example ETH Zürich's OCS2 on ANYmal and mobile manipulators) are widely used in research. As of 2026 many commercial quadrupeds and humanoids rely mainly on reinforcement-learned policies for locomotion (see the RL lesson), while MPC remains common in research systems, for planning, and as a teacher whose behaviour learned policies imitate.
- Autonomous vehicles. Lateral and longitudinal control with MPC is standard in research platforms and appears in open-source stacks such as Autoware; the constraints are steering and acceleration limits, comfort bounds and road boundaries. Sampling-based variants such as MPPI (model predictive path integral control), which evaluate thousands of random input sequences on a GPU, drive off-road and racing vehicles; the autonomous-vehicles lesson returns to this.
- Drones. Nonlinear MPC on full quadrotor models flies agile and racing trajectories, respecting motor thrust limits, in research groups such as the University of Zurich's Robotics and Perception Group; aerial robots covers the vehicle side.
- Manipulators. MPC is used for constrained motion near obstacles and joint limits, and increasingly with learned dynamics models for contact-rich tasks; the Planning level's trajectory optimisation lesson develops the nonlinear optimisation behind it.
Common misconceptions
Misconception
"MPC is LQR with the output clipped." Clipping changes the command after it is chosen, without telling the controller. MPC chooses the command knowing the limit will hold in every future step, which is why it brakes in time. Without active constraints and with the right terminal cost they coincide; with active constraints they can behave very differently.
Misconception
"A longer horizon is always better." A longer horizon sees further and makes the terminal cost matter less, but it costs computation, and predictions far ahead are less accurate because model errors compound. With a good terminal cost, a moderate horizon is often as good as a long one.
Misconception
"MPC guarantees the robot never violates its constraints." It guarantees the predictions satisfy them. A wrong model, an unmeasured disturbance or a solver stopped early can let the real robot violate them. Margins, soft constraints with tight penalties, robust MPC and independent safety layers (hardware limits, safety-rated monitoring) cover that gap.
Misconception
"MPC is too slow for fast robots." Small QPs solve in microseconds to a millisecond with structure-exploiting, warm-started solvers, fast enough for 1 kHz loops in some applications. The usual design runs MPC at tens to hundreds of hertz and lets a faster inner loop (the cascades of the PID lesson, or an impedance controller) track its plan.
Exercises
1. Model predictive control
Warm-upHumanAn MPC controller computes a plan of 30 future inputs at every step but applies only the first one, then throws the rest away and plans again. Why not apply the whole plan?
2. Model predictive control
CoreHumanA linear MPC uses quadratic costs , , a horizon of steps, and as its terminal cost the matrix from the discrete Riccati equation of the LQR with the same and . When no constraint is active, what control law results?
3. Model predictive control
CoreHumanA convex MPC for a trotting quadruped treats the body as a single rigid body and chooses the three-dimensional ground-reaction force at each of the four feet, at each of 10 steps of the horizon (a foot in the air gets its force constrained to zero). How many decision variables does the QP have?
4. Model predictive control
CoreHumanIn the lesson's cart example, both clipped LQR and MPC push with the full 4 N at first, but the LQR overshoots the target by about 30 cm and MPC by about 4 cm. What is the essential reason?
5. Model predictive control
CoreComputationalWrite prediction_matrices(A, B, N) for the condensed MPC formulation: return and such that the stacked predicted states for .
Block row (predicting ) of is , and block of is for and zero otherwise. The tests compare your matrices with step-by-step simulation, for a single-input and a two-input system.
6. Model predictive control
StretchComputationalWrite box_qp(H, f, lo, hi): minimise subject to elementwise, for symmetric positive definite , by projected gradient descent: repeat with the largest eigenvalue of , until stops changing.
The tests check the unconstrained case and the optimality (KKT) conditions on constrained problems: at a solution, the gradient is zero for variables strictly inside their bounds, non-negative for variables at their lower bound, and non-positive for those at their upper bound.
7. Model predictive control
Warm-upHumanMPC optimises over a window of future steps, applies the first input, then slides the window forward by one step and repeats. What is this strategy called? (Two words.)
Further reading and resources
- Model Predictive Control: Theory, Computation, and Design · James B. Rawlings, David Q. Mayne and Moritz M. Diehl · 2017The standard graduate textbook, with a free PDF from the authors' site.
- Constrained model predictive control: Stability and optimality · David Q. Mayne, James B. Rawlings, Christopher V. Rao and Pierre O. M. Scokaert · 2000The survey that settled how terminal costs and terminal sets guarantee stability and feasibility. Automatica 36(6).
- A survey of industrial model predictive control technology · S. Joe Qin and Thomas A. Badgwell · 2003How MPC spread through refineries and chemical plants from the 1970s onwards. Control Engineering Practice 11(7).
- The explicit linear quadratic regulator for constrained systems · Alberto Bemporad, Manfred Morari, Vivek Dua and Efstratios N. Pistikopoulos · 2002Solving the MPC problem offline for every state, so that the online controller is a table lookup. Automatica 38(1).
- OSQP: An operator splitting solver for quadratic programs · Bartolomeo Stellato, Goran Banjac, Paul Goulart, Alberto Bemporad and Stephen Boyd · 2020An open-source QP solver widely used for embedded MPC, with code generation and warm starting.
- acadosOpen-source software for fast nonlinear MPC, with real-time iteration schemes and generated C code.
- CasADiOpen-source symbolic framework for nonlinear optimisation and optimal control, used to formulate many MPC problems.
- Dynamic locomotion in the MIT Cheetah 3 through convex model-predictive control · Jared Di Carlo, Patrick M. Wensing, Benjamin Katz, Gerardo Bledt and Sangbae Kim · 2018Ground-reaction forces chosen by a small QP over a simplified rigid-body model, fast enough for dynamic gaits. IEEE/RSJ IROS 2018.
- OCS2: optimal control for switched systemsAn open-source nonlinear MPC toolbox from ETH Zürich's Robotic Systems Lab, used on legged and mobile manipulators.
- DrakeRobotics toolbox whose MathematicalProgram interface formulates MPC problems and passes them to several solvers.