step

Risposta al gradino di un sistema dinamico

Sintassi

[y,tOut] = step(sys)

[y,tOut] = step(sys,t)

[y,tOut] = step(sys,t,p)

[y,tOut,x] = step(___)

[y,tOut,x,ysd] = step(___)

[y,tOut,x,~,pOut] = step(sys,t,p)

[y,tOut] = step(___,config)

step(___)

Descrizione

step calcola la risposta al gradino a fronte di una variazione a gradino del valore di input da U a U + dU dopo t_d unità di tempo.

In questo caso,

• t₀ è il tempo di inizio della simulazione.

• t_d è il ritardo del gradino.

• U è il valore di input di base o bias.

• dU è l'ampiezza del gradino.

Per impostazione predefinita, la funzione applica il gradino per t₀ = 0, U = 0, dU = 1 e t_d = 0. Tuttavia, è possibile configurare questi valori utilizzando RespConfig. È inoltre possibile specificare lo stato iniziale x(t₀). Quando non si specifica lo stato iniziale, step presume che il sistema sia inizialmente a riposo con livello di input U.

[y,tOut] = step(sys) calcola la risposta al gradino y del sistema dinamico sys. step determina automaticamente i passi temporali e la durata della simulazione in base alla dinamica del sistema.

[y,tOut] = step(sys,t) simula la risposta per i passi temporali specificati da t. Per definire i passi temporali, è possibile specificare:

• Il tempo di simulazione finale utilizzando un valore scalare.

• I tempi di simulazione iniziale e finale utilizzando un vettore a due elementi. (da R2023b)

• Tutti i passi temporali utilizzando un vettore.

[y,tOut] = step(sys,t,p) specifica la traiettoria del parametro p per i modelli lineari a parametri varianti (LPV). (da R2023a)

[y,tOut,x] = step(___) restituisce inoltre le traiettorie di stato x, quando sys è un modello stato-spazio, come un modello ss o idss.

[y,tOut,x,ysd] = step(___) restituisce la deviazione standard della risposta a gradino per i modelli identificati. Per questa sintassi è necessario disporre del software System Identification Toolbox™.

[y,tOut,x,~,pOut] = step(sys,t,p) restituisce le traiettorie dei parametri per i modelli LPV. (da R2023a)

[y,tOut] = step(___,config) specifica ulteriori opzioni per il calcolo della risposta al gradino, come l'ampiezza del gradino o l'offset dell'input. Utilizzare RespConfig per creare config.

step(___) traccia la risposta al gradino di sys con le opzioni di plottaggio predefinite per tutte le combinazioni di argomenti di input precedenti. Per ulteriori opzioni di personalizzazione dei grafici, utilizzare stepplot.

• Per tracciare le risposte di più sistemi dinamici sullo stesso grafico, è possibile specificare sys come un elenco di modelli separati da virgole. Ad esempio, step(sys1,sys2,sys3) traccia le risposte di tre modelli sullo stesso grafico.

• Per specificare un colore, uno stile della linea e un marcatore per ogni sistema nel grafico, specificare un valore LineSpec per ciascun sistema. Ad esempio, step(sys1,LineSpec1,sys2,LineSpec2) traccia due modelli e ne specifica lo stile di plottaggio. Per ulteriori informazioni sulla specifica di un valore LineSpec, vedere stepplot.

Esempi

Risposta al gradino di un sistema dinamico

Tracciare la risposta al gradino di un sistema a tempo continuo rappresentato dalla seguente funzione di trasferimento.

$$\mathrm{sys}\left(\mathit{s}\right)=\frac{4}{{\mathit{s}}^2+2\mathit{s}+10}.$$

Per questo esempio, creare un modello tf che rappresenti la funzione di trasferimento. È possibile tracciare in modo analogo la risposta al gradino di altri tipi di modelli di sistemi dinamici, come i modelli a guadagno zero-poli (zpk) o i modelli stato-spazio (ss).

sys = tf(4,[1 2 10]);

Tracciare la risposta al gradino.

step(sys)

