Is there an easy path for PID controller tuning, especially for those who aren’t experts? What’s the minimum I need to know to succeed at PID tuning?
Navigating the controller tuning process
- There is a minimum amount of information you need to solve a specific tuning problem, but the scope of that information is very different for different problems. There is no simple guide that covers all problems.
- You must filter available tuning articles and videos against knowledge about your process and system to verify they apply to your problem.
- Careful attention to measurement scaling and internal system processing is required to successfully apply tuning solutions to your system.
- Controller tuning follows a five-step process (unless you run into additional problems like bad valves or process noise).
- Some tuning problems should be referred to experts.
Within the first 10 installments of the PID spotlight series, someone asked for an easier way to optimize proportional-integral-derivative controller tuning. I’m sure the person is perfectly capable, but an “occasional tuner,” where PID controller tuning is only a small part of the job. The real question is “What is the minimum amount of knowledge I need just to get by?” which is a question all of us have asked many times.
The answer to the “easier way” question is no, to my knowledge there is no single controller tuning guide that can serve as a one-stop tutorial. An internet search for “basic PID tutorial” will return a bewildering array of articles and videos. Some are fairly good as far as they go, and you will get good results if they apply to your situation. Unfortunately, in the interest of time, all the videos and articles often leave out important context: What is the process? What is the control platform? What is the form of the PID equation? How is gain entered? What are the time units on integral and derivative? What kind of performance will this tuning method give you?
If you do not know to ask these questions, you can get yourself into plenty of trouble (not to mention questioning your career choices.)
Similarly, the implied question “What is the minimum I need to get by?” gets the frustrating answer “that depends.” If you know the right questions to ask, you can usually get to an answer. There is no way to sugarcoat it. Acquiring minimum knowledge for PID tuning remains a research project.
Can we help the occasional PID controller tuner get by?
Let’s try to get a beginning PID controller tuner pointed in the right direction. It begins with breaking down the process into its component steps:
- Identify the problem.
- Visualize the solution.
- Select the required tools.
- Execute the solution using the tools.
- Verify the solution.
Conceptually that’s easy, but the problem is in the details. What follows is how to navigate the previous articles in this series, omitting the ones you may be able to safely skip, while getting to the minimum you need to know to get to a solution. However, before doing any of this, it is important to know the basics of the PID algorithm. PID spotlight part 2 covers two of the three major PID controller variants, classical and parallel, and includes this advice: If at all possible set up a PID controller simulation on your system and play with it to get a feel for how your PID really works. Every system has quirks that generic training just cannot prepare you for.
Getting from engineering units to percent in PID controllers
If you are new to applying control theory, you need to know some basic housekeeping first:
- Any measurement not in percent of span must be converted to percent before calculating tuning constants.
- Some systems’ PID controllers work in engineering units and therefore require special setup.
- Some older programmable logic controllers work in very strange units which require special attention.
In most modern control systems, the PID algorithm converts inputs and outputs to percent of span. While it may display a temperature of 350°F and the controller output is 1530 gpm, internally the process variable is 70% and the output is 61.2%. The conversion is:
Percent = 100 * (value – min value) /(max range – min range)
Some systems will also let you access the process variable, setpoint, and controller output in percent of span. If they do save yourself a little trouble and trend these variables when you are tuning.
There are some legacy systems that work in engineering units. You can spot these because they have a unit conversion factor included somewhere in their PID algorithm. They will usually call it a gain, which only confuses things. Their documentation will show a PID algorithm that may look like this:
OP = KG *(K *Error + Ti * ∫Error + Td * d(PV)/dt)
Where:
KG is the unit conversion factor (it may be described as a “gain multiplier”).
Regardless of how things are shown in the documentation, the key is there is an extra gain term that won’t look like it belongs. The trick will be teasing out which is the unit conversion factor; this should be the one outside of all the parentheses.
KG should be set to:
KG = Output Span / Input Span
Which, in the case of a flow controller that operates a valve directly:
KG = 100% / 47,737 BPD
KG = 0.002095 %/BPD
Or, in the case of the level cascading to that flow:
KG = 47,737 BPD / 100%
KG = 477.37 BPD/%
You can end up with some very strange-looking unit conversion factors, but the result is you can use tuning constants calculated using normal methods that assume the input and output range is in percent of span. The caveat is you must then convert the process variable, setpoint, and controller output readings to percent of span just like you would with a system that works internally in percent. You must also remember that whenever an instrument span is changed you must also update KG to avoid inadvertently changing tuning as well as confusing future users. (If you have the great misfortune to run into a system that works in engineering units and doesn’t supply a unit conversion factor then you will have to use heuristic tuning.)
Finally, early in my career I worked with programmable logic controllers (PLCs) that did all their internal math in signed integers. The range of inputs and outputs was 0-32,000. As long as the input to and output from the PID controller was not converted to engineering units it was possible to calculate tuning constants as if the controller was using percent of span internally. If, however, anything was converted to engineering units you were on your own. If you run into this situation, you have a research project on your hands. Fortunately, as long as you are working with modern systems you shouldn’t run into this (although it’s been many years since I worked with PLCs and who is to say what weird stuff might still be out there).
Identifying the problem with PID tuning
Our first set of questions have to do with understanding your equipment: What is the control platform? What is the form of the PID equation? How is gain entered? What are the units on integral and derivative? And, as we just learned, how does the PID algorithm handle inputs and outputs? Once you know the answers to these questions you can start looking for information geared to your system (and weed out the ones that are not applicable.)
Next we have to ask what is the process? Fortunately for us, the vast majority of processes we will run across fall into one of two categories; self-limiting or integrating (or close enough). If there are any questions on how to identify the type of process you are working with please review PID spotlight part 3.
Caution: If you find that your process doesn’t fall into the self-limiting or integrating type, ask for expert help. Exponential and complex process types are often hazardous and can get you into deep trouble in a hurry. Sometimes giving up and asking for help is the better part of valor.
The next issue you must deal with is the lag/deadtime or fill time/deadtime ratio for self-limiting or integrating processes. Each respectively affects how you might tune the controller or even whether a PID controller will work at all. Fortunately most processes will tend toward higher lag/deadtime or fill time/deadtime ratios and can be tuned reasonably easily. This is more of an awareness issue and if you run into problems you will need to adjust tuning methods.
Visualizing the PID tuning solution
Once we’ve established that a controller needs to be tuned, the type of process the controller is working on, and whether tuning is possible we need to decide on what kind of performance is required.
Tuning integrating processes for performance has been covered reasonable thoroughly in PID spotlight part 12 and in PID spotlight part 17. There is a future deep dive coming for self-limiting processes. A preliminary review is available in PID spotlight part 6. The short answer is the published mechanistic tuning methods will not give you perfect performance.
However, if you are less worried about perfection then rest easy. PID controller tuning fortunately usually offers a broad plateau of acceptable tuning for any given process (as long as you don’t have too much deadtime). You should aim for critically damped tuning (as fast as possible to setpoint without overshoot) as this is the best compromise for disturbance rejection without upsetting other parts of the process. It appears that most of the videos use this as their default tuning; use it if it is appropriate.
Select the PID tuning tools you will need
I have found that heuristics is the easiest to teach and deploy. The one major drawback is convincing people they really do have to wait long enough for a proper pattern to develop. One strength of the method is it works regardless of the PID algorithm in use, which makes it ideal for the occasional tuner or if you simply don’t know what PID algorithm your system uses.
If you happen to pursue open loop tuning the simplified internal model control (IMC) method for self-limiting processes works well for all lag/deadtime ratios. It intentionally limits controller gain for high lag/deadtime ratios to prevent unsettlingly large output jumps on a setpoint change. This isn’t ideal for disturbance rejection tuning, but still provides good disturbance rejection.
Similarly the simplified integrating process PI tuning calculations work well for integrating processes. The trick here is deciding on how much deviation from setpoint you are willing to allow. 20-25% is a reasonable limit in the absence of any other guidance.
Of course if you do not know the PID algorithm you may want to stick with heuristics as the open loop methods are specific to the classical PID algorithm (conversion to parallel provided below.)
Execute the PID controller tuning solution
Open loop and heuristic tuning methods with examples for self-limiting processes are laid out in PID spotlight part 7 and PID spotlight part 9 (and part 10) for deadtime dominant processes). Similarly open loop and heuristic methods with examples for integrating processes are laid out in PID spotlight part 15 and PID spotlight part 17. Here is another good heuristic PID tuning guide for self-limiting processes. It is a step-by-step process that sets controller gain, then integral and then derivative (if required) in a stepwise fashion. It will work with classical and parallel PID algorithms. Their “this is what good looks like” pictures will get you close to critically damped tuning.
For the heuristic methods you can leave out much of the math-y bits. These will help you get to an answer faster but the simple larger/smaller controller gain and faster/slower integral adjustment method works well. (You must use the math-y bits for deadtime dominant process tuning, otherwise you might never get to a solution.)
If you are interested in a deeper dive into how the PID controller works you are invited to read the articles on mating the PID controller to each type of process, examples of well and poorly tuned controllers, and the discussion of lag/deadtime or fill time/deadtime ratios. This is not required for the occasional tuner, but may clear up some questions you might have about how the PID controller really works.
(Note: 90% of my tuning is done using heuristics. It’s generally faster, safer and more tolerant of confounding factors like process noise and bad valves.)
Verifying the solution for PID tuning
Of course after tuning a controller you should verify that the controller tuning works. Most of the time a simple setpoint change will suffice. If for some reason you don’t like the response feel free to use heuristic methods to adjust the tuning to match your needs. The important thing to remember in all this is that your controller is probably working within multiple constraints, and that there is going to be some tradeoff among minimizing the impact of disturbances, following setpoint changes, and not disturbing the rest of the process. This is a tradeoff only you can make.
What if this doesn’t get me to a solution?
If you find that no matter what you do the controller continues to behave badly you likely have a bad control valve. PID spotlight part 18 and PID spotlight part 20 have practical guidance on identifying valve problems and what you might do about them. Spoiler alert: bad valves must be fixed. There is a tuning solution, but it is very hazardous and not recommended for the non-expert user.
You may also have a problem with process noise, in which case PID spotlight part 23 will give you help on practical solutions to noise. The short answer is you can’t just filter the living daylights out of the process as this has bad effects on tuning and performance. Once again there are tradeoffs among filtering, PID tuning and controller performance. More background is available in PID spotlight part 21 and PID spotlight part 22.
Finally, if you are working in a process plant, you should read PID spotlight part 19 on controller tuning best practices.
Deadtime is the enemy
Another problem that may plague the occasional tuner is excessive deadtime. For integrating processes excessive deadtime simply makes the process impossible to control. There is no tuning solution to this; a process fix must be pursued. Since this will require real money (beyond just your time and effort), you must be able to justify the expenditure. PID spotlight part 13 explains how excessive deadtime translates into low controller gain which then allows excessive process variable movement for even small disturbances.
Improving the performance of self-limiting processes with too much deadtime may require extraordinary measures. These fall in two categories:
- Preventing disturbances in the first place. This requires a close focus on tuning upstream controllers or possibly process changes.
- Some form of feedforward control that will require new logic and likely new instrumentation.
If you do not feel competent to address this type of issue please consider contacting an expert.
What’s next for this PID controller tuning series?
The basics of tuning generic PID controllers is behind us and with it the beginners part of this series is complete. From here the articles will be getting more technical and focused on more specific problems. Future articles will cover:
- A deep dive into tuning for performance for self-limiting processes.
- A close look at certain advanced features. This will be aimed at how these features are used to solve specific problems from overly aggressive response to setpoint changes, deadtime compensation and noise management to name a few.
- Cascade control; tuning cascades, anti-reset windup and other issues.
- Extraordinary measures: What you can do to work with or around processes with excessive deadtime.
- Tips and tricks for managing controller interaction.
While our focus changes to more advanced subjects the overall goal remains. Purely mechanistic approaches to controller tuning, whether the old reliable Ziegler-Nichols approach, some version of Lambda tuning or any of the other 400+ methods, will not necessarily solve your specific tuning problem. Your toolbox will continue to collect new tools; you can’t solve problems without them. But what I hope to impart is some intuition into how the PID algorithm really works so that you know which tools to use when and, more importantly, when to bend the rules to get the best performance from your controllers.
Converting tuning constants from classical to parallel (and more)
To recap, the classical PID algorithm is:
OP = K *(Error + 1/Ti * ∫Error + Td * d(PV)/dt) + OP(t=0)
The parallel PID algorithm is:
OP = K *Error + Ti * ∫Error + Td * d(PV)/dt + OP(t=0)
The conversion process from classical to parallel “removes” the parenthesis and inverts the integral constant. The calculations are:
Integral:
Ti(Parallel) = K/Ti(Classical)
Derivative:
Td(Parallel) = K * Td(Classical)
Pay careful attention to time units. Seconds and minutes are equally common between systems. This can be a very embarrassing mistake. (Ask me how I know.)
Some controllers use proportional band (PB) instead of controller gain (K). This is common in some single loop controllers and programable logic controllers (PLC) but unusual in distributed control systems (DCS). If you happen to run across proportional band (PB) the conversion is:
PB = 100/K
Note that the conversion to proportional band means that bigger is less controller gain and smaller is more controller gain. Keep this in mind if you are using heuristic tuning methods.
Ed Bullerdiek is a retired control engineer with 37 years of process control experience in petroleum refining and oil production. Edited by Mark T. Hoske, editor-in-chief, Control Engineering, WTWH Media, [email protected].
ONLINE
PID series from Ed Bullerdiek, retired control engineer
PID Spotlight, part 1: Three reasons to tune control loops: Safety, profit, energy efficiency
PID spotlight, part 2: Know these 13 terms, interactions
PID spotlight, part 3: How to select one of four process responses
PID spotlight, part 4: How to balance PID control for a self-limiting process
PID spotlight, part 5: What does good and bad controller tuning look like?
PID spotlight, part 6: Deadtime? How to boost controller performance anyway
PID spotlight, part 7: Open-loop tuning of a self-limiting process
PID spotlight, part 8: Closed-loop tuning for self-limiting processes
PID spotlight, part 9: Heuristic tuning for a self-limiting process (part A on heuristic tuning)
PID spotlight, part 10: Heuristic tuning in a self-limiting process
PID spotlight, part 11: How a PID controller works with an integrating process
PID spotlight, part 12: What does good and bad controller tuning look like?
PID spotlight, part 13: Deadtime: what’s the best that I can do?
PID spotlight, part 14: Open loop tuning of an integrating process
PID spotlight, part 15: Open loop tuning of near integrating processes
PID spotlight, part 16: Closed loop tuning of an integrating process
PID spotlight, part 17: Heuristic tuning of an integrating processes
PID spotlight, part 18: Identifying control valve performance problems
PID spotlight, part 19: PID controller tuning mechanics
PID spotlight, part 20: Tuning with bad valves
PID spotlight, part 21: Noise: Can I tune around it?
PID spotlight, part 22: Can I tune a noisy PID controller?
PID spotlight, part 23: Filtering noise for better PID control
PID spotlight: part 24: How do I tune PID controllers during a new unit startup?
Aug. 1 RCEP webcast available for one year: How to automate series: The mechanics of loop tuning
More on PID and advanced process control from Control Engineering
