Hello,

I'm simulating a basic PID control system in excel. I've got Proportional and Integral action working fine, but when I add in Derivative action, it doesn't seem to follow the form expected.

As I understand it, Derivative action reduces overshoot and shortens settling time (with appropriate tuning of P and I), but I am finding that Derivative action increases overshoot and settling time, eventually sending my system into oscillation.

Given the basic PID formula of:

Pout = Kp.e + Ki.{integral}e(t) + Kd.(de/Dt)

I can't see how the derivative component could achieve this "damping" effect in any case, as surely, as the rate of change of e increases, so Kd.(de/Dt) also increases, throwing the system out of control.

If somebody could explain this to me, I would be very grateful.

Many thanks,

Paul

I'm simulating a basic PID control system in excel. I've got Proportional and Integral action working fine, but when I add in Derivative action, it doesn't seem to follow the form expected.

As I understand it, Derivative action reduces overshoot and shortens settling time (with appropriate tuning of P and I), but I am finding that Derivative action increases overshoot and settling time, eventually sending my system into oscillation.

Given the basic PID formula of:

Pout = Kp.e + Ki.{integral}e(t) + Kd.(de/Dt)

I can't see how the derivative component could achieve this "damping" effect in any case, as surely, as the rate of change of e increases, so Kd.(de/Dt) also increases, throwing the system out of control.

If somebody could explain this to me, I would be very grateful.

Many thanks,

Paul

The key isssue here is properly tuned PID controller. If you're having increased oscillations that means you have gone too far with changing derivative time constant. With derivations you must be very careful. First of all, you should try to implement derivative action on process variable (not the actual error) if possible in order to avoid so called "derivative kick" that can happen if there is suddenly change in setpoint.

On the other hand, derivative action will practically multiply noise. So, if you want to correct tune your controller, first implement proper filter that will remove noise (process and measurement) from proces variable signal.

It is true that derivative action (if all above is fulfilled) will reduce oscillations.

Oscialltions can often be caused by too high gain or even too strong integral componentm becase I part of controller is effectively summing error. D part can reduce oscillations, but only if you're doing it properly. Increasing derivative gain (time constant) beyond optimal limits will increase oscillations (you're increasing overall gain).

On the other hand, derivative action will practically multiply noise. So, if you want to correct tune your controller, first implement proper filter that will remove noise (process and measurement) from proces variable signal.

It is true that derivative action (if all above is fulfilled) will reduce oscillations.

Oscialltions can often be caused by too high gain or even too strong integral componentm becase I part of controller is effectively summing error. D part can reduce oscillations, but only if you're doing it properly. Increasing derivative gain (time constant) beyond optimal limits will increase oscillations (you're increasing overall gain).

Math aside for a moment. The derivative action must operate in the direction to increase the corrective action of the loop.

For example in a temperature loop, it the PV (temperature) is falling rapidly, the error is increasing at the same rate and the derivative term needs to increase the heat being added.

The idea is while the error is getting worse, the controlling action is increased. The algorithm. If the derivative of PV is used rather than e=SP-PV - then step change to the SP does not result in high loop output.

I think too high a derivative gain tends to increase the overshoot and reduce the response time. It boosts the loop gain while the PV is changing. High gain tends to overshoot.

For example in a temperature loop, it the PV (temperature) is falling rapidly, the error is increasing at the same rate and the derivative term needs to increase the heat being added.

The idea is while the error is getting worse, the controlling action is increased. The algorithm. If the derivative of PV is used rather than e=SP-PV - then step change to the SP does not result in high loop output.

I think too high a derivative gain tends to increase the overshoot and reduce the response time. It boosts the loop gain while the PV is changing. High gain tends to overshoot.

Not always. If the temperature is below the setpoint but rising fast, then the derivative term acts to reduce the corrective action. That is, it acts in opposition to raising the temperature. The effect is to slow down the approach to the setpoint so that it does not overshoot too much. In general, derivative action acts to oppose change.

Robert Scott

Real-Time Specialties

Robert Scott

Real-Time Specialties

the basic thing for you to understand derivative control is it will not reduce the oscilations. infact it will increase oscillations.

for ex: derivative for a step signal is an impulse siganl in step signal amplitude is defined but in impulse the amplitude is ideally infinite so it will give controller output to 100% within no time. so the out put will be over shooted.

that is abt oscilations in derivative control

when it comes to settling time it depends not only on derivative time constant but also on integral time so you have to carefully finetune between them with minimum values

for ex: derivative for a step signal is an impulse siganl in step signal amplitude is defined but in impulse the amplitude is ideally infinite so it will give controller output to 100% within no time. so the out put will be over shooted.

that is abt oscilations in derivative control

when it comes to settling time it depends not only on derivative time constant but also on integral time so you have to carefully finetune between them with minimum values

No, with properly tuned controller, derivation action will reduce oscillation as described earlier.

Paul,

If your PI controller is somewhat heavy on the P-action but still shows reasonable response to a setpoint change and you add (sufficiently strong) D-action, then you certainly will see an overshoot - or increase thereof.