Il grafico step include automaticamente una linea orizzontale tratteggiata che indica la risposta allo stato stazionario. In una finestra di figura di MATLAB®, è possibile fare clic con il tasto destro del mouse sul grafico per visualizzare altre caratteristiche di risposta al gradino, come la risposta di picco e il tempo di assestamento. Per ulteriori informazioni su queste caratteristiche, vedere stepinfo.

Risposta al gradino di un sistema a tempo discreto

Tracciare la risposta al gradino di un sistema a tempo discreto. Il sistema ha un tempo di campionamento di 0,2 s ed è rappresentato dalle seguenti matrici stato-spazio.

A = [1.6 -0.7;
      1  0];
B = [0.5; 0];
C = [0.1 0.1];
D = 0;

Creare il modello stato-spazio e tracciarne la risposta al gradino.

sys = ss(A,B,C,D,0.2);
step(sys)

La risposta al gradino riflette la discretizzazione del modello, mostrando la risposta calcolata ogni 0,2 secondi.

Risposta al gradino in momenti specifici

Esaminare la risposta al gradino della seguente funzione di trasferimento.

sys = zpk(-1,[-0.2+3j,-0.2-3j],1) * tf([1 1],[1 0.05]) 

sys =
 
            (s+1)^2
  ----------------------------
  (s+0.05) (s^2 + 0.4s + 9.04)
 
Continuous-time zero/pole/gain model.
Model Properties

step(sys)

Per impostazione predefinita, step sceglie un tempo finale che mostra lo stato stazionario verso cui tende la risposta. Questo sistema presenta tuttavia transitori rapidi che sono oscurati su questa scala temporale. Per osservare più da vicino la risposta transitoria, limitare il grafico a gradino a t = 15 s.

step(sys,15)

In alternativa, è possibile specificare gli istanti esatti in cui si desidera esaminare la risposta al gradino, purché siano separati da un intervallo costante. Ad esempio, osservare la risposta dalla fine del transitorio fino a quando il sistema raggiunge lo stato stazionario.

t = 20:0.2:120;
step(sys,t)

Anche se questo grafico inizia a t = 20, step applica sempre l'input a gradino a t = 0.

Grafico della risposta al gradino dei sistemi MIMO

Si consideri il seguente modello stato-spazio di secondo ordine:

$$\begin{array}{l}\left[\begin{array}{c}{\underset{}{\overset{\dot{}}{x}}}_1\\ {\underset{}{\overset{\dot{}}{x}}}_2\end{array}\right]=\left[\begin{array}{cc}-0.5572& -0.7814\\ 0.7814& 0\end{array}\right]\left[\begin{array}{c}{x}_1\\ x_2\end{array}\right]+\left[\begin{array}{cc}1& -1\\ 0& 2\end{array}\right]\left[\begin{array}{c}{u}_1\\ u_2\end{array}\right]\\ y=\left[\begin{array}{cc}1.9691& 6.4493\end{array}\right]\left[\begin{array}{c}{x}_1\\ x_2\end{array}\right]\end{array}$$

A = [-0.5572,-0.7814;0.7814,0];
B = [1,-1;0,2];
C = [1.9691,6.4493];
sys = ss(A,B,C,0);

Questo modello presenta due input e un output, quindi ha due canali: dal primo input all'output e dal secondo input all'output. Ogni canale ha la propria risposta al gradino.

Quando si utilizza step, vengono calcolate le risposte di tutti i canali.

step(sys)

Il grafico a sinistra mostra la risposta al gradino del primo canale di input, mentre quello a destra mostra la risposta al gradino del secondo canale di input. Ogni volta che si utilizza step per tracciare le risposte di un modello MIMO, questo genera un array di grafici che rappresentano tutti i canali I/O del modello. Ad esempio, creare un modello stato-spazio casuale con cinque stati, tre input e due output e tracciarne la risposta al gradino.

sys = rss(5,2,3);
step(sys)

In una finestra di figura di MATLAB, è possibile limitare il grafico a un sottoinsieme di canali facendo clic con il tasto destro del mouse sul grafico e selezionando I/O Selector (Selettore I/O).

