Adding PID controller Chapter.

SUMMARY.md

@@ -33,6 +33,7 @@
     * [Verlet Integration](contents/verlet_integration/verlet_integration.md)
     * [Quantum Systems](contents/quantum_systems/quantum_systems.md)
         * [Split-Operator Method](contents/split-operator_method/split-operator_method.md)
+* [PID Controller](contents/pid_controller/pid_controller.md)
 * [Data Compression](contents/data_compression/data_compression.md)
     * [Huffman Encoding](contents/huffman_encoding/huffman_encoding.md)
 * [Quantum Information](contents/quantum_information/quantum_information.md)

contents/pid_controller/code/c/pid_controller.c

@@ -0,0 +1,46 @@
+#include <stdio.h>
+
+struct pid_context {
+    double kp;
+    double ki;
+    double kd;
+    double setpoint;
+    double last_error;
+    double integral;
+    double dt; // Normally you calculate the change in time.
+};
+
+struct pid_context get_pid(double setpoint, double dt, double kp, double ki,
+                           double kd) {
+
+    struct pid_context ctx = {0};
+    ctx.setpoint = setpoint;
+    ctx.dt = dt;
+    ctx.kp = kp;
+    ctx.ki = ki;
+    ctx.kd = kd;
+
+    return ctx;
+}
+
+double pid_calculate(struct pid_context ctx, double input) {
+    // Here you would calculate the time elapsed.
+    double error = ctx.setpoint - input;
+    ctx.integral += error * ctx.dt;
+    double derivative = (error - ctx.last_error) / ctx.dt;
+    ctx.last_error = error;
+
+    return ctx.kp * error + ctx.ki * ctx.integral + ctx.kd * derivative;
+}
+
+int main() {
+    struct pid_context ctx = get_pid(1.0, 0.01, 1.2, 1.0, 0.001);
+    double input = 0.0;
+
+    for (int i = 0; i < 100; ++i) {
+        input += pid_calculate(ctx, input);
+        printf("%g\n", input);
+    }
+
+    return 0;
+}

contents/pid_controller/pid_controller.md

@@ -0,0 +1,86 @@
+# Proportional-Integral-Derivative Controller
+
+The Proportional-Integral-Derivative controller (PID controller) is a control loop feedback mechanism, used for continuously modulated control.
+The PID controller is comprised of three parts: proportional controller, integral controller, and derivative controller.
+
+Before we get into how a PID controller works, we need a good example to explain things.
+Imagine you are making a self-driving RC car that drives on a line, how would make it work given that the car moves with a constant speed.
+
+### Proportional Controller
+
+If the car is too far to the right then you should turn left and vice versa.
+Since there are a range of angles you can turn the wheel, so you should turn proportional to the distance from the line.
+This is what the proportional controller (P controller) does, which is described by,
+
+$$ P = K_{p} e(t), $$
+
+Where $K_{p}$ is a constant and $e(t)$ is the current distance from the line, which is called the error.
+The performance of the controller improves with larger $K_{p}$;
+if $K_{p}$ is too high then when the error is too high, the system becomes unstable.
+In this case, the car would turn in circles, since there is a maximum angle the wheel can turn, else it would zig zag around the line.
+
+### Derivative Controller
+
+The P controller works well but it has the added problem of overshooting a lot, we need to dampen these oscillations.
+One way to solve this is to make the rc car resistant to sudden changes of error.
+This is what the derivative controller (D controller) does, which is described by,
+
+$$ D = K_{d} \frac{de(t)}{dt}$$
+
+Where $K_{d}$ is a constant.
+If $K_{d}$ is too high then the system is overdamped, i.e. the car takes too long to get back on track.
+If it's too low the system is underdamped, i.e. the car oscillates around the line.
+When the car is getting back on track quickly with little to no oscillations then the system is called critically damped.
+
+### Integral Controller
+
+The Proportional and Derivative controllers are robust enough to get the on course.
+We start driving, but then some wind starts pushing the car which introduces a constant error.
+We need to know if we are spending too long on one side and account for that.
+The way to do that is to sum up all the errors and multiply it by a constant.
+This is what the integral controller (I controller) does, which is described by,
+
+$$ I = K_{i} \int_{0}^{t} e(\uptau) d\uptau, $$
+
+Where $K_{i}$ is a constant.
+The peformance of the controller is better with higher $K_{i}$; but with higher $K_{i}$ it can introduce oscillations.
+
+### Proportional-Integral-Derivative Controller
+
+The PID controller is just a sum of all three controllers and is of the form,
+
+$$ U = K_{p} e(t) + K_{i} \int_{0}^{t} e(x) dx + K_{d} \frac{de(t)}{dt} $$
+
+To use a PID controller, you need to tune it by setting the constants, $K_{p}$, $K_{i}$, and $K_{d}$.
+If you choose the parameters for your PID controller incorrectly, the output will be unstable, i.e., the output diverges.
+There are multiple methods of tuning like, manual tuning, Ziegler–Nichols, Tyreus Luyben, Cohen–Coon, and Åström-Hägglund.
+
+Theoretically, PID controllers can be used for any process with a measurable output and a known ideal output,
+but controllers are used mainly for regulating temperature, pressure, force, flow rate, feed rate, speed and more.
+
+## The Algorithm
+
+Luckily the algorithm is very simple, you just need to make the PID equation discrete.
+Thus, the equation looks like this:
+
+$$ U = K_{p} e(t_{j}) + \sum_{l=0}^{j} K_{i} e(t_{l}) \Delta t + K_{d} \frac{e(t_{j-1}) - e(t_{j})}{\Delta t}. $$
+
+In the end the code looks like this:
+
+{% method %}
+{% sample lang="c" %}
+[import:26-34, lang:"c_cpp"](code/c/pid_controller.c)
+{% endmethod %}
+
+## Example Code
+
+This example is not calculating the time elapsed, instead it is setting a value called dt.
+
+{% method %}
+{% sample lang="c" %}
+[import, lang:"c_cpp"](code/c/pid_controller.c)
+{% endmethod %}
+
+<script>
+MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
+</script>