Real-Time Optimization (RTO)

The most critical characteristic of RTO is its hard real-time deadline. The optimization solver must compute a solution within the system's fixed sampling period (e.g., 10ms, 100ms). Failure to meet this deadline results in a dropped control cycle, potentially destabilizing the physical system. This necessitates the use of deterministic algorithms and often requires a feasible, suboptimal solution to be returned if the optimal one cannot be found in time.

RTO operates in a closed-loop, measurement-update-optimize-actuate cycle:

• State Estimation: The current system state is estimated from sensor measurements (e.g., using a Kalman Filter).
• Problem Formulation: A new Optimal Control Problem (OCP) is instantiated using this state as the initial condition.
• Numerical Solution: The OCP is solved by an embedded optimizer.
• Actuation: Only the first control input from the optimized sequence is applied to the system before the cycle repeats. This contrasts with offline optimization, where computation time is unconstrained.

RTO explicitly handles state constraints (e.g., position limits, temperature bounds) and input constraints (e.g., actuator saturation, torque limits) within the optimization problem. This is a primary advantage over traditional PID control. Constraints can be:

• Hard Constraints: Must never be violated (e.g., physical safety limits).
• Soft Constraints: Can be violated at a penalty, implemented via slack variables to ensure the optimizer always finds a feasible solution. Proper constraint handling is essential for safe and practical operation.

To meet tight deadlines, RTO solvers heavily rely on warm-starting. The solution from the previous control step (shifted in time) is used as the initial guess for the current optimization. Since the system state changes incrementally, the new optimal solution is typically close to the old one. This dramatically reduces the number of iterations required for convergence, especially for Nonlinear MPC (NMPC) problems solved with iterative methods like Sequential Quadratic Programming (SQP).

RTO involves a fundamental engineering trade-off between solution accuracy and computational latency. Key parameters that balance this include:

• Prediction Horizon Length: A longer horizon improves performance but increases problem size.
• Discretization Granularity: Finer time steps increase accuracy but also computation.
• Solver Tolerance: Looser convergence tolerances speed up computation at the cost of a less optimal solution. The design goal is to find the "good enough" solution within the available time, not the perfect one.

Implementing RTO requires tight integration between algorithms and hardware. This involves:

• Embedded Optimizers: Using specialized solvers like qpOASES or OSQP for Quadratic Programming (QP) in Linear MPC, or acados or FORCES Pro for NMPC.
• Code Generation: Often, solvers generate tailored, low-level C code for the target processor to minimize overhead.
• Processor Selection: Utilizing hardware with deterministic performance, such as real-time CPUs or even FPGAs, to guarantee deadline compliance. Techniques like Explicit MPC pre-compute the solution offline to avoid online optimization entirely.

The Optimal Control Problem (OCP) is the foundational mathematical formulation solved at each step of MPC/RTO. It is defined by three core components:

• A dynamic model (e.g., differential equations) predicting future system states.
• A cost function quantifying performance (tracking error, energy use).
• Constraints on system states and control inputs (e.g., actuator limits, safety bounds).

Solving the OCP within the sampling period is the essence of Real-Time Optimization. The complexity of the OCP directly determines the computational challenge for the RTO solver.

A Quadratic Programming (QP) Solver is a numerical algorithm critical for Linear MPC. When the MPC cost function is quadratic and constraints are linear, the OCP reduces to a QP problem. Real-Time Optimization demands solvers with:

• Deterministic execution times to guarantee completion within the sampling period.
• High numerical reliability to handle ill-conditioned matrices.
• Warm-starting capability to use the previous solution as an initial guess, drastically reducing iteration counts.

Examples include active-set methods and interior-point methods, often implemented in embedded-optimized libraries like qpOASES or OSQP.

Sequential Quadratic Programming (SQP) is the dominant iterative algorithm for solving the Nonlinear Programming (NLP) problems arising in Nonlinear MPC (NMPC). For Real-Time Optimization, SQP methods:

• Approximate the complex NLP by a sequence of simpler Quadratic Programming (QP) subproblems.
• Require careful management of iteration count to meet real-time deadlines.
• Often employ real-time iteration schemes, where only one SQP iteration is performed per control step, leveraging parametric sensitivity to track the optimal solution.

This method balances the accuracy of nonlinear optimization with the computational constraints of RTO.

Receding Horizon Control is the operational principle that defines the closed-loop execution of MPC and creates the need for Real-Time Optimization. The process is:

1. Predict: Solve an OCP over a finite future horizon from the current state.
2. Apply: Implement only the first control input from the optimized sequence.
3. Shift: At the next sampling instant, shift the horizon forward, incorporate new sensor measurements, and repeat.

This principle means the OCP must be solved anew at every time step, making the speed and reliability of the RTO solver paramount for system stability and performance.

Explicit MPC is an alternative strategy to meet Real-Time Optimization requirements by eliminating online optimization. It pre-computes the optimal control law offline by solving a multiparametric programming problem. The result is a piecewise affine function of the system state, stored as a look-up table.

Advantages for RTO:

• Control computation reduces to a simple set-membership test and linear function evaluation.
• Extremely fast and deterministic execution, ideal for systems with very short sampling periods.

Limitation: Complexity grows exponentially with problem size, making it suitable primarily for small-scale systems.

Hardware-in-the-Loop (HIL) Testing is the critical validation step for Real-Time Optimization systems before physical deployment. It involves:

• Running the actual MPC controller software (with its RTO solver) on the target embedded hardware (e.g., an automotive ECU).
• Connecting it to a real-time simulator that runs a high-fidelity model of the physical plant (e.g., vehicle dynamics).

HIL testing verifies that the RTO solver consistently converges within the required sampling period under realistic computational loads and that the closed-loop system behaves correctly, ensuring that real-time deadlines will be met in the final application.