Confronto delle risposte di più sistemi

step consente di tracciare le risposte di più sistemi dinamici sullo stesso asse. Ad esempio, confrontate la risposta a loop chiuso di un sistema con un controller PI e un controller PID. Creare una funzione di trasferimento del sistema e sincronizzare i controller.

H = tf(4,[1 2 10]);
C1 = pidtune(H,'PI');
C2 = pidtune(H,'PID');

Costruire i sistemi a loop chiuso e tracciare le loro risposte al gradino.

sys1 = feedback(H*C1,1);
sys2 = feedback(H*C2,1);
step(sys1,sys2)
legend('PI','PID','Location','SouthEast')

Per impostazione predefinita, step sceglie colori distinti per ogni sistema che si traccia. È possibile specificare i colori e gli stili di linea utilizzando l'argomento di input LineSpec.

 step(sys1,'r--',sys2,'b')
 legend('PI','PID','Location','SouthEast')

Il primo LineSpec 'r--' specifica una linea rossa tratteggiata per la risposta con il controller PI. Il secondo LineSpec 'b' specifica una linea blu continua per la risposta con il controller PID. La legenda riflette i colori e gli stili di linea specificati. Per ulteriori opzioni di personalizzazione dei grafici, utilizzare stepplot.

Risposta al gradino dei sistemi in un array del modello

L'esempio precedente, confronto delle risposte di più sistemi, mostra come tracciare le risposte di diversi sistemi individuali su un singolo asse. Quando sono presenti più sistemi dinamici disposti in un array del modello, step traccia tutte le loro risposte contemporaneamente.

Creare un array del modello. Per questo esempio, utilizzare un array monodimensionale di funzioni di trasferimento del secondo ordine che presentano frequenze naturali diverse. Innanzitutto, preassegnare la memoria per l'array del modello. Il comando seguente crea una riga 1x5 di funzioni di trasferimento SISO a guadagno zero. Le prime due dimensioni rappresentano gli output e gli input del modello. Le restanti dimensioni sono le dimensioni dell'array.

 sys = tf(zeros(1,1,1,5));

Popolare l'array.

w0 = 1.5:1:5.5;    % natural frequencies
zeta = 0.5;        % damping constant
for i = 1:length(w0)
   sys(:,:,1,i) = tf(w0(i)^2,[1 2*zeta*w0(i) w0(i)^2]);
end

(Per ulteriori informazioni sugli array del modello e su come crearli, vedere Model Arrays.) Tracciare le risposte al gradino di tutti i modelli nell'array.

step(sys)

step utilizza lo stesso stile di linea per le risposte di tutte le voci dell'array. Un modo per distinguere le voci è l'utilizzo della proprietà SamplingGrid dei modelli di sistemi dinamici per associare ogni voce dell'array al valore w0 corrispondente.

sys.SamplingGrid = struct('frequency',w0);

Ora, quando si tracciano le risposte in una finestra di figura di MATLAB, è possibile fare clic su una traccia per vedere a quale valore di frequenza corrisponde.

Dati della risposta al gradino

Quando si assegna un argomento di output, step restituisce un array dei dati della risposta. Per un sistema SISO, i dati della risposta vengono restituiti come vettore colonna di lunghezza pari al numero di punti temporali in cui la risposta viene campionata. È possibile fornire il vettore t dei punti temporali o lasciare che step selezioni i punti temporali in base alla dinamica del sistema. Ad esempio, estrarre la risposta al gradino di un sistema SISO in 101 punti temporali compresi tra t = 0 e t = 5 s.

sys = tf(4,[1 2 10]);
t = 0:0.05:5;
y = step(sys,t);
size(y)

ans = 1×2

   101     1

Per un sistema MIMO, i dati della risposta vengono restituiti in un array di dimensioni N x Ny x Nu, dove Ny e Nu sono il numero di output e input del sistema dinamico. Ad esempio, si consideri il seguente modello stato-spazio che rappresenta un sistema con due input e un output.

A = [-0.5572,-0.7814;0.7814,0];
B = [1,-1;0,2];
C = [1.9691,6.4493];
sys = ss(A,B,C,0);

