💻 computer science

LPV-MPC for Lateral Control in Full-Scale Autonomous Racing

This paper presents a Linear Parameter-Varying Model Predictive Controller (LPV-MPC) for lateral control of full-scale autonomous racing vehicles, demonstrating its successful implementation and stable performance at speeds exceeding 160 mph on an IAC AV-24 while addressing computational and operational constraints.

Original authors: Hassan Jardali, Ihab S. Mohamed, Durgakant Pushp, Lantao Liu

Published 2026-03-17

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Hassan Jardali, Ihab S. Mohamed, Durgakant Pushp, Lantao Liu

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 teaching a robot to drive a race car around a track at speeds faster than a Formula 1 car. The goal isn't just to stay on the road; it's to hug the inside line, take corners at 160 mph, and do it without crashing, all while the car's computer has to make decisions in the blink of an eye.

This paper is about how the IU-Luddy Autonomous Racing Team taught their robot car to do exactly that. They built a "brain" for the car called an LPV-MPC, and here is how it works, explained simply.

1. The Problem: Driving at the Edge of Chaos

Driving a car at normal speeds is easy. The tires grip the road, and if you turn the wheel, the car turns. But at 160 mph, physics gets weird. The tires start to slide (like a hockey puck on ice), the car leans heavily into turns, and the road itself might be tilted (banked) like a roller coaster.

If you use a simple rule like "turn the wheel 10 degrees," the car will crash because it doesn't account for how fast it's going or how slippery the tires are. The team needed a controller that could predict the future and adjust instantly.

2. The Solution: The "Crystal Ball" Driver (LPV-MPC)

The team created a controller called LPV-MPC. Let's break down the name with an analogy:

MPC (Model Predictive Control): Imagine you are playing a video game where you can see 2 seconds into the future. Before you make a move, you simulate: "If I turn left now, will I hit the wall in 2 seconds? If I turn right, will I be too far from the track?" You pick the move that keeps you safe and on track. MPC does this thousands of times a second. It looks ahead, plans a path, and only executes the very first step of that plan before looking ahead again.
LPV (Linear Parameter-Varying): This is the "smart" part. A standard driver might assume the car always handles the same way. But a race car at 50 mph handles differently than at 160 mph.
- The Analogy: Think of a chameleon. A chameleon changes its color based on its surroundings. Similarly, this controller changes its "rules" based on the car's current speed, how sharp the turn is, and how much the track is tilted. It doesn't use one static map; it uses a living, breathing map that updates instantly as the car speeds up or slows down.

3. The "Training" (System Identification)

You can't just guess how a race car behaves; you have to measure it. The team had to figure out exactly how their specific car's tires grip the road.

The Challenge: They couldn't just drive around testing things because crashes are expensive and dangerous.
The Fix: They used a mathematical "detective" method. They took data from previous laps (where the car was driving fast) and used a computer algorithm to reverse-engineer the tire physics. It's like listening to a song and trying to figure out exactly what instruments were used just by analyzing the sound waves. They found the "stiffness" of the tires (how much they bend before slipping) and fed this data into the controller.

4. The Real-World Test: The Indy Autonomous Challenge

The team took their robot car to the Indianapolis Motor Speedway and later the Las Vegas Motor Speedway. These are huge, oval tracks with steep banks (tilted walls).

The Result: The car drove itself autonomously at speeds over 160 mph.
The Performance:
- It stayed on the track with incredible precision, only drifting about 1.6 meters off the ideal line (which is tiny for a car going that fast).
- It handled the "g-forces" of the turns without spinning out.
- The computer solved the complex math in about 6 milliseconds (faster than a human can blink).

5. Why This Matters

