CarND-Controls-PID

Self-Driving Car Engineer Nanodegree Program

PID Controller

A PID (Proportional, Integral, Differential) Controller is a control feedback mechanism used in robotics and industrial control systems. The PID controller continuously tracks an error value e(t) as the difference between a desired threshold, and a measured process variable, and applies a continuous correction based on proportional (P), integral (I), and differential (D) terms. In the case of a Self Driving Car, a PID controller can be used to drive a car with reference to a particular offset from the lane lines (thru controlling the steering angle of the vehicle), and also a reference speed (thus controlling the throttle/accelerator).

Mechanism

A PID Controller attempts to minimize the error over time by adjusting control variable u(t) based on tracking the error Cross Track Error (CTE) also written as e(t).

u(t) = Kp * e(t) + Ki * Integral_e(t) + Kd * Derivative_e(t)/dt

Where Kp, Ki, Kd are non-negative coefficients for the proportional, integral, differential terms, respectively.

P term accounts for present values of the CTE. If the error is large, the control output will also be large.
I term accounts for past values of the error. This term smoothens out the accumulated bias over time.
D term accounts for possible future values of the error, based on its current rate of change.

Parameter Tuning

In this project, the PID values were chosen manually, and then optimized based on the performance of the car.

Initially, the Kp value was set to a small value (~0.1) and Ki and Kd were set to 0, and the performance was observed. Kd was slowly increased until a wobble was observed, and then reduced to between 2.0 - 3.0. Ki was chosen to a very small value (0.0001) since the vehicle does not have an inherent steering bias.

A second PID was introduced to control the Speed of the vehicle, via the throttle variable. A target speed limit was tested from a slow speed of 30 mph, and the car was observed to complete Track 1 correctly. The speed limit was then slowly raised till 80 mph in increments of 10 mph, and the K-coefficients were chosen manually to both increase the speed of the vehicle, while also performing within the bounds of the road.

Ultimately, the K-values for were as follows:

Speed Limit: 65 mph

PID Controller	K-coefficient	Value
Steering PID	Kp	0.13
- same -	Ki	0.0002
- same -	Kd	2.0
Throttle PID	TKp	0.12
- same -	TKi	0.00001
- same -	TKd	2.5

Improvements & Future Work

A Twiddle algorithm could be implemented to algorithmically determine the K coefficients, instead of manual testing.
A braking functionality could be implemented to slow down the vehicle during turns (steep steering angles).

Dependencies

cmake >= 3.5
All OSes: click here for installation instructions
make >= 4.1
- Linux: make is installed by default on most Linux distros
- Mac: install Xcode command line tools to get make
- Windows: Click here for installation instructions
gcc/g++ >= 5.4
- Linux: gcc / g++ is installed by default on most Linux distros
- Mac: same deal as make - [install Xcode command line tools]((https://developer.apple.com/xcode/features/)
- Windows: recommend using MinGW
uWebSockets == 0.13, but the master branch will probably work just fine
- Follow the instructions in the uWebSockets README to get setup for your platform. You can download the zip of the appropriate version from the releases page. Here's a link to the v0.13 zip.
- If you run OSX and have homebrew installed you can just run the ./install-mac.sh script to install this
Simulator. You can download these from the project intro page in the classroom.

Basic Build Instructions

Clone this repo.
Make a build directory: mkdir build && cd build
Compile: cmake .. && make
Run it: ./pid.

Editor Settings

We've purposefully kept editor configuration files out of this repo in order to keep it as simple and environment agnostic as possible. However, we recommend using the following settings:

indent using spaces
set tab width to 2 spaces (keeps the matrices in source code aligned)

Code Style

Please (do your best to) stick to Google's C++ style guide.

Project Instructions and Rubric

Note: regardless of the changes you make, your project must be buildable using cmake and make!

More information is only accessible by people who are already enrolled in Term 2 of CarND. If you are enrolled, see the project page for instructions and the project rubric.

Hints!

You don't have to follow this directory structure, but if you do, your work will span all of the .cpp files here. Keep an eye out for TODOs.

Call for IDE Profiles Pull Requests

Help your fellow students!

We decided to create Makefiles with cmake to keep this project as platform agnostic as possible. Similarly, we omitted IDE profiles in order to we ensure that students don't feel pressured to use one IDE or another.

However! I'd love to help people get up and running with their IDEs of choice. If you've created a profile for an IDE that you think other students would appreciate, we'd love to have you add the requisite profile files and instructions to ide_profiles/. For example if you wanted to add a VS Code profile, you'd add:

/ide_profiles/vscode/.vscode
/ide_profiles/vscode/README.md

The README should explain what the profile does, how to take advantage of it, and how to install it.

Frankly, I've never been involved in a project with multiple IDE profiles before. I believe the best way to handle this would be to keep them out of the repo root to avoid clutter. My expectation is that most profiles will include instructions to copy files to a new location to get picked up by the IDE, but that's just a guess.

One last note here: regardless of the IDE used, every submitted project must still be compilable with cmake and make./

laventura / PID-Control