On the positive side: D-action reduces the tendency of the I-controller to swing. Thus if you manage to get a fast response with a PI, but still with some swings around the SP then adding D-action will minimize or even eliminate them. Important in all cases is the proper dosage of the D-action.

Best recommendation is thus to get the process parameters and calculate the PID tuning – with the right tool and reasonable process data a matter of minutes.

We cover this topic quite intensively in our training courses, also with exercises. If you send me your e-mail address I will be happy to forward you the handout with the results.

Hans H. Eder

hans.eder@act-control.com

www.act-control.com

If your PI controller is somewhat heavy on the P-action but still shows reasonable response to a setpoint change and you add (sufficiently strong) D-action, then you certainly will see an overshoot - or increase thereof.

On the positive side: D-action reduces the tendency of the I-controller to swing. Thus if you manage to get a fast response with a PI, but still with some swings around the SP then adding D-action will minimize or even eliminate them. Important in all cases is the proper dosage of the D-action.

Best recommendation is thus to get the process parameters and calculate the PID tuning – with the right tool and reasonable process data a matter of minutes.

We cover this topic quite intensively in our training courses, also with exercises. If you send me your e-mail address I will be happy to forward you the handout with the results.

Hans H. Eder

hans.eder@act-control.com

www.act-control.com

Like I said before, it is very important to get rid of the noise by using appropriate filter. Derivator can do harm to your control loop if applied to noisy process value. Do you know what is derivation of step change? Derivation on sudden changes cause very large spikes...

>As I understand it, Derivative action

>reduces overshoot <

Yes, in theory the derivative term adds damping.

> and shortens settling

>time (with appropriate tuning of P and

>I), <

That depends. Obviously if there is too much damping the system will take longer to reach the set point.

> but I am finding that Derivative

>action increases overshoot and settling

>time, <

It really is the derivative action. It is the lack of ability to calculate the true d/dt(PV). This is caused by low resolution feed back, aperiodic sampling etc and process noise. The first two items are usually the main culprits.

>Given the basic PID formula of:

>

>Pout = Kp.e + Ki.{integral}e(t) +

>Kd.(de/Dt)

>

>I can't see how the derivative

>component could achieve this "damping"

>effect in any case, as surely, as the

>rate of change of e increases, so

>Kd.(de/Dt) also increases, throwing the

>system out of control. <

That is because you haven't done the math. If you have a transfer function for the controller

Gc(s)=Kp+Ki/s+Kd*s

and for the plant

Gp(s)=K/(t1*s+1)(t2*s+1) then the closed loop transfer function (CLTF) is:

T(s)=(Gc(s)*Gp(s))/(1+Gc(s)*Gp(s))

Work that out symbolically and you will see how the gains interact. Actually what they really do is help you place the poles of the CLTF's characteristic equation. You can then adjust the controller gains to bring the poles close to the negative real axis. You can then increase the gains more by moving the poles to the left on the negative real axis to get a faster response.

The plant I used as an example is simple. If it had another pole then the controller would need yet another gain to place all the poles properly.

The problem is that most people look at the gains individually and say this gain to this and that gain does that. This view is not the best view. Instead you should be looking at the math and where the closed poles are and then calculating the gains to place the poles in the desired location to provide the desired response.

Here is an example of you one calculates controller gains given you know what the plant transfer function is

(%i1) Gp: K/((t1*s+1)*(t2*s+1)); /* System transfer function (%o1) K/((s*t1+1)*(s*t2+1))

*/

Gc: Ki/s+Kp+Kd*s; /* Simple PID controller */

(%o2) Kd*s+Ki/s+Kp

CLTF: (Gc*Gp)/(1+Gc*Gp); /* Closed loop transfer function */

(%o3) ((Kd*s+Ki/s+Kp)*K)/((s*t1+1)*(s*t2+1)*(((Kd*s+Ki/s+Kp)*K)/((s*t1+1)*(s *t2+1))+1))

CE: expand(denom(ratsimp(CLTF))); /* Characteristic equation */

(%o4) Kd*s^2*K+Kp*s*K+Ki*K+s^3*t1*t2+s^2*t2+s^2*t1+s

DIFCE: expand(CE-(s+lambda)^3); /* desire three poles at -lambda */

Ki: solve(coeff(DIFCE,s,0),Ki);

Kp: solve(coeff(DIFCE,s,1),Kp);

Kd: solve(coeff(DIFCE,s,2),Kd);

grind(Ki,Kp,Kd);

(%o5) -lambda^3-3*s*lambda^2-3*s^2*lambda+Kd*s^2*K+Kp*s*K+Ki*K+s^3*t1*t2+s^2 *t2+s^2*t1-s^3+s

(%o6) [Ki=lambda^3/K]

(%o7) [Kp=(3*lambda^2-1)/K]

(%o8) [Kd=(3*lambda-t2-t1)/K][Ki = lambda^3/K]$[Kp = (3*lambda^2-1)/K]$[Kd = (3*lambda-t2-t1)/K]

$(%o9) done(%i10)

