PID or Proportional Integral Derivate is used often times when you need an automated system to self correct. Think for example a robot that has to drive straight or follow a line, or self balance.
Driving or Flying Straight: In this case the robot needs to keep to a certain heading or angle. Various forces might make it deviate from that heading (wind, wheel slip or friction, etc). The difference between the target heading and the actual heading is the error and PID can be used to correct that heading.
Following a line: In line following the robot attempts to follow a dark line to its target. In this case, typically a sensor that senses reflected light is used. The robot attempts to keep the reflected light within a certain range and tries to correct its direction to keep tracking the line. The difference between the amount of reflected light sensed and target reflected light is the error value and used in self correcting the direction the robot is travelling.
Self Balancing Robot: Think about a segway like robot that attempts to self balance using 2 motors. In this case the robot's target orientation is upright and the error is the angle from the vertical plane. The robot then attempts to self correct by applying a force towards the vertical plane. PID again provides the amount of self correcting needed.
PID is most important in the self balancing example, as one cannot use a constant amount of correction, as the robot would likely topple. This is because while the robot is attempting to balance, the amount of deviation from the vertical plane will vary randomly.
Quad Copter: This is probably the most intuitive applications to work with. Think of a quad copter on the ground. You wish to have it take off and hover at a certain height (eg: 10 feet). When the quad copter first takes off, its altitude sensor will start at 0 feet and the error is 10 feet. The quad copter increases its propeller speed and starts its journey to 10 feet. It will invariably overshoot the target altitude (say 11 feet), so it will have to slow down its propeller to return back to its target of 10 feet. Wind and other factors will keep moving the copter away from its target altitude and so, as the sensor returns its altitude readings, the quad copter will have to continuously change the propeller speed to increase or decrease its altitude.
PID is again a better algorithm to use for a quad-copter trying to attain a target height, compared to a constant correction amount, as it will allow it to get to its target height and maintain it better.
In a PID based system, the math is trying to reduce the error at every calculation step (or loop) and bring it to its target value. The systems typically never ever reaches the their target value and continuously fluctuates around the target value.
Even though PID uses fancy words like integral and derivate, the math itself is very simple.
Lets go through PID math by its various components:
Proportional
One can use only the proportional part of PID (with I = 0 and D = 0) in many simple systems (eg: line following robot). The job of this component of the PID math is to provide a correction towards the target value.
Kp: constant of proportion (usually called the "proportional gain constant")
SP: Set Point (or the target value we want on the sensor)
PV(t): The process value at time t (or the current sensor value)
E(t) = SP - PV(t) : This is the error at any given time t. (or the error in the graph above).
The proportional value P(t) is calculated as Kp * E(t) or Kp * (SP - PV(t)).
P(t) = Kp * E(t)
P(t) = Kp * (SP - PV(t))
In other words its the error multiplied by a certain tuning factor (Kp). Kp can be used to magnify or dampen the effect of the error on the driving components.
In the diagram below, its Kp * 9ft (where Kp could be any value that you pick, other than 0!). If Kp = 1, then the value would be 9.
Integral
The job of the integral is make larger corrections if the Proportional component is not providing enough of a correction. It accumulates the errors and applies it to the correction. Again a Integral gain constant is used to dampen or magnify the effect of this component.
Ki: integral gain constant
I(t) = Ki * E(t) + I(t-1)
Where I(t-1) is the I(t) that was calculated in the previous cycle. If the terms (t-1) and (t) are confusing, you can also write this as:
I = Ki * E + Iprev
In the above diagram if Ki = 1, then at time = 1:
I = 1 * 9 + 0 = 9 (0, as I starts at 0)
at time = 2, (now I = 9)
I = 1 * 7 + 9 = 16
Derivate
The job of the derivate is to slow down the effect of the Proportional and Integral components. It attempts to minimize overshoot that can happen as the previous two components attempt to bring the system to the target value. From the graph above its the difference in value of the 2 error values shown above at (t-1) and t.
Kd: derivate gain constant
D(t) = Kd * (E(t) - E(t-1))
or alternatively:
D = Kd * (E - Eprev)
In the above example, if Kd = 1, then at t = 1:
D = 1 * (9-0) = 9
at t=2, E(t-1) or Eprev = 9:
D = 1 * (7-9) = 1 * -2 = -2
Putting it all together:
C(t) = P(t) + I(t) + D(t) where C is the correction.
C(t) = Kp*E(t) + (Ki*E(t) + Ki*I(t-1)) + Kd*(E(t) - E(t-1))
Going back to our quad-copter example, this is what its flight might have looked like
In fancy math terms this is the PID equation:
And as an Algorithm:
- Kp = 1, Ki = 1, Kd = 1 (where the values can be different and tuned for your system)
- Target = 100 (this is the set-point. This the target value you wish your system to achieve)
- CurrentValue = 0 (this is the current sensor measurement or Process value - PV)
- ErrPrev = 0
- I = 0
- while true
- Err = Target - CurrentValue(from Sensor)
- P = Kp * Err
- I = Ki * Err + I
- D = Kd * (Err - ErrPrev)
- ErrPrev = Err
- C = P + I + D
- Do something with C (turn your robot by C degrees, etc).