Estrarre la risposta al gradino di questo sistema a 200 punti temporali compresi tra t = 0 e t = 20 s.

t = linspace(0,20,200);
y = step(sys,t);
size(y)

ans = 1×3

   200     1     2

y(:,i,j) è un vettore colonna contenente la risposta al gradino dal j-esimo input all'i-esimo output ai tempi t. Ad esempio, estrarre la risposta al gradino dal secondo input all'output.

y12 = y(:,1,2);
plot(t,y12)

Grafico della risposta al gradino del loop di feedback con ritardo

Creare un loop di feedback con ritardo e tracciarne la risposta al gradino.

s = tf('s');
G = exp(-s) * (0.8*s^2+s+2)/(s^2+s);
sys = feedback(ss(G),1);
step(sys)

La risposta al gradino del sistema visualizzata è confusa. La risposta al gradino dei sistemi con ritardi interni può mostrare un comportamento anomalo, come salti ricorrenti. Tale comportamento è una feature del sistema e non un'anomalia del software.

Risposta all'input a gradino personalizzato

Per impostazione predefinita, step applica un segnale di input che cambia da 0 a 1 a t = 0. Per personalizzare l'ampiezza e il bias, utilizzare RespConfig. Ad esempio, calcolare la risposta di un modello stato-spazio SISO a un segnale che cambia da 1 a –1 a t = 0.

A = [1.6 -0.7;
      1  0];
B = [0.5; 0];
C = [0.1 0.1];
D = 0;
sys = ss(A,B,C,D,0.2);

opt = RespConfig;
opt.Bias = 1;
opt.Amplitude = -2;

step(sys,opt)

Per le risposte a segnali di input arbitrari, utilizzare lsim.

Risposte al gradino di modelli identificati con intervalli di confidenza

Confrontare la risposta al gradino di un modello parametrico identificato con un modello non parametrico (empirico). Visualizzare inoltre i 3 relativi intervalli di confidenza $$\sigma$$.

Caricare i dati.

load iddata1 z1

Stimare un modello parametrico.

sys1 = ssest(z1,4);

Stimare un modello non parametrico.

sys2 = impulseest(z1);

Tracciare le risposte al gradino per il confronto.

t = (0:0.1:10)';
[y1, ~, ~, ysd1] = step(sys1,t);
[y2, ~, ~, ysd2] = step(sys2,t);
plot(t, y1, 'b', t, y1+3*ysd1, 'b:', t, y1-3*ysd1, 'b:')
hold on
plot(t, y2, 'g', t, y2+3*ysd2, 'g:', t, y2-3*ysd2, 'g:')

Risposta al gradino del modello di serie temporale identificato

Calcolare la risposta al gradino di un modello di serie temporale identificato.

Un modello di serie temporale, chiamato anche modello di segnale, è un modello senza segnali di input misurati. Il grafico a gradino di questo modello utilizza il suo canale di rumore (non misurato) come canale di input a cui viene applicato il segnale a gradino.

Caricare i dati.

load iddata9;

Stimare un modello di serie temporale.

sys = ar(z9, 4);

sys è un modello di forma A y(t) = e(t), dove e(t) rappresenta il canale di rumore. Per il calcolo della risposta al gradino, e(t) viene trattato come un canale di input e viene denominato e@y1.

Tracciare la risposta al gradino.

step(sys)

Validazione della linearizzazione del modello ARX non lineare identificato

Validare la linearizzazione di un modello ARX non lineare confrontando le risposte a gradino di ampiezza ridotta dei modelli lineari e non lineari.

Caricare i dati.

load iddata2 z2;

Stimare un modello ARX non lineare.

nlsys = nlarx(z2,[4 3 10],idTreePartition,'custom',...
    {'sin(y1(t-2)*u1(t))+y1(t-2)*u1(t)+u1(t).*u1(t-13)',...
    'y1(t-5)*y1(t-5)*y1(t-1)'},'nlr',[1:5, 7 9]);

Determinare un punto di equilibrio operativo per nlsys corrispondente a un valore di input a stato stazionario di 1.

