💻 computer science

NMPCM: Nonlinear Model Predictive Control on Resource-Constrained Microcontrollers

This paper presents NMPCM, an efficient method for deploying Nonlinear Model Predictive Control on resource-constrained microcontrollers for quadrotor UAVs, achieving high-frequency real-time execution while maintaining control accuracy through validated simulations and experiments.

Original authors: Van Chung Nguyen, Pratik Walunj, Chuong Le, An Duy Nguyen, Hung Manh La

Published 2026-02-27

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Van Chung Nguyen, Pratik Walunj, Chuong Le, An Duy Nguyen, Hung Manh La

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a tiny, super-fast drone to fly through a complex obstacle course. To do this perfectly, the drone needs a "brain" that constantly calculates the best path, adjusts for wind, and avoids crashing, all while making thousands of decisions every second.

This paper is about building that brain, but with a major twist: the brain has to fit inside a tiny, cheap, low-power chip, not a powerful laptop.

Here is the breakdown of the paper using simple analogies:

1. The Problem: The "Super-Brain" vs. The "Pocket Watch"

The Super-Brain (NMPC): Nonlinear Model Predictive Control (NMPC) is like a genius chess player. Before making a move, it looks 10 steps ahead, simulates every possible outcome, and picks the absolute best move. It's incredibly smart and keeps the drone stable even in crazy conditions.
The Pocket Watch (Microcontroller): Most small drones use tiny, cheap chips (microcontrollers) to fly. These are like a pocket watch: they are great at telling time (keeping basic balance) but they are too slow and have too little memory to do complex chess calculations.
The Conflict: Usually, to run this "Super-Brain," you need a heavy, expensive computer (like a laptop or a Jetson) strapped to the drone. This makes the drone heavy and expensive. The authors wanted to put the "Super-Brain" directly onto the "Pocket Watch."

2. The Solution: "Pre-Cooking" the Recipe

The authors figured out a way to shrink the "Super-Brain" so it fits on the tiny chip. They did this using a tool called ACADO.

The Analogy: Imagine you are a chef. Normally, to make a complex dish, you have to measure ingredients, chop vegetables, and stir the pot while the customer is waiting (this is what the heavy computers do).
The Innovation: The authors used ACADO to write a special "recipe card" before the drone even flies. They did all the heavy math ahead of time and turned the complex instructions into a simple, pre-written script.
The Result: When the drone is flying, the tiny chip doesn't have to "think" hard; it just has to "read" the pre-written script and follow the steps. This is so fast that the drone can make these decisions 1,000 times every second (1 kHz).

3. The "Warm Start" Trick (The Co-Pilot)

Even with the pre-written recipe, the tiny chip might still get confused if it starts from zero.

The Analogy: Imagine trying to solve a math problem. If you start from scratch, it takes a long time. But if someone gives you a rough guess to start with, you can finish the answer much faster.
The Trick: The authors added a simple, old-school controller (a "Cascaded PID") that acts like a co-pilot. This co-pilot gives the "Super-Brain" a rough guess of what to do first. The Super-Brain then just tweaks that guess to make it perfect. This "warm start" makes the tiny chip fast enough to handle the job.

4. The Results: Flying High on a Shoestring Budget

The team tested this on a Teensy 4.1, a tiny microcontroller that costs very little and has very little memory (about the size of a postage stamp).

The Simulation: In a computer simulation, their method was 30 times faster than the standard way of doing it. While other methods could only make 30 decisions a second, their method made 1,000.
The Real World: They built a real drone and flew it. The tiny chip successfully kept the drone stable, followed complex paths, and didn't crash.
The Comparison: They compared their method to a "Cascaded PID" (the standard, simple autopilot). The new method was much smoother, made fewer mistakes, and handled the drone's movements with much more precision, almost like a professional pilot vs. a beginner.

Why Does This Matter?

Think about the future of robots.

Today: If you want a smart robot that can fly through a forest or search a collapsed building, you have to strap a heavy, expensive computer to it. This drains the battery and makes the robot slow.
Tomorrow (thanks to this paper): You can have a swarm of tiny, cheap, lightweight drones that are all "smart" enough to fly themselves. They don't need a heavy computer; their "brain" is built right into their tiny, cheap chip.

In a nutshell: The authors took a complex, heavy mathematical brain, shrunk it down, and put it inside a tiny, cheap chip, allowing small drones to fly smarter, faster, and more independently than ever before.

1. Problem Statement

Nonlinear Model Predictive Control (NMPC) is a superior control strategy for highly dynamic systems like quadrotor UAVs because it explicitly accounts for system dynamics and optimizes control inputs at every time step. However, its high computational complexity has historically made it impractical for resource-constrained microcontrollers (MCUs).

The Challenge: Most miniature robots rely on low-power MCUs (e.g., 8-bit or 32-bit ARM Cortex-M) with limited RAM, Flash memory, and processing speed. Consequently, they often depend on off-board computers (like Jetson Nano) for complex optimization tasks.
The Gap: While Linear MPC (LMPC) has been successfully deployed on MCUs using solvers like ADMM, full NMPC remains a significant challenge due to the need for solving non-convex optimization problems in real-time.