I generated this using Maxima. If you take time to straighten out the formating you will see that there are three poles. Two from the plant and one from the controller integrator. If the system is to be critically damped then the characteristic equation coefficients will have a binomial pattern like 1 3 3 1 for three pole systems and 1 2 1 for two pole systems. of course the closed loop time constant must be factored in so the response it (tc*s)^3+3*(tc*s)^2+3*(tc*s)+1

Now if you look carefully you will see that Kd is in the s^2. If Kd is too small then the response is under damped and if it is too big the response is over damped.

>reduces overshoot <

Yes, in theory the derivative term adds damping.

> and shortens settling

>time (with appropriate tuning of P and

>I), <

That depends. Obviously if there is too much damping the system will take longer to reach the set point.

> but I am finding that Derivative

>action increases overshoot and settling

>time, <

It really is the derivative action. It is the lack of ability to calculate the true d/dt(PV). This is caused by low resolution feed back, aperiodic sampling etc and process noise. The first two items are usually the main culprits.

>Given the basic PID formula of:

>

>Pout = Kp.e + Ki.{integral}e(t) +

>Kd.(de/Dt)

>

>I can't see how the derivative

>component could achieve this "damping"

>effect in any case, as surely, as the

>rate of change of e increases, so

>Kd.(de/Dt) also increases, throwing the

>system out of control. <

That is because you haven't done the math. If you have a transfer function for the controller

Gc(s)=Kp+Ki/s+Kd*s

and for the plant

Gp(s)=K/(t1*s+1)(t2*s+1) then the closed loop transfer function (CLTF) is:

T(s)=(Gc(s)*Gp(s))/(1+Gc(s)*Gp(s))

Work that out symbolically and you will see how the gains interact. Actually what they really do is help you place the poles of the CLTF's characteristic equation. You can then adjust the controller gains to bring the poles close to the negative real axis. You can then increase the gains more by moving the poles to the left on the negative real axis to get a faster response.

The plant I used as an example is simple. If it had another pole then the controller would need yet another gain to place all the poles properly.

The problem is that most people look at the gains individually and say this gain to this and that gain does that. This view is not the best view. Instead you should be looking at the math and where the closed poles are and then calculating the gains to place the poles in the desired location to provide the desired response.

Here is an example of you one calculates controller gains given you know what the plant transfer function is

(%i1) Gp: K/((t1*s+1)*(t2*s+1)); /* System transfer function (%o1) K/((s*t1+1)*(s*t2+1))

*/

Gc: Ki/s+Kp+Kd*s; /* Simple PID controller */

(%o2) Kd*s+Ki/s+Kp

CLTF: (Gc*Gp)/(1+Gc*Gp); /* Closed loop transfer function */

(%o3) ((Kd*s+Ki/s+Kp)*K)/((s*t1+1)*(s*t2+1)*(((Kd*s+Ki/s+Kp)*K)/((s*t1+1)*(s *t2+1))+1))

CE: expand(denom(ratsimp(CLTF))); /* Characteristic equation */

(%o4) Kd*s^2*K+Kp*s*K+Ki*K+s^3*t1*t2+s^2*t2+s^2*t1+s

DIFCE: expand(CE-(s+lambda)^3); /* desire three poles at -lambda */

Ki: solve(coeff(DIFCE,s,0),Ki);

Kp: solve(coeff(DIFCE,s,1),Kp);

Kd: solve(coeff(DIFCE,s,2),Kd);

grind(Ki,Kp,Kd);

(%o5) -lambda^3-3*s*lambda^2-3*s^2*lambda+Kd*s^2*K+Kp*s*K+Ki*K+s^3*t1*t2+s^2 *t2+s^2*t1-s^3+s

(%o6) [Ki=lambda^3/K]

(%o7) [Kp=(3*lambda^2-1)/K]

(%o8) [Kd=(3*lambda-t2-t1)/K][Ki = lambda^3/K]$[Kp = (3*lambda^2-1)/K]$[Kd = (3*lambda-t2-t1)/K]

$(%o9) done(%i10)

I generated this using Maxima. If you take time to straighten out the formating you will see that there are three poles. Two from the plant and one from the controller integrator. If the system is to be critically damped then the characteristic equation coefficients will have a binomial pattern like 1 3 3 1 for three pole systems and 1 2 1 for two pole systems. of course the closed loop time constant must be factored in so the response it (tc*s)^3+3*(tc*s)^2+3*(tc*s)+1

Now if you look carefully you will see that Kd is in the s^2. If Kd is too small then the response is under damped and if it is too big the response is over damped.

Your use of this site is subject to the terms and conditions set forth under Legal Notices and the Privacy Policy. Please read those terms and conditions carefully. Subject to the rights expressly reserved to others under Legal Notices, the content of this site and the compilation thereof is © 1999-2014 Nerds in Control, LLC. All rights reserved.

Users of this site are benefiting from open source technologies, including PHP, MySQL and Apache. Be happy.

**Fortune**

Johnson's First Law:

When any mechanical contrivance fails, it will do so at the

most inconvenient possible time.