u0 = 1;
[X,~,r] = findop(nlsys, 'steady', 1);
y0 = r.SignalLevels.Output;

Ottenere un'approssimazione lineare di nlsys in tale punto operativo.

sys = linearize(nlsys,u0,X);

Validare l'utilità di sys confrontando la sua risposta al gradino di ampiezza ridotta con quella di nlsys.

Il sistema non lineare nlsys funziona a un livello di equilibrio determinato da (u0,y0). Introdurre una perturbazione a gradino di grandezza 0,1 rispetto a questo stato stazionario e calcolare la risposta corrispondente.

opt = RespConfig;
opt.InputOffset = u0;
opt.Amplitude = 0.1;
t = (0:0.1:10)';
ynl = step(nlsys, t, opt);

Il sistema lineare sys esprime la relazione tra le perturbazioni in input e la corrispondente perturbazione in output. Non tiene in considerazione i valori di equilibrio del sistema non lineare.

Tracciare la risposta al gradino del sistema lineare.

opt = RespConfig;
opt.Amplitude = 0.1;
yl = step(sys, t, opt);

Aggiungere l'offset di stato stazionario y0 alla risposta del sistema lineare e tracciare le risposte.

plot(t, ynl, t, yl+y0)
legend('Nonlinear', 'Linear with offset')

Risposta al gradino del modello LPV

Calcolare e tracciare la risposta al gradino di un modello LPV (lpvss). Questo esempio simula la risposta al gradino a loop chiuso di un modello di palla levitante definito in fcnMaglev.m a un disturbo $\mathit{du}$.

Creare il modello e discretizzarlo.

hmin = 0.05; 
hmax = 0.25;
h0 = (hmin+hmax)/2;
Ts = 0.01;
Glpv = lpvss("h",@fcnMaglev,0,0,h0);
Glpvd = c2d(Glpv,Ts,"tustin"); 

Campionare il modello LPV per tre valori in altezza e sincronizzare un controller PID.

hpid = linspace(hmin,hmax,3);
[Ga,Goffset] = sample(Glpvd,[],hpid);
wc = 50;
Ka = pidtune(Ga,"pidf",wc);
Ka.Tf = 0.01;

Creare il controller PID con pianificazione del guadagno.

Ka.SamplingGrid = struct("h",hpid);
Koffset = struct("y",{Goffset.u});
Clpv = ssInterpolant(ss(Ka),Koffset);

Creare il modello a loop chiuso.

CL = feedback(Glpvd*[1,Clpv],1,2,1);
CL.InputName = {'du';'href'};
CL.OutputName = "h";

Ottenere la corrente allo stato stazionario $\mathit{h}$ = ${\mathit{h}}_0$ per calcolare una grandezza appropriata per il disturbo a gradino all'input dell'impianto.

[~,~,~,~,~,~,~,u0] = Glpv.DataFunction(0,h0);

Calcolare e tracciare la risposta al disturbo dell'input e alla variazione a gradino del riferimento. Impostare i segnali di input di base $\mathit{du}$ = 0 e $\mathit{h}$ = ${\mathit{h}}_0$ per specificare la condizione dello stato stazionario iniziale.

t = 0:Ts:2;
pFcn = @(k,x,u) x(1);
Config = RespConfig( ...
    Bias=[0;h0], ...
    Amplitude=0.2*[u0;h0]*Ts, ...
    Delay=0.5, ...
    InitialParameter=h0);
step(CL,t,pFcn,Config)
title("Current Step Disturbance and Height Step Change")

Calcolo della risposta al gradino del modello con coefficienti complessi

Creare un modello stato-spazio con coefficienti complessi.

A = [-2-2i -2;1 0];
B = [2;0];
C = [0 0.5+2.5i];
D = 0;
sys = ss(A,B,C,D);

Calcolare la risposta al gradino del sistema.

[y,t] = step(sys);

I dati della risposta risultanti contengono valori di output complessi.

y

