Explicit MPC

This method is deployed on microcontrollers and programmable logic controllers (PLCs) with severe memory and processing constraints. The explicit solution eliminates the need for an embedded Quadratic Programming (QP) solver library.

• Implementation: The control law is stored as a set of polyhedral regions and associated affine gains, often in read-only memory.
• Use Cases: Automotive engine control units, consumer appliance motor control, low-power sensor nodes.
• Advantage: Extremely deterministic execution and low power consumption, as computation is simple arithmetic.

In applications where constraint violation is unacceptable, Explicit MPC provides formal guarantees. The offline computation verifies that all possible states within a defined region satisfy constraints under the optimal law.

• Critical Domains: Aerospace flight control, medical devices, nuclear reactor control.
• Verification: The multiparametric programming solution can be formally analyzed to prove properties like recursive feasibility and stability within the computed state-space partition.
• Assurance: Offers a higher degree of certification readiness compared to online MPC, where numerical solver failures are a risk.

Explicit MPC acts as a high-level safety filter or reference governor for a lower-level controller. It modifies desired setpoints or trajectories to ensure all system constraints are respected.

• Function: It monitors the system state and a desired reference command. If the raw command would lead to constraint violation, the explicit law computes the closest admissible command.
• Architecture: Often sits atop a fast, simple PID or LQR controller in a cascaded setup.
• Example: Protecting a robot arm from joint limit and torque saturation while tracking a path from a planner.

Explicit MPC is applied to robotic arms with 2-4 degrees of freedom for tasks like pick-and-place or trajectory tracking. It optimally manages actuator limits and avoids obstacles defined as state constraints.

• Typical Constraints: Joint position, velocity, and torque limits; keep-out zones for collision avoidance.
• Benefit: Provides optimal, constraint-aware control with the computational footprint of a simple gain-scheduled controller.
• Limitation: The curse of dimensionality makes it impractical for high-DOF arms, where online MPC or alternative methods are preferred.

Multiparametric programming is the core mathematical technique behind Explicit MPC. It solves an optimization problem where the objective function and constraints depend linearly on a vector of parameters—in MPC, the system state. The output is not a single optimal value, but an explicit piecewise affine function mapping the parameter (state) to the optimal solution (control input).

• Key Result: The optimal control law is partitioned into critical regions in the state space.
• For Linear Systems: With a quadratic cost and linear constraints, the resulting multiparametric Quadratic Program (mpQP) yields a continuous, piecewise affine control law.
• Offline Computation: This complex region exploration and function derivation is performed once, before deployment.

A Piecewise Affine function is a mathematical function whose domain is partitioned into polyhedral regions, with a distinct affine function (of the form u = Kx + c) defined on each region. This is the exact form of the pre-computed control law in Explicit MPC.

• Structure: The state space is divided into convex polyhedra (critical regions). For any measured state falling within a given region, the optimal control is calculated via a simple matrix multiplication and addition.
• Implementation: In practice, this is stored as a list of regions and their associated affine gains. Online execution reduces to a point location problem (finding which region contains the current state) followed by the affine evaluation.
• Continuity: For mpQP problems, the resulting PWA function is continuous across region boundaries.

A critical region is a convex polyhedral subset of the state space where a specific set of constraints is active at the optimum of the multiparametric program. In Explicit MPC, each critical region corresponds to a unique affine expression of the optimal control law.

• Definition: Mathematically, it is the set of parameters (states) for which the optimal solution has the same active set of constraints.
• Online Operation: The controller's main online task is to identify the critical region containing the current measured state, typically using a sequential search or binary search tree built from the region geometries.
• Complexity Trade-off: The number of critical regions grows combinatorially with the number of constraints and system dimensions, which is the primary storage and search challenge for Explicit MPC.

A state feedback law is a control policy where the input u is determined as a direct function of the current system state x. Explicit MPC provides an optimal constrained state feedback law, u = κ(x), where κ is the pre-computed piecewise affine function.

• Contrast with Classic MPC: Traditional (implicit) MPC solves an optimization problem online to find u. Explicit MPC evaluates the pre-computed function κ(x).
• Deterministic Timing: The evaluation of a PWA function has a bounded worst-case execution time, critical for certified hard real-time systems.
• Relation to LQR: For an unconstrained linear system with a quadratic cost, the optimal feedback law is linear (u = -Kx). Explicit MPC generalizes this to handle constraints, resulting in a nonlinear (PWA) law.

This is the fundamental trade-off characterizing Explicit MPC. Computational effort is shifted from the online execution phase to a one-time offline design phase.

• Offline Complexity: Involves solving the multiparametric programming problem. This can be computationally intensive and grows rapidly with system size (states, inputs, constraints, and horizon length). It may involve exploring a potentially large number of critical regions.
• Online Complexity: Reduced to simple operations: measuring the state, searching a data structure (e.g., a binary search tree) to identify the active critical region, and evaluating the corresponding affine function. This is typically orders of magnitude faster than online optimization.
• Design Implication: Makes Explicit MPC suitable for systems with very fast sampling rates, limited online computational power (microcontrollers), or requirements for provable worst-case execution time.

A Binary Search Tree is a prevalent data structure used to efficiently implement the online point-location problem in Explicit MPC. It organizes the critical regions into a tree to minimize the number of comparisons needed to find the active region.

• How it Works: The tree is constructed offline. Each node contains a hyperplane that splits the state space. Traversing the tree involves checking which side of the hyperplane the current state lies on, guiding the search to a leaf node containing the correct affine control law.
• Efficiency: Transforms an online search that could be linear in the number of regions (O(N)) into a logarithmic one (O(log N)), drastically speeding up online evaluation.
• Memory Trade-off: The BST itself requires storage, but this is a fixed, offline cost. It enables the deployment of Explicit MPC with thousands of regions on resource-constrained hardware.