impulse

Impulsantwort-Diagramm eines dynamischen Systems, Impulsantwortdaten

Syntax

[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(___)

Beschreibung

[y,tOut] = impulse(sys) berechnet die Impulsantwort y des dynamischen Systems sys. impulse bestimmt automatisch die Zeitschritte und die Dauer der Simulation auf der Grundlage der Systemdynamik.

[y,tOut] = impulse(sys,t) simuliert die Antwort für die Zeitschritte, die durch t angegeben sind. Zum Definieren der Zeitschritte können Sie folgendes angeben:

• Die endgültige Simulationszeit unter Verwendung eines skalaren Werts.

• Die Anfangs- und Endzeit der Simulation unter Verwendung eines Vektors mit zwei Elementen. (seit R2023b)

• Alle Zeitschritte unter Verwendung eines Vektors.

[y,tOut] = impulse(sys,t,p) gibt die Parametertrajektorie p für Modelle mit linearer Parametervariation (LPV) an. (seit R2023a)

[y,t,x] = impulse(___) gibt auch die Zustandstrajektorien x zurück, wenn sys ein Zustandsraummodell ist.

[y,t,x,ysd] = impulse(___) gibt die Standardabweichung der Impulsantwort für identifizierte Modelle zurück. Diese Syntax erfordert System Identification Toolbox™-Software.

[y,tOut,x,~,pOut] = impulse(sys,t,p) gibt die Parametertrajektorien für LPV-Modelle zurück. (seit R2023a)

[y,tOut] = impulse(___,config) gibt zusätzliche Optionen für die Berechnung der Impulsantwort an, z. B. die Amplitude oder den Eingangsoffset. Verwenden Sie RespConfig, um den Optionssatz config zu erstellen.

impulse(___) plottet die Impulsantwort von sys mit Standard-Diagrammoptionen für alle vorherigen Eingangsargument-Kombinationen. Weitere Informationen zu den Anpassungsmöglichkeiten von Diagrammen finden Sie unter impulseplot.

• Um Antworten für mehrere dynamische Systeme auf einem Diagramm zu plotten, können Sie sys als kommagetrennte Modellliste angeben. impulse(sys1,sys2,sys3) plottet beispielsweise die Antworten für drei Modelle auf demselben Diagramm.

• Um eine Farbe, einen Linienstil und eine Markierung für jedes System im Diagramm darzustellen, geben Sie für jedes System einen Wert LineSpec an. Mithilfe von impulse(sys1,LineSpec1,sys2,LineSpec2) können Sie beispielsweise zwei Modelle zeichnen und deren Diagrammstil festlegen. Weitere Informationen zum Festlegen eines LineSpec-Werts finden Sie unter impulseplot.

Beispiele

Impulsantwort eines dynamischen Systems

Plotten Sie die Impulsantwort eines zeitkontinuierlichen Systems, das durch die folgende Transferfunktion dargestellt wird.

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

Erstellen Sie für dieses Beispiel ein tf-Modell, das die Transferfunktion darstellt. In ähnlicher Weise können Sie die Impulsantwort anderer dynamischer Systemmodelle plotten, wie z. B. Nullpolverstärkungsmodelle (zpk) oder Zustandsraummodelle (ss).

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

Plotten Sie die Impulsantwort.

impulse(sys)

Das impulse-Diagramm enthält automatisch eine gepunktete horizontale Linie, die das stationäre Verhalten anzeigt. In einem MATLAB®-Abbildungsfenster können Sie auf das Diagramm rechtsklicken, um weitere Impulsantwortcharakteristiken wie Spitzenwert und Übergangszeit anzuzeigen.

Impulsantwort eines zeitdiskreten Systems

Plotten Sie die Impulsantwort eines zeitdiskreten Systems. Das System hat eine Abtastzeit von 0,2 s und wird durch die folgenden Zustandsraummatrizen dargestellt.

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

Erstellen Sie das Zustandsraummodell und plotten Sie seine Impulsantwort.

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

Die Impulsantwort spiegelt die Diskretisierung des Modells wider und zeigt die alle 0,2 Sekunden berechnete Antwort.

Impulsantwort zu bestimmten Zeiten

Untersuchen Sie die Impulsantwort des folgenden Null-Polstellen-Verstärkungsmodells.

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)

