How Approximate Model FOPDT

Hi, I have a problem.

My G(s)=7/(s^2+7), so is a 2 order undumped. I need to approximate it in a FOPDT , How i can? Thanks to everyone.

Answer 1

[akshatsood]

Hi @LORIS IACOBAN,

To approximate a second-order undamped system with a First Order Plus Dead Time (FOPDT) model, you shall aim to find an equivalent system that captures the essential dynamics of the original system with a simpler representation. The FOPDT model is given by: where K is the process gain, is time constant and, θ is dead time.

As stated in the question, your system is repereseted as: . This is a second-order system without damping as does not have a term (where ξ is the damping ratio and is the natural frequency). The natural frequency is in your case.

You can consider the following steps to approximate to FOPDT

Identify Key Characteristics - For the original system, identify characteristics like the time to reach first peak, settling time, or steady-state gain. For a second-order undamped system, the steady-state gain is the coefficient of the transfer function, which is 7 in this case.

Approximate Parameters

Gain (K) : The gain of the FOPDT model should match the steady-state gain of the original system. Thus, .

Time Constant (τ) : The time constant should represent the time it takes for the system to reach a significant portion of its final value. For a second-order undamped system, you might use the time it takes to reach the first peak or some empirical methods for estimation.

Dead Time (θ): This could represent the delay before the system starts responding. For systems without an explicit delay, this might be approximated as a fraction of time constant or based on system's response characteristics.

Approximation Method

A generic approach aimed towards approximating involves comparing step response of original system to that of FOPDT model and adjusting τ and θ to match key features of the response, such as the time to reach first peak or the half-rise time. However, for a purely undamped second-order system, there is no perfect match because the original system oscillates indefinitely while the FOPDT system does not.

Given lack of a standard method for directly converting a second-order undamped system to FOPDT, consider using empirical methods or judgment based on the system's step response, you might consider the following :

1. Estimate τ based on when the system reaches a significant portion of its steady-state value for the first time.
2. θ is based on when the system output first starts to rise, but for an undamped second-order system (as in your case), this is effectively zero.

As a footnote, this approach is highly approximate and relies on matching key characteristics rather than a direct mathematical transformation. For precise transformation, consider using simulations to iteratively adjust τ and θ until the FOPDT model's response closely aligns with that of the original system.

I hope this helps.

Answer 2

[Sam Chak]

Hi @LORIS IACOBAN

Considering that the open-loop model lacks the characteristic S-shaped process reaction curve and exhibits oscillations, you can employ whatever suitable manipulation technique to close the loop and transform it into a First-Order Plus Time Delay (FOPDT) model. Once that is achieved, you can utilize the Ziegler-Nichols Tuning method with the help of Dr. Yi Cao's 'ReactionCurve()' code, which can be downloaded from the File Exchange using the following link:

https://www.mathworks.com/matlabcentral/fileexchange/16661-learning-pid-tuning-i-process-reaction-curve

Gp  = tf(7, [1 0 7])            % Process model, Gp

Gp =
 
     7
  -------
  s^2 + 7
 
Continuous-time transfer function.

Ts  = 1.5;                      % desired Settling Time
kp  =-0.25;
ki  = 1.94464386024797;
kd  = 0.309945826765284;
N   = 7.77857544099188;         % bandwidth of derivative filter
Gc  = pid(kp, ki, kd, 1/N)      % PID controller (for manipulation purposes)

Gc =
 
             1            s    
  Kp + Ki * --- + Kd * --------
             s          Tf*s+1 

  with Kp = -0.25, Ki = 1.94, Kd = 0.31, Tf = 0.129
 
Continuous-time PIDF controller in parallel form.

Gcl = feedback(Gc*Gp, 1);       % Closed-loop system, Gcl (that looks like FOPDT)
S   = stepinfo(Gcl);

figure(1)
step(Gp,  2*Ts), hold on
step(Gcl, 2*Ts), grid on, hold off
xline(S.SettlingTime, '--', sprintf('Settling Time: %.4f sec', S.SettlingTime), 'color', '#265EF5', 'LabelVerticalAlignment', 'bottom')
legend('Open-loop Gp', 'Closed-loop Gcl', '')

figure(2)
[y, t]  = step(Gcl, 3);
[model, controller] = ReactionCurve(t, y);
T       = feedback(Gcl*controller.PID, 1);
step(T, 3), grid on, hold off

function [model, controller] = ReactionCurve(t, y, u)
    ...
end

[Tamir Friedrich]

Thanks, can you convert the above to a discrete implementation?