y = 369×1 complex

   0.0000 + 0.0000i
   0.0018 + 0.0075i
   0.0079 + 0.0286i
   0.0191 + 0.0612i
   0.0360 + 0.1033i
   0.0588 + 0.1531i
   0.0874 + 0.2089i
   0.1215 + 0.2690i
   0.1609 + 0.3320i
   0.2048 + 0.3969i
   0.2528 + 0.4624i
   0.3041 + 0.5279i
   0.3580 + 0.5925i
   0.4138 + 0.6558i
   0.4708 + 0.7173i
      ⋮

Argomenti di input

sys — Sistema dinamico

modello di sistema dinamico | array del modello

Sistema dinamico, specificato come modello di sistema dinamico SISO o MIMO o come array di modelli del sistema dinamico. È possibile utilizzare questi tipi di sistemi dinamici:

• Modelli LTI numerici a tempo continuo o a tempo discreto, come i modelli tf, zpk o ss.

• Modelli LTI generalizzati o incerti, come i modelli genss o uss. (Per utilizzare i modelli incerti è necessario disporre del software Robust Control Toolbox™).

  • Per i blocchi di progettazione di controllo sincronizzabili, la funzione valuta il modello al suo valore corrente sia per tracciare che per restituire i dati della risposta.

  • Per i blocchi di progettazione di controllo incerti, la funzione traccia il valore nominale e i campioni casuali del modello. Quando si utilizzano gli argomenti di output, la funzione restituisce i dati della risposta solo per il modello nominale.

• Modelli stato-spazio radi, come i modelli sparss e mechss.

• Modelli LTI identificati, come i modelli idtf, idss o idproc. Per tali modelli, la funzione può inoltre tracciare gli intervalli di confidenza e restituire le deviazioni standard della risposta in frequenza. Vedere Risposte al gradino di modelli identificati con intervalli di confidenza. (Per utilizzare i modelli identificati è necessario disporre del software System Identification Toolbox).

• Modelli lineari a tempo variabile (ltvss) e a parametri variabili (lpvss).

Questa funzione non supporta i modelli di dati della risposta in frequenza, come il modello frd, genfrd o idfrd.

Se sys è un array di modelli, la funzione traccia le risposte di tutti i modelli dell'array sugli stessi assi. Vedere Risposta al gradino dei sistemi in un array del modello.

t — Passi temporali

scalare positivo | vettore a due elementi | vettore | []

Passi temporali in cui calcolare la risposta, specificati come uno di questi valori:

• Scalare positivo tFinal: calcolare la risposta da t = 0 a t = tFinal.

• Vettore a due elementi [t0 tFinal]: calcolare la risposta da t = t0 a t = tFinal. (da R2023b)

• Vettore Ti:dt:Tf: calcolare la risposta per i punti temporali specificati in t.

  • Per i sistemi a tempo continuo, dt è il tempo di campionamento di un'approssimazione discreta al sistema continuo.

  • Per i sistemi a tempo discreto con un tempo di campionamento specificato, dt deve corrispondere alla proprietà del tempo di campionamento Ts di sys.

  • Per i sistemi a tempo discreto con un tempo di campionamento non specificato (Ts = -1), dt deve essere 1.

• []: selezionare automaticamente i valori del tempo in base alla dinamica del sistema.

Quando si specifica un intervallo di tempo utilizzando tFinal o [t0 tFinal]:

• Per i sistemi a tempo continuo, la funzione determina automaticamente la grandezza del passo temporale e il numero di punti in base alla dinamica del sistema.

• Per i sistemi a tempo discreto con un tempo di campionamento specificato, la funzione utilizza il tempo di campionamento di sys come grandezza del passo temporale.

• Per i sistemi a tempo discreto con tempo di campionamento non specificato (Ts = -1), la funzione interpreta tFinal come il numero di periodi di campionamento da simulare con un tempo di campionamento di 1 secondo.

Esprimere t utilizzando le unità di tempo specificate nella proprietà TimeUnit di sys.

Se si specifica un ritardo del gradino td utilizzandoconfig, la funzione applica il gradino a t = t0+td.

p — Traiettoria del parametro del modello LPV

matrice | handle della funzione