Standardmäßig wählt impulse einen Endzeitpunkt, der den stationären Zustand anzeigt, zu dem die Antwort tendiert. Um einen genaueren Blick auf das Einschwingverhalten zu erhalten, begrenzen Sie das Impulsdiagramm auf t = 20 s.

impulse(sys,20)

Sie können auch die genauen Zeitpunkte angeben, zu denen Sie die Impulsantwort untersuchen wollen, sofern sie durch ein konstantes Intervall getrennt sind. Untersuchen Sie zum Beispiel die Antwort vom Ende des Einschwingvorgangs bis zum Erreichen des stationären Zustands des Systems.

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

Auch wenn dieses Diagramm bei t = 20 beginnt wendet impulse immer die Impulseingabe bei t = 0 an.

Impulsantwortdiagramm von MIMO-Systemen

Betrachten Sie das folgende Zustandsraummodell zweiter Ordnung:

$$\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);

Dieses Modell hat zwei Eingänge und einen Ausgang, es hat also zwei Kanäle: vom ersten Eingang zum Ausgang und vom zweiten Eingang zum Ausgang. Jeder Kanal hat seine eigene Impulsantwort.

Wenn Sie impulse verwenden, werden die Antworten aller Kanäle berechnet.

impulse(sys)

Das linke Diagramm zeigt die Impulsantwort des ersten Eingangskanals, das rechte Diagramm die Impulsantwort des zweiten Eingangskanals. Wann immer Sie mit impulse die Antworten eines MIMO-Modells plotten, wird ein Array von Diagrammen erzeugt, die alle E/A-Kanäle des Modells darstellen. Erstellen Sie zum Beispiel ein zufälliges Zustandsraummodell mit fünf Zuständen, drei Eingängen und zwei Ausgängen und plotten Sie seine Impulsantwort.

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

In einem MATLAB-Abbildungsfenster können Sie das Diagramm auf eine Teilmenge von Kanälen beschränken, indem Sie auf das Diagramm rechtsklicken und I/O Selector wählen.

Vergleichen der Impulsantworten mehrerer Systeme

impulse ermöglicht es Ihnen, die Antworten mehrerer dynamischer Systeme auf derselben Achse darzustellen. Vergleichen Sie zum Beispiel das Regelverhalten eines Systems mit einem PI-Regler und einem PID-Regler. Erstellen Sie eine Transferfunktion des Systems und optimieren Sie die Regler.

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

Bilden Sie die geschlossenen Regelkreise und plotten Sie deren Impulsantworten.

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

Standardmäßig wählt impulse unterschiedliche Farben für jedes System aus, das Sie plotten. Sie können Farben und Linienstile mit dem Eingabeargument LineSpec angeben.

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

Das erste LineSpec, 'r--', legt eine gestrichelte rote Linie für die Antwort mit dem PI-Regler fest. Das zweite LineSpec, 'b', legt eine durchgezogene blaue Linie für die Antwort mit dem PID-Regler fest. Die Legende spiegelt die angegebenen Farben und Linienstile wider. Weitere Informationen zu den Anpassungsmöglichkeiten von Diagrammen finden Sie unter impulseplot.

Impulsantwort von Systemen in einem Modellarray

Das Beispiel Vergleichen der Impulsantworten mehrerer Systeme zeigt, wie die Antworten mehrerer individueller Systeme auf einer einzigen Achse geplottet werden können. Wenn Sie mehrere dynamische Systeme in einem Modellarray angeordnet haben, plottet impulse alle ihre Antworten auf einmal.

