Compute step-response characteristics, such as rise time, settling time, and overshoot, for a dynamic system model. For this example, use a continuous-time transfer function:

Create the transfer function and examine its step response.

sys = tf([1 5 5],[1 1.65 5 6.5 2]);
step(sys)

The plot shows that the response rises in a few seconds, and then rings down to a steady-state value of about 2.5. Compute the characteristics of this response using stepinfo.

S = stepinfo(sys)

S = struct with fields:
         RiseTime: 3.8456
    TransientTime: 27.9762
     SettlingTime: 27.9762
      SettlingMin: 2.0689
      SettlingMax: 2.6873
        Overshoot: 7.4915
       Undershoot: 0
             Peak: 2.6873
         PeakTime: 8.0530

Here, the function uses ${\mathit{y}}_{\mathrm{init}}$= 0 to compute characteristics for the dynamic system model sys.

By default, the settling time is the time it takes for the error to stay below 2% of $\left|{\mathit{y}}_{\mathrm{init}}-{\mathit{y}}_{\mathit{final}}\right|$. The result S.SettlingTime shows that for sys, this condition occurs after about 28 seconds. The default definition of rise time is the time it takes for the response to go from 10% to 90% of the way from ${\mathit{y}}_{\mathrm{init}}$= 0 to ${\mathit{y}}_{\mathrm{final}}$. S.RiseTime shows that for sys, this rise occurs in less than 4 seconds. The maximum overshoot is returned in S.Overshoot. For this system, the peak value S.Peak, which occurs at the time S.PeakTime, overshoots by about 7.5% of the steady-state value.

For a MIMO system, stepinfo returns a structure array in which each entry contains the response characteristics of the corresponding I/O channel of the system. For this example, use a two-output, two-input discrete-time system. Compute the step-response characteristics.

A = [0.68 -0.34; 0.34 0.68];
B = [0.18 -0.05; 0.04 0.11];
C = [0 -1.53; -1.12 -1.10];
D = [0 0; 0.06 -0.37];
sys = ss(A,B,C,D,0.2);

S = stepinfo(sys)

S=2×2 struct array with fields:
    RiseTime
    TransientTime
    SettlingTime
    SettlingMin
    SettlingMax
    Overshoot
    Undershoot
    Peak
    PeakTime

Access the response characteristics for a particular I/0 channel by indexing into S. For instance, examine the response characteristics for the response from the first input to the second output of sys, corresponding to S(2,1).

S(2,1)

ans = struct with fields:
         RiseTime: 0.4000
    TransientTime: 2.8000
     SettlingTime: 3
      SettlingMin: -0.6724
      SettlingMax: -0.5188
        Overshoot: 24.6476
       Undershoot: 11.1224
             Peak: 0.6724
         PeakTime: 1

To access a particular value, use dot notation. For instance, extract the rise time of the (2,1) channel.

rt21 = S(2,1).RiseTime

rt21 = 0.4000

You can use SettlingTimeThreshold and RiseTimeThreshold to change the default percentage for settling and rise times, respectively, as described in the Algorithms section. For this example, use the system given by:

Create the transfer function.

sys = tf([1 5 5],[1 1.65 5 6.5 2]);

Compute the time it takes for the error in the response of sys to stay below 0.5% of the gap $|{\mathit{y}}_{\mathrm{final}}-{\mathit{y}}_{\mathrm{init}}|$. To do so, set SettlingTimeThreshold to 0.5%, or 0.005.

S1 = stepinfo(sys,'SettlingTimeThreshold',0.005);
st1 = S1.SettlingTime

st1 = 46.1325

Compute the time it takes the response of sys to rise from 5% to 95% of the way from ${\mathit{y}}_{\mathrm{init}}$ to ${\mathit{y}}_{\mathrm{final}}$. To do so, set RiseTimeThreshold to a vector containing those bounds.

S2 = stepinfo(sys,'RiseTimeThreshold',[0.05 0.95]);
rt2 = S2.RiseTime

rt2 = 4.1690

You can define percentages for both settling time and rise time in the same computation.

S3 = stepinfo(sys,'SettlingTimeThreshold',0.005,'RiseTimeThreshold',[0.05 0.95])

S3 = struct with fields:
         RiseTime: 4.1690
    TransientTime: 46.1325
     SettlingTime: 46.1325
      SettlingMin: 2.0689
      SettlingMax: 2.6873
        Overshoot: 7.4915
       Undershoot: 0
             Peak: 2.6873
         PeakTime: 8.0530

You can extract step-response characteristics from step-response data even if you do not have a model of your system. For instance, suppose you have measured the response of your system to a step input and saved the resulting response data in a vector y of response values at the times stored in another vector t. Load the response data and examine it.

load StepInfoData t y
plot(t,y)