Traiettoria del parametro del modello LPV, specificata come matrice o handle della funzione.

• Per le traiettorie esogene o esplicite, specificare p come matrice con dimensioni N x Np, dove N è il numero di campioni di tempo e Np è il numero di parametri.

  Pertanto, il vettore riga p(i,:) contiene i valori dei parametri all'i-esimo passo temporale.

• Per le traiettorie endogene o implicite, specificare p come handle della funzione di forma p = F(t,x,u) a tempo continuo e p = F(k,x,u) a tempo discreto che fornisce i parametri come funzione del tempo t o come campione di tempo k, stato x e input u.

  Questa opzione è utile quando si desidera simulare modelli quasi LPV. Per un esempio, vedere Risposta al gradino del modello LPV.

config — Configurazione della risposta

oggetto RespConfig

Configurazione del segnale applicato, specificata come oggettoRespConfig. Per impostazione predefinita, step applica un input che passa da 0 a 1 al tempo t = 0. Utilizzare questo argomento di input per cambiare la configurazione dell'input a gradino. Per un esempio, vedere Risposta all'input a gradino personalizzato.

Per i modelli lpvss e ltvss con offset (x₀(t),u₀(t)), è possibile utilizzare RespConfig per definire l'input relativo a u₀(t,p) e inizializzare la simulazione con lo stato x₀(t,p).

Argomenti di output

y — Dati della risposta al gradino

array

Dati della risposta al gradino, restituiti come array.

• Per i sistemi SISO, y è un vettore colonna della stessa lunghezza di t (se fornito) o di tOut (se t non è fornito).

• Per i sistemi a singolo input/singolo output, y è una matrice con tante righe quante sono i campioni di tempo e tante colonne quante sono le uscite. Quindi, la j-esima colonna di y o y(:,j), contiene la risposta al gradino dall'input al j-esimo output.

• Per i sistemi MIMO, le risposte al gradino di ciascun canale di input sono sovrapposte lungo la terza dimensione di y. Le dimensioni di y sono quindi N x Ny x Nu, dove:

  • N è il numero di campioni di tempo.

  • Ny è il numero di output del sistema.

  • Nu è il numero di input del sistema.

  Quindi, y(:,i,j) è un vettore colonna contenente la risposta al gradino dal j-esimo input all'i-esimo output ai tempi specificati in t o tOut.

• Per i sistemi con coefficienti complessi, y è un array di valori complessi. (da R2025a)

tOut — Tempi in cui viene calcolata la risposta al gradino

vettore

Tempi in cui viene calcolata la risposta al gradino, restituiti come vettore. Quando non si fornisce un vettore di tempi t specifico, step sceglie questo vettore temporale in base alla dinamica del sistema. I tempi sono espressi nelle unità di tempo di sys.

x — Traiettorie di stato

array

Traiettorie di stato, restituite come array. Quando sys è un modello stato-spazio, x contiene l'evoluzione degli stati di sys a ciascun istante in t o tOut. Le dimensioni di x sono N x Nx x Nu, dove:

• N è il numero di campioni di tempo.

• Nx è il numero di stati.

• Nu è il numero di input del sistema.

Quindi, l'evoluzione degli stati in risposta a un gradino applicato al k-esimo input è dato dall'array x(:,:,k). Il vettore riga x(i,:,k) contiene i valori di stato all'i-esimo passo temporale.

Per i sistemi con coefficienti complessi, x è un array di valori complessi. (da R2025a)

ysd — Deviazione standard della risposta al gradino

array

Deviazione standard della risposta al gradino di un modello identificato, restituita come un array delle stesse dimensioni di y. Se sys non contiene informazioni sulla covarianza dei parametri, allora ysd è vuoto.

pOut — Traiettorie del parametro

array

Traiettorie del parametro, restituite come array. Quando sys è un modello lineare a parametri variabili, pOut contiene l'evoluzione dei parametri di sys a ciascun istante in t o tOut. Le dimensioni di pOut sono N x Np x Nu, dove:

• N è il numero di campioni di tempo.

• Np è il numero di parametri.