Erstellen Sie ein Modellarray. Verwenden Sie für dieses Beispiel ein eindimensionales Array von Transferfunktionen zweiter Ordnung mit unterschiedlichen Eigenfrequenzen. Weisen Sie zunächst den Speicher für das Modellarray zu. Der folgende Befehl erstellt eine 1-mal-5-Reihe von SISO-Transferfunktionen mit Null-Verstärkung. Die ersten beiden Dimensionen stellen die Ausgänge und Eingänge des Modells dar. Die übrigen Dimensionen sind die Arraydimensionen.

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

Füllen Sie das Array auf.

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

(Weitere Informationen über Modellarrays und deren Erstellung finden Sie unter Model Arrays) Plotten Sie die Impulsantworten aller Modelle im Array.

impulse(sys)

impulse verwendet den gleichen Linienstil für die Antworten aller Einträge im Array. Eine Möglichkeit, zwischen den Einträgen zu unterscheiden, ist die Verwendung der SamplingGrid-Eigenschaft dynamischer Systemmodelle, um jedem Eintrag im Array den entsprechenden w0-Wert zuzuordnen.

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

Wenn Sie nun die Antworten in einem MATLAB-Abbildungsfenster plotten, können Sie auf eine Kurve klicken, um zu sehen, welchem Frequenzwert sie entspricht.

Impulsantwortdaten

Wenn Sie ihr ein Ausgangs-Argument angeben, gibt die Funktion impulse ein Array mit Antwortdaten zurück. Bei einem SISO-System werden die Antwortdaten als Spaltenvektor zurückgegeben, dessen Länge der Anzahl der Zeitpunkte entspricht, zu denen die Antwort abgetastet wird. Sie können den Vektor t der Zeitpunkte angeben oder zulassen, dass impulse auf der Grundlage der Systemdynamik Zeitpunkte für Sie auswählt. Extrahieren Sie zum Beispiel die Impulsantwort eines SISO-Systems zu 101 Zeitpunkten zwischen t = 0 und 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

Bei einem MIMO-System werden die Antwortdaten in einem Array der Dimensionen N-mal-Ny-mal-Nu zurückgegeben, wobei Ny und Nu die Anzahl der Ausgänge und Eingänge des dynamischen Systems sind. Betrachten Sie zum Beispiel das folgende Zustandsraummodell, das ein System mit zwei Eingängen und einem Ausgang darstellt.

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

Extrahieren Sie die Impulsantwort dieses Systems zu 200 Zeitpunkten zwischen t = 0 und t = 20 s.

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

ans = 1×3

   200     1     2

y(:,i,j) ist ein Spaltenvektor, der die Impulsantwort des j-ten Eingangs zum i-ten Ausgang zu den Zeitpunkten t enthält. Extrahieren Sie zum Beispiel die Impulsantwort vom zweiten Eingang zum Ausgang.

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

Impulsantworten der identifizierten Modelle mit Konfidenzintervallen

Vergleichen Sie die Impulsantwort eines parametrisch ermittelten Modells mit jener eines nicht-parametrischen (empirischen) Modells. Sehen Sie sich auch ihre 3 $$\sigma$$ Konfidenzintervalle an.

Laden Sie die Daten.

load iddata1 z1

Schätzen Sie ein parametrisches Modell.

sys1 = ssest(z1,4);

Schätzen Sie ein nicht-parametrisches Modell.

sys2 = impulseest(z1);

Plotten Sie die Impulsantwort zum Vergleich.

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:')

Impulsantwort eines identifizierten Zeitreihenmodells

Berechnen Sie die Impulsantwort eines identifizierten Zeitreihenmodells.

Ein Zeitreihenmodell, auch Signalmodell genannt, ist ein Modell ohne gemessene Eingangssignale. Das Impulsdiagramm dieses Modells verwendet seinen (nicht gemessenen) Rauschkanal als Eingangskanal, an den das Impulssignal angelegt wird.

Laden Sie die Daten.

load iddata9;

Schätzen Sie ein Zeitreihenmodell.

sys = ar(z9, 4);

sys ist ein Modell der Form A y(t) = e(t), wobei e(t) den Rauschkanal darstellt. Zur Berechnung der Impulsantwort wird e(t) als ein Eingangskanal behandelt und e@y1 benannt.

