This project is to use Model Predictive Control (MPC) to drive a car in a game simulator. The server provides reference waypoints (yellow line in the demo video) via websocket, and we use MPC to compute steering and throttle commands to drive the car. The solution must be robust to 100ms latency, since it might encounter in real-world application.
In this project, the MPC optimize the actuators (steering and throttle), simulate the vehicle trajactory, and minimize the cost like cross-track error.
A max speed of 80 MPH is achieved in this project.
A kinematic model is implemented to control the vehicle around the track. Kinematic models are simplifications of dynamic models that ignore tire forces, gravity, and mass. This simplification reduces the accuracy of the models, but it also makes them more tractable.
The prediction horizon is the duration over which future predictions are made. We’ll refer to this as T. T is the product of two other variables, T = N * dt. In the case of driving a car, T should be a few seconds, at most. Beyond that horizon, the environment will change enough that it won’t make sense to predict any further into the future. N and dt are hyperparameters you will need to tune for each model predictive controller you build. However, there are some general guidelines: T should be as large as possible, while dt should be as small as possible. These guidelines create tradeoffs.
These following dt has been tested 0.3, 0.12, 0.1, 0.08, and I found that the dt should be greater than the latency in order to make the MPC work. So, I choose 0.12 as dt in the end.
The goal of Model Predictive Control is to optimize the control inputs: [δ,a]. An optimizer will tune these inputs until a low cost vector of control inputs is found.
Since the reference waypoints are given in the map global coordinate, and I transfer them into the car’s coordinate
by a funciton called
map2car (see line 117 in
main.cpp), then a 3rd order polynomial is fitted to waypoints.
In a real car, an actuation command won’t execute instantly - there will be a delay as the command propagates through the system. A realistic delay might be on the order of 100 milliseconds, so in this project 100 millisecond latency is handled by Model Predictive Controller.
The latency is handled by using kinematic equations to predict the states for after 100ms before sending them to MPC
(see code in line 126-134 in
brew install gcc(might not be required)
sudo apt-get install gfortran. Additionall you have also have to install gcc and g++,
sudo apt-get install gcc g++. Look in this Dockerfile for more info.
brew install ipopt
apt-getis 3.11.x. If you can get that version to work great but if not there’s a script
install_ipopt.shthat will install Ipopt. You just need to download the source from the Ipopt releases page or the Github releases page.
install_ipopt.shwith the source directory as the first argument, ex:
sudo bash install_ipopt.sh Ipopt-3.12.1.
brew install cppad
sudo apt-get install cppador equivalent.