Compute step-response characteristics from this response data using stepinfo. If you do not specify the steady-state response value yfinal, then stepinfo assumes that the last value in the response vector y is the steady-state response. Because the data has some noise, the last value in y is likely not the true steady-state response value. When you know what the steady-state value should be, you can provide it to stepinfo. For this example, suppose that the steady-state response is 2.4.

S1 = stepinfo(y,t,2.4)

S1 = struct with fields:
         RiseTime: 1.2897
    TransientTime: 19.6478
     SettlingTime: 19.6439
      SettlingMin: 2.0219
      SettlingMax: 3.3302
        Overshoot: 38.7575
       Undershoot: 0
             Peak: 3.3302
         PeakTime: 3.4000

Because of the noise in the data, the default definition of the settling time is too stringent, resulting in an arbitrary value of almost 20 seconds. To allow for the noise, increase the settling-time threshold from the default 2% to 5%.

S2 = stepinfo(y,t,2.4,'SettlingTimeThreshold',0.05)

S2 = struct with fields:
         RiseTime: 1.2897
    TransientTime: 10.4201
     SettlingTime: 10.4149
      SettlingMin: 2.0219
      SettlingMax: 3.3302
        Overshoot: 38.7575
       Undershoot: 0
             Peak: 3.3302
         PeakTime: 3.4000

Settling time and transient time are equal when the peak error ${\mathit{e}}_{\max }$ is equal to the gap $|{\mathit{y}}_{\mathrm{final}}-{\mathit{y}}_{\mathrm{init}}|$ (see Algorithms), which is the case for models with no undershoot or feedthrough and with less than 100% overshoot. They tend to differ for models with feedthrough, zeros at the origin, unstable zeros (undershoot), or large overshoot.

Consider the following models.

s = tf('s');
sys1 = 1+tf(1,[1 1]);                        % feedthrough
sys2 = tf([1 0],[1 1]);                      % zero at the origin
sys3 = tf([-3 1],[1 2 1]);                   % non-minimum phase with undershoot
sys4 = (s/0.5 + 1)/(s^2 + 0.2*s + 1);        % large overshoot

step(sys1,sys2,sys3,sys4)
grid on
legend('Feedthrough','Zero at origin','Non-minimum phase with undershoot','Large overshoot')

Compute the step-response characteristics.

S1 = stepinfo(sys1)

S1 = struct with fields:
         RiseTime: 1.6095
    TransientTime: 3.9121
     SettlingTime: 3.2190
      SettlingMin: 1.8005
      SettlingMax: 1.9993
        Overshoot: 0
       Undershoot: 0
             Peak: 1.9993
         PeakTime: 7.3222

S2 = stepinfo(sys2)

S2 = struct with fields:
         RiseTime: 0
    TransientTime: 3.9121
     SettlingTime: NaN
      SettlingMin: 6.6069e-04
      SettlingMax: 1
        Overshoot: Inf
       Undershoot: 0
             Peak: 1
         PeakTime: 0

S3 = stepinfo(sys3)

S3 = struct with fields:
         RiseTime: 2.9198
    TransientTime: 6.5839
     SettlingTime: 7.3229
      SettlingMin: 0.9004
      SettlingMax: 0.9991
        Overshoot: 0
       Undershoot: 88.9466
             Peak: 0.9991
         PeakTime: 10.7900

S4 = stepinfo(sys4)

S4 = struct with fields:
         RiseTime: 0.3896
    TransientTime: 40.3317
     SettlingTime: 46.5052
      SettlingMin: -0.2796
      SettlingMax: 2.7571
        Overshoot: 175.7137
       Undershoot: 27.9629
             Peak: 2.7571
         PeakTime: 1.8850

Examine the plots and characteristics. For these models, the settling time and transient time differ because the peak error exceeds the gap between the initial and the final value. For models such as sys2, the settling time is returned as NaN because the steady-state value is zero.

In this example, you compute the step-response characteristics from step-response data that has an initial offset. This means that the value of the response data is nonzero before the step occurs.

Load the step-response data and examine the plot.

load stepDataOffset.mat
plot(stepOffset.Time,stepOffset.Data)

If you do not specify yfinal and yinit, then stepinfo assumes that yfinal is the last value in the response vector y and yinit is zero. When you know what the steady-state and initial values are, you can provide them to stepinfo. Here, the steady state of the response yfinal is 0.9 and the initial offset yinit is 0.2.

Compute step-response characteristics from this response data.

S = stepinfo(stepOffset.Data,stepOffset.Time,0.9,0.2)

S = struct with fields:
         RiseTime: 0.0084
    TransientTime: 1.0662
     SettlingTime: 1.0662
      SettlingMin: 0.8461
      SettlingMax: 1.0878
        Overshoot: 26.8259
       Undershoot: 0.0429
             Peak: 0.8878
         PeakTime: 1.0225

Here, the peak value of this response is 0.8878 because stepinfo measures the maximum deviation from yinit.