Plotten Sie die Impulsantwort.

impulse(sys)

Konfigurieren von Optionen für die Impulsantwort

Erstellen Sie ein Zustandsraummodell.

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);

Erstellen Sie einen Standard-Optionssatz und verwenden Sie Punktnotation, um die Werte anzugeben.

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

Berechnen Sie die Impulsantwort.

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

Impulsantwort eines LPV-Modells

Dieses Beispiel demonstriert, wie Sie die Impulsantwort eines LPV-Modells simulieren können. Dieses Beispiel simuliert die in fcnMaglev.m definierte Antwort im geschlossenen Regelkreis eines Modells einer schwebenden Kugel auf eine Störung $\text{du}$.

Sie müssen die Referenz auf $h_0$ setzen, um das System korrekt zu initialisieren und auf $h$ = $h_0$ zu halten.

Erstellen Sie das Modell und diskretisieren Sie es.

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"); 

Probieren Sie das LPV-Modell mit drei Höhenwerten aus und stellen Sie einen PID-Regler ein.

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

Erstellen Sie den verstärkungsgesteuerten PID-Regler.

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

Erstellen Sie das Modell des geschlossenen Regelkreises.

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

Ermitteln Sie den stationären Strom für $h$ = $h_0$, um die Größe der Störung zu bestimmen.

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

Antwort auf Impulsänderung in $\text{du}$ und $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")

Berechnen der Impulsantwort eines Modells mit komplexen Koeffizienten

Erstellen Sie ein Zustandsraummodell mit komplexen Koeffizienten.

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

Berechnen Sie die Impulsantwort des Systems.

[y,t] = impulse(sys);

Die resultierenden Antwortdaten enthalten komplexe Ausgangswerte.

y

Eingabeargumente

sys — Dynamisches System

dynamisches Systemmodell | Modellarray

Dynamisches System, das als SISO- oder MIMO-Modell für dynamische Systeme oder als Array von dynamischen Systemmodellen angegeben wird. Sie können diese Arten von dynamischen Systemen verwenden:

• Zeitkontinuierliche oder zeitdiskrete numerische LTI-Modelle, wie tf-, zpk- oder ss-Modelle.

• Verallgemeinerte oder unsichere LTI-Modelle wie z. B. genss- oder uss-Modelle. (Für die Verwendung unsicherer Modelle ist die Software Robust Control Toolbox™ erforderlich.)

  • Bei optimierbaren Regelungsentwurf-Blöcken wertet die Funktion das Modell mit dem aktuellen Wert aus, um die Antwortdaten zu plotten und zurückzugeben.

  • Bei unsicheren Regelungsentwurf-Blöcken stellt die Funktion den Nennwert und Zufallsstichproben des Modells dar. Wenn Sie Ausgangsargumente verwenden, gibt die Funktion nur Antwortdaten für das Nominalmodell zurück.

• Schwach besetzte Zustandsraummodelle wie sparss- und mechss-Modelle.

• Identifizierte LTI-Modelle wie idtf-, idss- oder idproc-Modelle. Bei solchen Modellen kann die Funktion auch Konfidenzintervalle darstellen und Standardabweichungen des Frequenzgangs zurückgeben. Siehe Sprungantworten der identifizierten Modelle mit Konfidenzintervallen. (Für die Verwendung von identifizierten Modellen ist die Software System Identification Toolbox erforderlich.)

• Linear zeitvariable (ltvss) und linear parametervariable (lpvss) Modelle.

Diese Funktion unterstützt keine Frequenzantwort-Datenmodelle wie z. B frd-, genfrd- oder idfrd-Modelle.

Wenn sys ein Array von Modellen ist, stellt die Funktion die Antworten aller Modelle im Array auf denselben Achsen dar. Siehe Sprungantwort von Systemen in einem Modellarray.

t — Zeitschritte

Positiver Skalar | Zwei-Elemente-Vektor | Vektor | []

Zeitschritte, zu denen die Antwort berechnet werden soll, angegeben als einer dieser Werte:

