Computer Controller Design Computer Controller Design Controllers are sort of a black art among most engineers, believe it or not. Many controllers used are simple on-off affairs, or gain + bias controllers for continuous control. Computer Scientists can sometimes be even worse, coding strange hacks to regulate variables rather than trying to control them. Today, we'll be looking at some general control theory, five controllers, the theory behind them, and how to implement them in FreeBASIC. Finally, we'll look at a few minor tricks you can use to make controllers extremely useful for controlling things in your software. General Control Theory A controller takes a variable of what's going on, called a "Process Variable" or PV, and tries to change another variable, called the "Manipulated Variable" or M, to drive the Process Variable towards the desired value, called "Set Point", or SP. The manipulated value M goes to whatever is controlling the process, and that device is called the "Control Element". To illustrate this, let's consider a controller which controls the amount of time a computer spends sleeping to correctly get the desired frame rate. The frame rate itself is the Process Variable in this case. The time the computer spends sleeping is the manipulated variable. The desired frame rate is the Set Point. The pause itself is the control element. The difference between a controller and a regulator can basically be summed up in terms of software by the presence or absence of a set point as part of the fundamental design. In real-life process control, a control loop is a much more complicated and elabourate device than a regulator. For the above example of controlling frame rate, an effective method to regulate the frame rate is to simply set the frame wait to 1/3 of a second. If the PC is fast enough, the rate will regulate to its optimum value. If the PC is too slow, the regulation will not correct properly. One often-overlooked concept in controllers is the concept of "Fail to safe". In terms of computers, this isn't relevant for safety reasons, because the controller and the control element will never fail independently of each other (In real life, lines can be cut or pneumatics can be blown out). Where this IS important is the fact that not every control element will act in the same direction! In the example above, increasing the frame period will decrease the frame rate. What if, instead, you were increasing the frequency of the frame wait? In that case, the increase in frequency would increase the frame rate. For this reason, we have "DIR" and "REV" outputs. The thing to remember is that DIR outputs will increase with an increase in error(More on this later), and REV outputs will decrease with an increase in error. In practice, you must ALWAYS ask yourself: "If my PV changes, which direction of change in M will bring PV back to SP?" Controller 1: The knife-edge on-off The knife-edge controller functions basically by comparing the process variable to set point, and setting M to 100% or 0%, depending on the DIR/REV setting, when PV drops below SP, and hammering M to the opposite value when the PV rises above SP. This results in a fairly tightly controlled PV, oscillating at the natural frequency of the process. The knife-edge controller is the easiest to write in FB – basically, it's just an IF statement! IF DIRREV = DIR then IF PV < SP then M = 100 else M = 0 ELSE IF PV < SP then M = 0 else M = 100 ENDIF Note that the reason this is called "knife edge" is that there is a single sharply defined point where on becomes off. This effect can also be created by setting the proportional gain on a P+B controller (Covered later) to a massive value, thus sending M to max or min depending on the PV and SP. Controller 2: The Hysteresis on-off The Hysteresis, or "Band gap" on-off controller is virtually the same as above, with one important difference: Unlike the knife-edge controller, which will turn a process on and off right around a single point, the on and off values are different. This is used mostly in places where hammering a control element off and on so quickly will have a detrimental effect. IF DIRREV = DIR then if M = 100 then IF PV < SP + X then M = 100 else M = 0 if M = 0 then IF PV < SP - X then M = 100 else M = 0 ELSE if M = 100 then IF PV < SP + X then M = 0 else M = 100 if M = 0 then IF PV < SP - X then M = 0 else M = 100 ENDIF Notice that this controller just changes the point around a bit depending on the direction M is in. Controllers like these are used in industrial operations when the simplicity of an on-off controller is ideal, but the high oscillation of a control element using a knife-edge controller will cause excess mechanical wear. Controller 3: The P+B The P+B controller is where things get interesting, because we're getting into continuous control. P+B means "Proportional + Bias". To understand what this means, you must first understand that error is either SP-PV or PV-SP, depending on the DIR/REV setting. Therefore, all the remainder of the controllers actually know is exactly how different PV is from SP. Proportional control uses this information, E, by simply multiplying it by some factor Gp. The effect is any error in the process variable signal vs. set point will drive M to oppose the error proportionally. To understand this, consider you have your two hands pushing against each other. Now, when one starts pushing harder, the other starts pushing harder. When one lets up, the other lets up. In the end, nothing moves. This is exactly how this controller functions. It also has a bias function, however. The purpose of this is to eliminate the offset caused by the Proportional signal. There is an offset because the proportional signal REQUIRES error to act. Thus, if there is no error, the output won't change. If the output won't change, your PV drifts from SP. If your PV drifts from SP, you get an error, and the controller can correct that error! M = B + Gp*E if DIR then E = PV – SP else E = SP – PV M = B + Gp*E Controller 4: The PI We covered mathematical integrals in a previous article. This controller supposedly take the integral of error over time, multiplies the integral by a constant Gi, and adds that to the proportional gain covered in the previous controller. The result is that the controller 'seeks' zero error by integrating the error over time, and acting in the direction required to push error towards 0. This would be tough if we were actually planning on taking the integral mathematically, but you can sum the error using a much better method: just keep adding the error to a value, scaled with time! One problem with this form of controller is they can "wind up" the integral and take a long time to "unwind" on some processes. This can happen if your SP is set very high or very low, and is then set very low or very high. There is no bias in this controller, because the Integral action actually functions as an 'auto-bias' mechanism. M = Gp * E + GI * E if DIR then E = PV – SP else E = SP – PV IntegralE += E M = B + Gp*E + Gi*IntegralE Controller 5: The PID The PID controller takes the previous PI controller, and adds one more element. A problem with many processes, such as temperature control loops, is that the strange time constants will make a PI control loop oscillate. This happens because a PI control loop can have no clue when the process starts approaching the appropriate value. The PID controller adds a derivative unit, which opposes the rate of change of the process variable, multiplied by a constant Gd. By limiting the rate of change, the PID controller can achieve what almost appears to be prescient control with some processes, such as temperature. An important thing to remember though, is processes with Gaussian noise(that is, noise that more or less stays around the measurement signal) will act WORSE with a pid controller. M = GP * E + GI * integral(E) + GD * dE/dt if DIR then E = PV – SP else E = SP – PV IntegralE += E DerivativeE = oldE - E oldE = E M = B + Gp * E + Gi * IntegralE + Gd * DerivativeE Note that the so-called Derivative is nothing more than the difference between the old error and the new. Again, calculus concepts so difficult with equations are much simpler when you exist in the time domain. Integrating a control loop into a software process To integrate the controller into a loop, simply plug the sensed variable into PV, and the controlled variable into SP. You may need to scale both, but that's more or less self-explanitory. Tuning your control loop There are a large variety of ways to tune a control loop, including the Process Reaction Curve and Zeigler Nichols. Instead of trying to explain those complex techniques, I'll just tell you to do the easy thing: Increase proportional gain until the loop starts to oscillate, then pull back a bit. Then, increase integral gain until the loop starts to oscillate, then pull back a bit. Finally, do the same for derivative. It's not pretty, but it will provide a relatively good reaction, possibly better than quarter amplitude damping. -- Jason