impulse

Grafico della risposta all'impulso di un sistema dinamico; dati di risposta all'impulso

Sintassi

[y,tOut] = impulse(sys)

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

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

[y,t,x] = impulse(___)

[y,t,x,ysd] = impulse(___)

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

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

impulse(___)

Descrizione

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

[y,tOut] = impulse(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] = impulse(sys,t,p) specifica la traiettoria del parametro p per i modelli lineari a parametri varianti (LPV). (da R2023a)

[y,t,x] = impulse(___) restituisce inoltre le traiettorie di stato x, quando sys è un modello stato-spazio.

[y,t,x,ysd] = impulse(___) restituisce la deviazione standard della risposta all'impulso per i modelli identificati. Per questa sintassi è necessario disporre del software System Identification Toolbox™.

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

[y,tOut] = impulse(___,config) specifica ulteriori opzioni per il calcolo della risposta all'impulso, come l'ampiezza o l'offset dell'input. Utilizzare RespConfig per creare l'insieme di opzioni config.

impulse(___) traccia la risposta all'impulso 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 impulseplot.

• Per tracciare le risposte di più sistemi dinamici sullo stesso grafico, è possibile specificare sys come un elenco di modelli separati da virgole. Ad esempio, impulse(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, impulse(sys1,LineSpec1,sys2,LineSpec2) traccia due modelli e ne specifica lo stile di plottaggio. Per ulteriori informazioni sulla specifica di un valore LineSpec, vedere impulseplot.

Esempi

Risposta all'impulso di un sistema dinamico

Tracciare la risposta all'impulso di un sistema a tempo continuo rappresentato dalla seguente funzione di trasferimento.

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

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

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

Tracciare la risposta all'impulso.

impulse(sys)

Il grafico impulse 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 della risposta all'impulso, come la risposta di picco e il tempo transitorio.

Risposta all'impulso di un sistema a tempo discreto

Tracciare la risposta all'impulso 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 all'impulso.

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

La risposta all'impulso riflette la discretizzazione del modello, poiché mostra la risposta calcolata ogni 0,2 secondi.

Risposta all'impulso in momenti specifici

Esaminare la risposta all'impulso del seguente modello di guadagno a polo zero.

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

impulse(sys)

Per impostazione predefinita, impulse sceglie un tempo finale che mostra lo stato stazionario verso cui tende la risposta. Per osservare più da vicino la risposta transitoria, limitare il grafico dell'impulso a t = 20 s.

impulse(sys,20)

In alternativa, è possibile specificare gli istanti esatti in cui si desidera esaminare la risposta all'impulso, 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;
impulse(sys,t)

Sebbene questo grafico inizi a t = 20, impulse applica sempre l'input di impulso a t = 0.

Grafico della risposta all'impulso 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 all'impulso.

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

impulse(sys)

Il grafico a sinistra mostra la risposta all'impulso del primo canale di input, mentre quello a destra mostra la risposta all'impulso del secondo canale di input. Ogni volta che si utilizza impulse 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 all'impulso.

sys = rss(5,2,3);
impulse(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 della risposta all'impulso di più sistemi

impulse 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 all'impulso.

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

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

 impulse(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 impulseplot.

Risposta all'impulso dei sistemi in un array del modello

L'esempio Confronto della risposta all'impulso di più sistemi mostra come tracciare le risposte di diversi sistemi singoli su un unico asse. Quando sono presenti più sistemi dinamici disposti in un array del modello, impulse 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 all'impulso di tutti i modelli nell'array.

impulse(sys)

impulse 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 all'impulso

Quando si assegna un argomento di output, impulse 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 impulse selezioni i punti temporali in base alla dinamica del sistema. Ad esempio, estrarre la risposta all'impulso 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 = impulse(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 all'impulso di questo sistema a 200 punti temporali compresi tra t = 0 e t = 20 s.

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

ans = 1×3

   200     1     2

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

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

Risposte all'impulso di modelli identificati con intervalli di confidenza

Confrontare la risposta all'impulso 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 all'impulso per il confronto.

t = (0:0.1:10)';
[y1, ~, ~, ysd1] = impulse(sys1,t);
[y2, ~, ~, ysd2] = impulse(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 all'impulso del modello di serie temporale identificato

Calcolare la risposta all'impulso 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 dell'impulso di questo modello utilizza il suo canale di rumore (non misurato) come canale di input a cui viene applicato il segnale di impulso.

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 all'impulso, e(t) viene trattato come un canale di input e viene denominato e@y1.

Tracciare la risposta all'impulso.

impulse(sys)

Configurazione delle opzioni per la risposta all'impulso

Creare un modello stato-spazio.

A = [-0.8429,-0.2134;-0.5162,-1.2139];
B = [0.7254,0.7147;0,-0.2050];
C = [-0.1241,1.4090;1.4897,1.4172];
D = [0.6715,0.7172;-1.2075,0];
sys = ss(A,B,C,D);

Creare un insieme di opzioni predefinito e utilizzare la notazione a punto per specificare i valori.

respOpt = RespConfig;
respOpt.Bias = [-2,3];
respOpt.Amplitude = [2,-0.5];
respOpt.InitialState = [0.1,-0.1];
respOpt.Delay = 5;

Calcolare la risposta all'impulso.

t = 0:0.1:20;
impulse(sys,t,respOpt)

Risposta all'impulso del modello LPV

Questo esempio mostra come simulare la risposta all'impulso di un modello LPV. Questo esempio simula la risposta a loop chiuso di un modello di palla levitante definito in fcnMaglev.m a un disturbo $\text{du}$.

È necessario impostare il riferimento su $h_0$ per inizializzare correttamente il sistema e mantenerlo intorno a $h$ = $h_0$.

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 per $h$ = $h_0$ per dimensionare il disturbo.

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

Risposta alla variazione dell'impulso in $\text{du}$ e $h_0$.

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);
impulse(CL,t,pFcn,Config)
title("Current Impulse Disturbance and Height Impulse Change")

Calcolo della risposta all'impulso 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 all'impulso del sistema.

[y,t] = impulse(sys);

I dati della risposta risultanti contengono valori di output complessi.

y

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 un 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.

Prima di R2026a: Specificare i valori temporali utilizzando la proprietà Responses.SourceData.TimeSpec.

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(k,x,u) che fornisce i parametri in funzione del campione temporale k, dello stato x e dell'input u. impulse supporta questa opzione solo per i modelli LPV a tempo discreto.

  Questa opzione è utile quando si desidera simulare modelli quasi LPV.

config — Configurazione della risposta

Insieme delle opzioni RespConfig

Configurazione del segnale d'impulso applicato, specificata come oggetto RespConfig. Per impostazione predefinita, impulse applica un input al tempo t = 0. Utilizzare questo argomento di input per modificare la configurazione della risposta, ad esempio specificando un ritardo o un offset di input. Per un esempio, vedere Configurazione delle opzioni per la risposta all'impulso.

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 all'impulso

array

Dati della risposta all'impulso, 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 e multiplo output, y è una matrice con tante righe quanti sono i campioni di tempo e tante colonne quanti sono gli output. Quindi, la j-esima colonna di y o y(:,j), contiene la risposta all'impulso dall'input al j-esimo output.

• Per i sistemi MIMO, le risposte all'impulso 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 all'impulso 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 all'impulso

vettore

Tempi in cui viene calcolata la risposta all'impulso, restituiti come vettore. Quando non si fornisce un vettore di tempi t specifico, impulse 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 impulso applicato al k-esimo input è data 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 all'impulso

array

Deviazione standard della risposta all'impulso 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 impulso applicato al k-esimo input è data dall'array pOut(:,:,k). Il vettore riga pOut(i,:,k) contiene i valori dei parametri all'i-esimo passo temporale.

Limiti

• La risposta all'impulso di un sistema continuo con matrice D diversa da zero è infinita in t = 0. impulse ignora questa discontinuità e restituisce il valore di continuità inferiore Cb in t = 0.

• Il comando impulse non funziona sui modelli a tempo continuo con ritardi interni. Per tali modelli, utilizzare pade per approssimare il ritardo temporale prima di calcolare la risposta all'impulso.

• Il comando impulse non supporta la simulazione lungo una traiettoria di parametri implicita per i modelli LPV a tempo continuo.

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 impulseplot.

• I grafici creati utilizzando impulse 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.

  impulse(sys)
  title("first line" + newline + "second line");

Algoritmi

I modelli LTI a tempo continuo vengono innanzitutto convertiti nella forma di modello stato-spazio. La risposta all'impulso di un modello stato-spazio a singolo input

$$\begin{array}{l}\dot{x}=Ax+bu\\ y=Cx\end{array}$$

è equivalente alla seguente risposta non forzata con stato iniziale b.

$$\begin{array}{cc}\dot{x}=Ax,& x(0)=b\\ y=Cx& \end{array}$$

Per simulare questa risposta, il sistema viene discretizzato utilizzando un mantenimento di ordine zero sugli input. Il tempo di campionamento viene scelto automaticamente in base alla dinamica del sistema, tranne nel caso in cui venga fornito un vettore di tempo t = T0:dt:Tf. Pertanto, dt viene utilizzato come tempo di campionamento.

Cronologia versioni

Introduzione prima di R2006a

R2026a: Supporto per i modelli radi di indice 2

A partire dalla release R2026a, la funzione impulse supporta le DAE rade di indice 2.

R2025a: Supporto per sistemi dinamici con coefficienti complessi

A partire dalla release R2025a, la funzione impulse 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 impulse, la funzione gca ora restituisce un oggetto grafico impulseplot 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 dell'impulso.

  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 l'impulso (t = t₀ + t_d). Questo garantisce che queste caratteristiche non siano influenzate dal ritardo.

In generale, il software calcola le caratteristiche della risposta dal momento dell'impulso, con il valore iniziale di output y_init come il valore appena prima dell'impulso.

R2023b: Nuova sintassi

Utilizzare la nuova sintassi [y,tOut] = impulse(sys,[t0,tFinal]) per calcolare la risposta all'impulso dal tempo t0 a tFinal. Per le configurazioni con un ritardo td, la funzione applica l'impulso 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 impulse 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

Linear System Analyzer | step | initial | lsim | pade | impulseplot