• Positiver Skalar tFinal – Berechnen Sie die Antwort von t = 0 auf t = tFinal.

• Zwei-Elemente-Vektor [t0 tFinal] – Berechnen Sie die Antwort von t = t0 auf t = tFinal. (seit R2023b)

• Vektor Ti:dt:Tf – Berechnen Sie die Antwort für die in t festgelegten Zeitpunkte.

  • Bei zeitkontinuierlichen Systemen ist dt die Abtastzeit einer diskreten Approximation an das kontinuierliche System.

  • Bei zeitdiskreten Systemen mit angegebener Abtastzeit muss dt mit der Abtastzeiteigenschaft Ts von sys übereinstimmen.

  • Bei zeitdiskreten Systemen mit unbestimmter Abtastzeit (Ts = -1) muss dt gleich 1 sein.

• [] – Automatische Auswahl von Zeitwerten auf der Grundlage der Systemdynamik.

Wenn Sie entweder mit tFinal oder [t0 tFinal]einen Zeitbereich angeben, gilt:

• Bei zeitkontinuierlichen Systemen bestimmt die Funktion automatisch die Größe des Zeitschritts und die Anzahl der Punkte auf der Grundlage der Systemdynamik.

• Bei zeitdiskreten Systemen mit angegebener Abtastzeit verwendet die Funktion die Abtastzeit von sys als Sprunggröße.

• Bei zeitdiskreten Systemen mit unbestimmter Abtastzeit (Ts = -1) interpretiert die Funktion tFinal als die Anzahl der zu simulierenden Abtastperioden mit einer Abtastzeit von 1 Sekunde.

Drücken Sie t unter Verwendung der Zeiteinheiten aus, die in der TimeUnit-Eigenschaft von sys angegeben sind.

Wenn Sie mit config eine Sprungverzögerung td angeben, wendet die Funktion den Sprung bei t = t0+td an.

Vor R2026a: Geben Sie Zeitwerte mithilfe der Eigenschaft Responses.SourceData.TimeSpec an.

p — Trajektorie der LPV-Modellparameter

Matrix | Funktions-Handle

Parametertrajektorie des LPV-Modells, angegeben als Matrix oder als Funktions-Handle.

• Geben Sie bei exogenen oder expliziten Trajektorien p als eine Matrix mit den Dimensionen N-mal-Np an, wobei N die Anzahl der Zeitabtastungen und Np die Anzahl der Parameter ist.

  Somit enthält der Zeilenvektor p(i,:) die Parameterwerte zum i-ten Zeitschritt.

• Geben Sie bei endogenen oder impliziten Trajektorien p als einen Funktions-Handle der Form p = F(k,x,u) an, der die Parameter als Funktion der Zeit oder Zeitabtastung k, des Zustands x und des Eingangs u ausgibt. impulse unterstützt diese Option nur für zeitdiskrete LPV-Modelle.

  Diese Option ist nützlich, wenn Sie Quasi-LPV-Modelle simulieren wollen.

config — Antwort-Konfiguration

RespConfig-Optionssatz

Konfiguration des angelegten Impulssignals, angegeben als RespConfig-Objekt. Standardmäßig wendet impulse einen Eingang zum Zeitpunkt t = 0 an. Verwenden Sie dieses Eingangsargument, um die Antwort-Konfiguration zu ändern und beispielsweise eine Verzögerung oder einen Eingangs-Offset anzugeben. Ein Beispiel hierzu finden Sie unter Konfigurieren von Optionen für die Impulsantwort.

Bei lpvss- und ltvss-Modellen mit Offsets (x₀(t),u₀(t)) können Sie mit RespConfig die Eingabe relativ zu u₀(t,p) definieren und die Simulation mit dem Zustand x₀(t,p) initialisieren.

Ausgangsargumente

y — Impulsantwortdaten

Array

Impulsantwortdaten, als Array zurückgegeben.

• Bei SISO-Systemen ist y ein Spaltenvektor mit der gleichen Länge wie t (falls vorhanden) oder tOut (wenn Sie t nicht angeben).