Before this, most high-speed racing controllers were either too simple (and crashed at high speeds) or too complex (and the computer couldn't calculate fast enough).

This paper proves that you can have both: a controller that is smart enough to handle the complex physics of a race car and fast enough to run on a laptop-sized computer inside the car.

The Takeaway

Think of this system as a super-coach sitting in the passenger seat.

It knows the car's exact physical limits (the tires, the weight).
It constantly asks, "If I steer this way, where will we be in 2 seconds?"
It adjusts its strategy instantly as the car speeds up or the track tilts.
It keeps the car glued to the track, even when the laws of physics are screaming "crash!"

The team even released their code for free, so other researchers can use this "super-coach" to build better self-driving cars for the future.

1. Problem Statement

Autonomous racing presents unique challenges for control systems, particularly at high speeds (exceeding 160 mph). Key difficulties include:

Nonlinear Dynamics: Significant tire slip, coupled longitudinal-lateral dynamics, and varying tire-road friction.
Computational Constraints: Controllers must operate within the onboard system's limited processing power while meeting strict real-time requirements.
Operational Limits: Teams often have very limited track time for tuning and face high costs for vehicle repairs, making robust, pre-tuned controllers essential.
Model Uncertainty: Traditional kinematic models (e.g., Pure Pursuit) fail at racing speeds because they assume no-slip conditions, while complex nonlinear models are often too computationally expensive or difficult to identify without extensive data.

The paper addresses the need for a lateral control strategy that balances robustness, precision, and computational efficiency for full-scale autonomous vehicles on oval tracks.

2. Methodology

The authors propose a Linear Parameter-Varying Model Predictive Controller (LPV-MPC) designed specifically for high-speed lateral control.

A. Vehicle Modeling

Base Model: A single-track (bicycle) dynamic model is used, extended to include the steering angle ( $\delta$ ) as a state variable to explicitly handle steering rate constraints.
Augmentation: The model incorporates road banking ( $\phi$ ) as a disturbance term ( $g \sin \phi$ ) to account for the gravitational assist on oval tracks (up to 20° banking).
LPV Formulation: The system is formulated as an LPV system where the state-space matrices ( $A, B, C, D$ $A, B, C, D$ ) are scheduled by three time-varying parameters:
1. Longitudinal velocity ( $v_x$ )
2. Path curvature ( $\kappa$ )
3. Road banking angle ( $\phi$ )
State Vector: The controller tracks errors in cross-track position ( $e_y$ ), lateral velocity ( $\dot{e}_y$ ), heading ( $e_\psi$ ), yaw rate ( $\dot{e}_\psi$ ), and steering angle ( $\delta$ ).

B. Parameter Identification

System Identification: Since precise tire parameters are hard to measure, the authors used an Expectation-Maximization (EM) approach with nonlinear least-squares optimization.
Tire Model: They fitted a Pacejka (Magic Formula) tire model to IMU data collected during practice runs.
Linearization: The nonlinear Pacejka parameters were converted into linear cornering stiffness values ( $C_f, C_r$ ) for use in the MPC, validated against a Physics-Informed Neural Network (PINN) approach.

C. Control Formulation

Objective Function: A constrained nonlinear least-squares problem minimizing tracking errors, control effort, and a penalty on the side-slip angle ( $\beta$ ) to ensure stability.
Constraints: Explicit handling of steering angle limits ( $\delta_{min/max}$ ) and steering rate limits ( $\dot{\delta}_{min/max}$ ).
Solver: The optimization is solved using acados with a Real-Time Iteration Sequential Quadratic Programming (SQP-RTI) scheme and HPIPM, discretized over a 1.6-second horizon (45 steps).
Fallback: A Pure Pursuit controller acts as a safety backup if the MPC fails due to numerical instability or constraint violations.

3. Key Contributions

LPV-MPC Framework: Development of a lateral controller that adapts to varying speeds, curvatures, and banking angles in real-time, overcoming the limitations of fixed-gain or constant-velocity controllers.
Full-Scale Validation: Successful deployment on an IAC AV-24 (a full-scale autonomous race car) achieving stable control at speeds exceeding 160 mph (71.5 m/s).
System Identification Pipeline: A detailed methodology for extracting dynamic parameters (Pacejka coefficients) from limited track data using an EM algorithm, bridging the gap between theoretical models and real-world vehicle dynamics.
Open-Source Release: Provision of a Python-based implementation of the framework to facilitate reproducibility and further research in the autonomous racing community.

4. Experimental Results

The system was tested during the Indy Autonomous Challenge (IAC) at the Las Vegas Motor Speedway (LVMS) on January 9, 2025.

Performance Metrics:
- Max Speed: Achieved 163.1 mph (72 m/s) on the final lap.
- Lap Time: Best lap time of 34.18 seconds with an average speed of 157.98 mph.
- Tracking Error: Mean cross-track error was -1.02 m (indicating a consistent offset to the left of the reference line), with a standard deviation of 0.38 m. Heading error remained within ±1°.
- Stability: The vehicle maintained stable performance throughout 12 high-speed laps, with lateral accelerations reaching up to 27 m/s².
Computation: The control loop operated with a mean computation time of 5.78 ms, well within the 10 ms cycle time required for 100 Hz operation (currently running at 50 Hz).
Observations:
- The controller successfully handled the transition into the nonlinear tire region (slip angles up to 2°).
- A persistent cross-track error was attributed to unmodeled hardware steering offsets and asymmetric weight distribution, which were not fully compensated for in the model.
- Model errors spiked during aggressive throttle inputs due to longitudinal-lateral coupling not fully captured by the linear model.

5. Significance and Conclusion

This paper demonstrates that LPV-MPC is a viable and effective strategy for full-scale autonomous racing at extreme speeds. By explicitly scheduling the controller on velocity, curvature, and banking, the system achieves a level of adaptability that fixed-parameter controllers lack.

Practical Impact: It validates that complex optimization-based control can run reliably on embedded hardware in a high-stakes, competitive environment with limited practice time.
Future Directions: The authors identify the need for better handling of longitudinal-lateral coupling (nonlinear MPC), improved parameter identification for asymmetric vehicles, and the inclusion of a robust terminal cost for enhanced stability.
Community Value: The release of the code and the detailed analysis of the parameter identification process provide a valuable reference for researchers aiming to push the boundaries of autonomous vehicle control.