2. Methodology

The authors propose NMPCM, a framework for generating and deploying efficient NMPC code directly onto resource-constrained microcontrollers. The methodology consists of three core components:

A. System Modeling

The authors utilize the full kinematic model of a quadrotor UAV, which includes 12 states (position, velocity, Euler angles, and angular velocities) and 4 control inputs (thrust and torques). The system is modeled as a nonlinear differential equation $\dot{x}(t) = f(x(t), u(t))$ .

B. Control Architecture (NMPC + Cascaded PID)

To address the computational burden and provide a robust initial guess for the solver:

Cascaded PID as a Warm Start: A Cascaded PID controller runs in parallel to track a reference trajectory. Its output serves as the initial guess (warm start) for the NMPC optimizer. This significantly improves the convergence speed and stability of the nonlinear solver.
NMPC Formulation: The NMPC solves a finite-horizon optimal control problem (OCP) minimizing a cost function that penalizes deviations from the reference trajectory and control effort, subject to system dynamics and input constraints.

C. Code Generation and Solvers

To enable real-time execution on MCUs, the authors avoid heavy runtime libraries:

ACADO Toolkit: They use ACADO for automatic code generation. ACADO discretizes the nonlinear dynamics using the Multiple Shooting Method and transforms the OCP into a Nonlinear Programming (NLP) problem.
Sequential Quadratic Programming (SQP): The NLP is solved using the SQP method. ACADO employs the Gauss-Newton method to approximate Hessian matrices, allowing for real-time iterations (one SQP step per time step).
qpOASES Solver: For the resulting Quadratic Programming (QP) sub-problems, the authors utilize qpOASES, an active-set algorithm solver. Unlike interior-point methods (e.g., CVXGEN), active-set methods are preferred here for their ability to utilize "hot-starting" (using the previous solution as a starting point), which is crucial for real-time performance.
Static Memory Allocation: The generated C++ code is hard-coded for specific dimensions and uses static memory allocation to ensure deterministic execution times and fit within strict RAM limits.

3. Key Contributions

Novel NMPCM Framework: A complete pipeline for implementing generated NMPC source code on resource-constrained microcontrollers, integrating a Cascaded PID warm-start strategy to enhance solver performance.
Open-Source Implementation: Release of open-source C++ code using ACADO-generated solvers and qpOASES, capable of running in real-time on MCUs without external dependencies.
High-Frequency Realization: Demonstration of NMPC execution at frequencies up to 1 kHz on embedded hardware, a significant improvement over standard off-board implementations (typically <30 Hz).
Comprehensive Validation: Extensive benchmarking against state-of-the-art methods (MPCC, CasADi-based NMPC) and standard PID controllers in both simulation (Gazebo/ROS) and real-world hardware experiments.

4. Results

Simulation Results (Gazebo/ROS)

Frequency: The proposed NMPCM achieved a solving frequency of 1 kHz, whereas the CasADi-based solver was limited to 30 Hz.
Tracking Performance: NMPCM tracked reference trajectories (e.g., moving from [0,0,0.15] to [5,5,5]) with minimal steady-state error. While it exhibited slightly higher overshoot than CasADi in some axes, it avoided the significant altitude overshoot seen in the CasADi simulation.
Stability: The controller successfully satisfied input constraints (thrust and torque limits) while stabilizing the drone.

Hardware Experiments (Teensy 4.1)

Hardware: Experiments were conducted on a Teensy 4.1 microcontroller (ARM Cortex-M7, 600 MHz, 512 kB RAM).
Memory Constraints: The system was constrained to 512 kB of RAM. The authors demonstrated that with a time horizon of 10 and an integrator step of 5, the system could solve the optimization problem without exceeding memory limits.
Performance Benchmarks:
- Tracking: NMPCM significantly outperformed the Cascaded PID controller in terms of error metrics (ISE, ITSE, IAE, ITAE). For example, the ITAE for the roll angle ( $\phi$ ) dropped from 128.8 (PID) to 24.3 (NMPCM).
- Smoothness: The control signals (PWM) generated by NMPCM were smoother and more precise than those from the PID controller.
- Robustness: The system successfully stabilized quadrotors with different frame configurations (F450, H-Frame, X-Frame).

5. Significance

This work bridges a critical gap in robotics by proving that full nonlinear model predictive control is feasible on tiny, low-cost, resource-constrained microcontrollers.

Autonomy: It enables miniature robots (e.g., for search and rescue or infrastructure inspection) to perform complex, dynamic maneuvers autonomously without relying on heavy, power-hungry onboard computers or off-board links.
Efficiency: By combining code generation (ACADO) with efficient active-set solvers (qpOASES) and warm-starting techniques, the authors achieved a 30x+ speedup in control loop frequency compared to standard numerical solvers.
Accessibility: The open-source nature of the code lowers the barrier for researchers and engineers to deploy advanced control strategies on embedded systems.

Future Work: The authors plan to integrate potential field navigation and optimal-time optimization to handle obstacle avoidance and external disturbances, further enhancing autonomous capabilities.