• Bei Systemen mit einem Eingang und mehreren Ausgängen ist y eine Matrix mit ebenso vielen Zeilen, wie es Zeitabtastungen gibt, und ebenso vielen Spalten, wie es Ausgänge gibt. Somit enthält die j-te Spalte von y oder y(:,j) die Impulsantwort vom Eingang bis zum j-ten Ausgang.

• Bei MIMO-Systemen werden die Impulsantworten der einzelnen Eingangskanäle entlang der dritten Dimension von y gestapelt. Die Dimensionen von y sind dann N-mal-Ny-mal-Nu, wobei gilt:

  • N ist die Anzahl der Zeitabtastungen.

  • Ny ist die Anzahl der Systemausgänge.

  • Nu ist die Anzahl der Systemeingänge.

  Also ist y(:,i,j) ein Spaltenvektor, der die Impulsantwort vom j-ten Eingang zum i-ten Ausgang zu den Zeiten enthält, die in t oder tOut angegeben sind.

• Bei Systemen mit komplexen Koeffizienten ist y ein Array mit komplexen Werten. (seit R2025a)

tOut — Zeiten, zu denen die Impulsantwort berechnet wird

Vektor

Zeiten, zu denen die Impulsantwort berechnet wird, zurückgegeben als Vektor. Wenn Sie keinen bestimmten Zeitvektor t angeben, wählt impulse diesen Zeitvektor auf der Grundlage der Systemdynamik aus. Die Zeiten werden in den Zeiteinheiten von sys ausgedrückt.

x — Zustands-Trajektorien

Array

Zustands-Trajektorien, zurückgegeben als Array. Wenn sys ein Zustandsraummodell ist, enthält x die Entwicklung der Zustände von sys zu jedem Zeitpunkt in t oder tOut. Die Dimensionen von x sind N-mal-Nx-mal-Nu, wobei gilt:

• N ist die Anzahl der Zeitabtastungen.

• Nx ist die Anzahl der Zustände.

• Nu ist die Anzahl der Systemeingänge.

Somit ist die Entwicklung der Zustände als Reaktion auf einen Impuls, der am k-ten Eingang eingespeist wird, durch das Array x(:,:,k) gegeben. Der Zeilenvektor x(i,:,k) enthält die Zustandswerte zum i-ten Zeitschritt.

Bei Systemen mit komplexen Koeffizienten ist x ein Array mit komplexen Werten. (seit R2025a)

ysd — Standardabweichung der Impulsantwort

Array

Standardabweichung der Impulsantwort eines identifizierten Modells, zurückgegeben als Array mit denselben Dimensionen wie y. Wenn sys keine Informationen über die Kovarianz der Parameter enthält, dann ist ysd leer.

pOut — Parameter-Trajektorien

Array

Parameter-Trajektorien, zurückgegeben als Array. Wenn sys ein Modell mit linear variierenden Parametern ist, enthält pOut die Entwicklung der Parameter von sys zu jedem Zeitpunkt in t oder tOut. Die Dimensionen von pOut sind N-mal-Np-mal-Nu, wobei gilt:

• N ist die Anzahl der Zeitabtastungen.

• Np ist die Anzahl der Parameter.

• Nu ist die Anzahl der Systemeingänge.

Somit ist die Entwicklung der Parameter als Reaktion auf ein Signal, das am k-ten Eingang eingespeist wird, durch das Array pOut(:,:,k) gegeben. Der Zeilenvektor pOut(i,:,k) enthält die Parameterwerte zum i-ten Zeitschritt.

Beschränkungen

• Die Impulsantwort eines kontinuierlichen Systems mit einer D-Matrix ungleich Null ist bei t = 0 unendlich. impulse ignoriert diese Diskontinuität und gibt den niedrigeren Kontinuitätswert Cb bei t = 0 zurück.

• Der Befehl impulse funktioniert nicht bei zeitkontinuierlichen Modellen mit internen Verzögerungen. Verwenden Sie bei diesen Modellen pade, um die Zeitverzögerung zu approximieren, bevor Sie die Impulsantwort berechnen.