• Nu è il numero di input del sistema.

Quindi, l'evoluzione dei parametri in risposta a un gradino applicato al k-esimo input è dato dall'array pOut(:,:,k). Il vettore riga pOut(i,:,k) contiene i valori dei parametri all'i-esimo passo temporale.

Suggerimenti

• Per simulare le risposte del sistema a segnali di input arbitrari, utilizzare lsim.

• Quando sono necessarie ulteriori opzioni di personalizzazione del grafico, utilizzare invece stepplot.

• I grafici creati utilizzando step non supportano titoli o etichette su più righe specificati come array di stringhe o array di celle di vettori di caratteri. Per specificare titoli ed etichette su più righe, utilizzare una singola stringa con un carattere newline.

  step(sys,u,t)
  title("first line" + newline + "second line");

Algoritmi

Per ottenere campioni di modelli a tempo continuo senza ritardi interni, step converte tali modelli in modelli stato-spazio e li discretizza utilizzando un blocco di ordine zero sugli input. step sceglie automaticamente il tempo di campionamento per questa discretizzazione in base alla dinamica del sistema, tranne quando si fornisce il vettore di tempo di input t nella forma t = T0:dt:Tf. In tal caso, step utilizza dt come tempo di campionamento. I passi temporali di simulazione risultanti tOut sono ugualmente campionati con spaziatura dt.

Per i sistemi con ritardi interni, il software Control System Toolbox™ utilizza risolutori a gradino variabile. Di conseguenza, i passi temporali tOut non sono ugualmente campionati.

Riferimenti

[1] L.F. Shampine and P. Gahinet, "Delay-differential-algebraic equations in control theory," Applied Numerical Mathematics, Vol. 56, Issues 3–4, pp. 574–588.

Cronologia versioni

Introduzione prima di R2006a

R2025a: Supporto per sistemi dinamici con coefficienti complessi

A partire dalla release R2025a, la funzione step supporta i sistemi dinamici con coefficienti complessi.

R2024b: Attuale fattibilità di restituzione di un oggetto grafico da parte di gca

Per i grafici creati utilizzando step, la funzione gca ora restituisce un oggetto grafico stepplot anziché un asse all'interno del grafico.

R2023b: Modifiche nel calcolo delle caratteristiche della risposta

Il calcolo di alcune caratteristiche della risposta è cambiato quando si utilizza una configurazione non predefinita, creata utilizzando RespConfig.

• La caratteristica Peak Response ora mostra la deviazione massima dal valore iniziale di output. Ossia, il valore di picco di |y(t) – y_init| quando t ≥ t₀ + t_d, dove y_init è il valore di output appena prima della variazione a gradino.

  Di conseguenza, nel suggerimento dati Peak Response, Peak amplitude viene rinominato in Peak deviation.

• Il tempo di assestamento e il tempo transitorio sono ora calcolati in relazione al momento in cui si verifica la variazione a gradino (t = t₀ + t_d). Questo garantisce che queste caratteristiche non siano influenzate da un ritardo del gradino.

In generale, il software calcola le caratteristiche della risposta dal momento della variazione a gradino, con il valore iniziale di output y_init come il valore appena prima della variazione a gradino.

R2023b: Nuova sintassi

Utilizzare la nuova sintassi [y,tOut] = step(sys,[t0,tFinal]) per calcolare la risposta al gradino dal tempo t0 a tFinal. Per le configurazioni con un ritardo td, la funzione applica il passo al tempo t = t0 + td.

R2023a: Supporto per il tempo di inizio diverso da zero

Ora è possibile specificare un tempo di inizio diverso da zero per il comando step utilizzando un input di tipo vettore di tempo nella forma Ti:dt:Tf. In precedenza, il comando applicava sempre l'input a t = 0, indipendentemente da Ti.

Vedi anche

Funzioni

• impulse | RespConfig | initial | lsim | stepplot

App

• Linear System Analyzer

Siti web esterni

• Transfer Function Analysis of Dynamic Systems (Analisi della funzione di trasferimento di sistemi dinamici) (Risorse didattiche di MathWorks)