GNC Tools

The examples below can be found in Control/PID/PID_Examples.m in GNCTools.

Manual Tuning

Most of us at one time or another have attempted to tune a PID controller 'by hand' (i.e. manually). We might be in a rush, or simply haven't spent the time to develop a model of the system we're trying to control and thus can't use automated methods. If you are faced with this situation, then this table is a good reference, reproduced below which describes the effect of increasing each gain independently:

Remember the table above is for changing any parameter independently, and is only a generalization. It should be used as a guide only, and a more rigorous modelling and analysis approach used instead where time allows.

First Order Modelling

As a control engineer, investing in a model is always a worthwhile exercise as it provides insight into the operation of the system, together with the ability to perform stability analysis and automated tuning. However deriving a detailed, physics-based model (i.e. white or grey box) can be very time intensive and require specialized knowledge outside your technical domain. Therefore if your plant/process is open loop stable (i.e. a judicially chosen constant input won't damage the system or make it unstable), then a common first order approximation is a First Order Plus Dead Time (FOPDT) model, which is a simple black box/empirical model:

⚠ $G(s) = \frac{K e^{-\theta s}}{\tau s + 1}$

where K is the process gain, ⚠ $\tau$ is the process (first order) time constant, and ⚠ $\theta$ is the process time delay (dead time).

The nice thing about this model is that it captures most dynamics of reasonably damped systems (e.g. ⚠ $\zeta > 0.8$) that are required to obtain good enough control with a PID controller. To illustrate, we're going to use a new second order plant model to generate some "real data" that captures a step test of the system. We will then use this data to fit a FOPDT model, and then use the fitted model for tuning our controller. To begin, the "true" plant we will be modelling and controlling:

As above, the response is obviously second order (or higher) from the "S-shape" of the curve, together with the overshoot. We will use this model to generate some interesting measurement data, from some simulated step tests of it:

Note the above step tests are pretty basic, and you may find you need more over the operating range of your plant to characterize its behaviour. Always try and do step tests in both directions, and near the typical operating point. Next, we will attempt to fit a FOPDT model to this data. We can estimate graphically the initial parameters guesses for the optimizer, by simply looking at the plot:

K

Input of 1 results in a output of 6; gain is ~6

⚠ $\theta$

The system takes approximately 0.5 seconds to begin to move; ⚠ $\theta$ is ~0.5 s.

⚠ $\tau$

The system reaches 1 time constant (63.2% of the final value) after approximately 2.75 seconds; removing dead time ⚠ $\tau$ is ~2.25.

The result of the above (simple, naive) example fitting routine is as follows:

Showing our initial guesses weren't too far off, and the optimizer has found a solution that approximates the plant response quite well. We now have a model of our plant we can use for more powerful tuning methods and analysis!

Automated Tuning

Once you have a model of the plant you are trying to control, you can use the powerful tuning algorithms included with MATLAB's Control Systems Toolbox. While the literature is rich with tuning methods and algorithms, MATLAB has done a pretty good job of getting their tuning routines robust and effective. My favourite is pidtune (and associated GUI, pidTuner), which we will use below.

First, discretize our fitted FOPDT model at the sampling rate we want our controller to run at, then tune a 2DOF PID controller with a crossover frequency of 1 rad/s:

this results in the following PID controller:

You can see MATLAB has tuned all parameters for us (including the derivative filter Time Constant and Setpoint Weights), and returned a pid2 object. We can simulate this controller with our fitted FOPDT model to see what response MATLAB has designed for us:

Which is not too bad. We could adjust the crossover frequency to obtain faster or slower responses, or modify the gains manually if we want to fine tune it. With the magic of simulation, we can also check what would happen if we were to use this PID controller with the true plant, and actually implement it:

As our FOPDT model was a good approximation of the true system, the controller that MATLAB designed does well controlling the true plant as well. I recommend experimenting with the pidTuner GUI for more control of the MATLAB designed controller as well.

Note more information on the frequency domain is provided in the Stability Guide, but roughly the crossover frequency from MATLAB's help is:

Second Order Modelling

If you have a system that exhibits significant overshoot (i.e. is quite underdamped) then a FOPDT model will typically not capture the dynamics correctly, and the above method won't work. In this case using a higher order model can be used, but noting fitting these is much more difficult. The classic second order system with dead time is:

⚠ $G(s) = K e^{-\theta s} \frac{\omega^2_n}{s^2 + 2 \zeta \omega_n s + \omega^2_n}$

where K is the process gain, ⚠ $\omega_n$ is the undamped natural frequency (frequency the system would oscillate at with no damping), ⚠ $\zeta$ is the damping ratio and ⚠ $\theta$ is the process time delay (dead time).

As above, we'll create a sample second order system to generate some interesting data, and try fit it and design a controller for it:

and generate some measurement data to fit in the same way as for the FOPDT example, resulting in:

With a SOPDT model, there are now four parameters to fit and each requires an initial guess (which can be done graphically):

K

Input of 1 results in a output of 2.5; estimate gain as ~2.5

⚠ $\omega_n$

Time between first two peaks is ~6s; estimate ⚠ $\omega_n$ as ~1 rad/s (1/6*2*pi)

⚠ $\zeta$

Looks quite underdamped; estimate ⚠ $\zeta$ as ~0.5.

⚠ $\theta$

The system takes approximately 0.3s to begin to move; estimate ⚠ $\theta$ as ~0.3 s.

The result of the above (simple, naive) example fitting routine is as follows:

Given we a fitting a model with the same model structure and number of parameters, together with a good starting guess, we should expect a pretty good result, which is shown above. The deviation between estimated and true parameters lies predominately in the measurement noise, which could be filtered if desired. We can then use the same pidtune routine to tune a 2DOF PID controller, and simulate the closed loop response:

this results in the following PID controller:

Occam's Razor

You may be tempted to keep increasing the model order, or adding more parameters to your models in order to "better" fit your measurement data, however a well-known principle in many fields is that of Occam's Razor. Summarizing, it basically means to always prefer the simplest solution, or in our case, the model with the least number of parameters that is "good enough" for the purposes of the model. As an example, if your plant data shows an overdamped (or critically damped) response - why try to fit a second order model to it? You may find a FOPDT fit is perfectly adequate for the purposes of controller tuning, and reduces the number of parameters to guess and fit.

Be judicial in choosing model order, and modelling in general. A spline or high order polynomial might "look better", but you may also find a quadratic performs just as well.