• Der Befehl impulse unterstützt keine Simulation entlang einer impliziten Parameter-Trajektorie für zeitkontinuierliche LPV-Modelle.

Tipps

• Verwenden Sie lsim, um die Reaktionen des Systems auf beliebige Eingangssignale zu simulieren.

• Verwenden Sie stattdessen die Funktion impulseplot, wenn Sie weitere Optionen zur Anpassung von Diagrammen benötigen.

• Diagramme, die mit impulse erstellt werden, unterstützen keine mehrzeiligen Titel oder Beschriftungen, die als String-Arrays oder Zellenarrays von Zeichenvektoren angegeben sind. Verwenden Sie zur Angabe mehrzeiliger Titel und Beschriftungen eine einzelne Zeichenkette mit einem newline-Zeichen.

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

Algorithmen

Zeitkontinuierliche LTI-Modelle werden zunächst in Zustandsraumform konvertiert. Die Impulsantwort eines Zustandsraummodells mit einem Eingang

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

ist zur folgenden nicht erzwungenen Antwort mit dem Anfangszustand b äquivalent.

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

Um diese Antwort zu simulieren, wird dieses System mithilfe einer Haltefunktion nullter Ordner bei den Eingängen diskretisiert. Die Abtastzeit wird automatisch auf Grundlage der Systemdynamik gewählt, außer wenn ein Zeitvektor t = T0:dt:Tf angegeben wird. Daher wird dt als Abtastzeit verwendet.

Versionsverlauf

Eingeführt vor R2006a

R2026a: Unterstützung für schwach besetzte Index-2-Modelle

Ab R2026a unterstützt die Funktion impulse schwach besetzte Index-2-DAEs.

R2025a: Unterstützung für dynamische Systeme mit komplexen Koeffizienten

Ab R2025a unterstützt die impulse-Funktion dynamische Systeme mit komplexen Koeffizienten.

R2024b: gca gibt jetzt ein Diagrammobjekt zurück

Bei Diagrammen, die mit impulse erstellt wurden, gibt die gca-Funktion jetzt ein impulseplot-Diagrammobjekt zurück und nicht mehr eine Achse im Diagramm.

R2023b: Änderungen bei der Berechnung der Antwortmerkmale

Die Berechnung einiger Antwortmerkmale hat sich geändert, wenn eine nicht standardmäßige Konfiguration verwendet wird, die mit RespConfig erstellt wurde.

• Die Peak Response-Kennlinie zeigt nun die maximale Abweichung vom anfänglichen Ausgangswert an. Das heißt, den Spitzenwert von |y(t) - y_init|, wenn t ≥ t₀ + t_d, wobei y_init der Ausgangswert unmittelbar vor dem Impuls ist.

  Infolgedessen wird in der Peak Response-Datenspitze Peak amplitude in Peak deviation umbenannt.

• Die Einschwingzeit und die Übergangszeit werden nun relativ zum Zeitpunkt der Impulsänderung berechnet (t = t₀ + t_d). Dadurch wird sichergestellt, dass diese Eigenschaften nicht durch die Verzögerung beeinträchtigt werden.

Im Allgemeinen berechnet die Software die Antwortcharakteristik ab dem Zeitpunkt des Impulses, wobei der Ausgangswert y_init der Wert unmittelbar vor dem Impuls ist.

R2023b: Neue Syntax

Verwenden Sie die neue Syntax [y,tOut] = impulse(sys,[t0,tFinal]) zur Berechnung der Impulsantwort von der Zeit t0 bis tFinal. Bei Konfigurationen mit einer Verzögerung td wendet die Funktion den Impuls zum Zeitpunkt t = t0 + td an.

R2023a: Unterstützung für Startzeiten ungleich Null

Sie können nun eine Startzeit ungleich Null für den impulse-Befehl angeben, indem Sie einen Zeitvektor in der Form Ti:dt:Tf verwenden. Zuvor hat der Befehl die Eingabe immer bei t = 0 vorgenommen, unabhängig von Ti.

Siehe auch

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