Main Content

tf

Transferfunktionsmodelle

Beschreibung

Verwenden Sie tf, um reellwertige oder komplexwertige Transferfunktionsmodelle zu erstellen oder um dynamische Systemmodelle in die Transferfunktionsform zu konvertieren.

Transferfunktionen sind eine Frequenzbereich-Darstellung linearer zeitinvarianter Systeme. Betrachten Sie zum Beispiel ein zeitkontinuierliches dynamisches SISO-System, das durch die Transferfunktion sys(s) = N(s)/D(s) dargestellt wird, wobei s = jw und N(s) und D(s) als Zähler- bzw. Nennerpolynome bezeichnet werden. Das tf-Modellobjekt kann SISO- oder MIMO-Transferfunktionen in kontinuierlicher Zeit oder diskreter Zeit darstellen.

Sie können ein Transferfunktions-Modellobjekt entweder durch direkte Angabe seiner Koeffizienten erstellen, oder durch Konvertierung eines Modells eines anderen Typs (z. B. eines Zustandsraummodells ss) in die Transferfunktionsform. Weitere Informationen finden Sie unter Transferfunktionen.

Sie können tf auch verwenden, um verallgemeinerte Zustandsraummodelle (genss) oder unsichere Zustandsraummodelle (uss (Robust Control Toolbox)) zu erstellen.

Erstellung

Beschreibung

Beispiel

sys = tf(numerator,denominator) erstellt zunächst ein zeitkontinuierliches Transferfunktionsmodell, indem die Eigenschaften Numerator und Denominator angegeben werden. Betrachten Sie zum Beispiel ein zeitkontinuierliches dynamisches SISO-System, das durch die Transferfunktion sys(s) = N(s)/D(s) dargestellt wird, wobei die Eingangsargumente numerator und denominator die Koeffizienten von N(s) bzw. D(s) sind.

Beispiel

sys = tf(numerator,denominator,ts) erzeugt ein zeitdiskretes Transferfunktionsmodell und setzt die Eigenschaften Numerator, Denominator und Ts. Betrachten Sie zum Beispiel ein zeitdiskretes dynamisches SISO-System, das durch die Transferfunktion sys(z) = N(z)/D(z) dargestellt wird. Die Eingangsargumente numerator und denominator sind die Koeffizienten von N(z) bzw. D(z). Wenn Sie die Abtastzeit nicht angeben möchten, setzen Sie das Eingabeargument ts auf -1.

Beispiel

sys = tf(numerator,denominator,ltiSys) erstellt ein Transferfunktionsmodell mit Eigenschaften, die vom dynamischen Systemmodell ltiSys geerbt wurden, einschließlich der Abtastzeit.

Beispiel

sys = tf(m) erstellt ein Transferfunktionsmodell, das die statische Verstärkung m angibt.

Beispiel

sys = tf(___,Name,Value) legt die Eigenschaften des Transferfunktionsmodells fest, indem es ein oder mehrere Name,Value-Paar-Argumente für eine der vorherigen Eingang-Argument-Kombinationen verwendet.

Beispiel

sys = tf(ltiSys) konvertiert das dynamische Systemmodell ltiSys in ein Transferfunktionsmodell.

Beispiel

sys = tf(ltiSys,component) konvertiert die angegebene Komponente component von ltiSys in die Form einer Transferfunktion. Verwenden Sie diese Syntax nur, wenn es sich bei ltiSys um ein identifiziertes lineares zeitinvariantes (LTI) Modell handelt.

Beispiel

s = tf('s') erzeugt eine spezielle Variable s, die Sie in einem rationalen Ausdruck verwenden können, um ein zeitkontinuierliches Transferfunktionsmodell zu erstellen. Die Verwendung eines rationalen Ausdrucks kann manchmal einfacher und intuitiver sein als die Angabe von Polynomkoeffizienten.

Beispiel

z = tf('z',ts) erzeugt eine spezielle Variable z, die Sie in einem rationalen Ausdruck verwenden können, um ein zeitkontinuierliches Transferfunktionsmodell zu erstellen. Wenn Sie die Abtastzeit nicht angeben möchten, setzen Sie das Eingabeargument ts auf -1.

Eingangsargumente

alle erweitern

Zählerkoeffizienten der Transferfunktion, angegeben als:

  • Zeilenvektor aus Polynomkoeffizienten.

  • Ein NyxNu-Zellenarray von Zeilenvektoren zur Angabe einer MIMO-Transferfunktion, wobei Ny die Anzahl der Ausgänge und Nu die Anzahl der Eingänge ist.

Wenn Sie die Transferfunktion erstellen, geben Sie die Zählerkoeffizienten in der Reihenfolge ihrer absteigenden Potenz an. Wenn der Zähler der Transferfunktion z. B. 3s^2-4s+5 lautet, geben Sie numerator als [3 -4 5] an. Für eine zeitdiskrete Transferfunktion mit Zähler 2z-1 setzen Sie numerator auf [2 -1].

Auch eine Eigenschaft des tf-Objekts. Weitere Informationen finden Sie unter Numerator.

Nennerkoeffizienten, angegeben als:

  • Zeilenvektor aus Polynomkoeffizienten.

  • Ein NyxNu-Zellenarray von Zeilenvektoren zur Angabe einer MIMO-Transferfunktion, wobei Ny die Anzahl der Ausgänge und Nu die Anzahl der Eingänge ist.

Wenn Sie die Transferfunktion erstellen, geben Sie die Nennerkoeffizienten in der Reihenfolge ihrer absteigenden Potenz an. Wenn der Nenner der Transferfunktion z. B. 7s^2+8s-9 lautet, geben Sie denominator als [7 8 -9] an. Für eine zeitdiskrete Transferfunktion mit Nenner 2z^2+1 setzen Sie denominator auf [2 0 1].

Auch eine Eigenschaft des tf-Objekts. Weitere Informationen finden Sie unter Denominator.

Abtastzeit, angegeben als ein Skalar. Auch eine Eigenschaft des tf-Objekts. Weitere Informationen finden Sie unter Ts.

Dynamisches System, das als SISO- oder MIMO-Modell für dynamische Systeme oder als Array von dynamischen Systemmodellen angegeben wird. Zu den dynamischen Systemen, die Sie verwenden können, zählen:

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

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

    Die resultierende Transferfunktion setzt Folgendes voraus:

    • aktuelle Werte der optimierbaren Komponenten für optimierbare Regelungsentwurf-Blöcke

    • nominale Modellwerte für unsichere Regelungsentwurf-Blöcke

  • Identifizierte LTI-Modelle wie idtf (System Identification Toolbox)-, idss (System Identification Toolbox)-, idproc (System Identification Toolbox)-, idpoly (System Identification Toolbox)- und idgrey (System Identification Toolbox)-Modelle. Um die zu konvertierende Komponente des identifizierten Modells auszuwählen, geben Sie component an. Wenn Sie in component keine Komponente angeben, konvertiert tf standardmäßig die gemessene Komponente des identifizierten Modells. (Für die Verwendung von identifizierten Modellen ist die Software System Identification Toolbox™ erforderlich.)

Statische Verstärkung, angegeben als Skalar oder Matrix. Die statische Verstärkung (auch stationäre Verstärkung) eines Systems stellt das Verhältnis zwischen dem Ausgang und dem Eingang unter stationären Bedingungen dar.

Zu konvertierende Komponente des identifizierten Modells, angegeben als eine der folgenden Optionen:

  • 'measured' – konvertiert die gemessene Komponente von sys.

  • 'noise' – konvertiert die Rauschkomponente von sys

  • 'augmented' – konvertiert sowohl die gemessene als auch die Rauschkomponente von sys.

component gilt nur, wenn sys ein identifiziertes LTI-Modell ist.

Weitere Informationen über identifizierte LTI-Modelle und ihre Mess- und Rauschkomponenten finden Sie unter Identified LTI Models.

Ausgangsargumente

alle erweitern

Ausgang des Systemmodells, geliefert als:

  • Ein Transferfunktions-Modellobjekt (tf), wenn die Eingangsargumente numerator und denominator numerische Arrays sind.

  • Ein verallgemeinertes Zustandsraum-Modellobjekt (genss), wenn die Eingangsargumente numerator oder denominator optimierbare Parameter enthalten, wie z. B. realp-Parameter oder verallgemeinerte Matrizen (genmat). Ein Beispiel hierzu finden Sie unter Optimierbarer Tiefpassfilter.

  • Ein unsicheres Zustandsraum-Modellobjekt (uss), wenn die Eingangsargumente numerator oder denominator unsichere Parameter enthalten. Für die Verwendung unsicherer Modelle ist die Software Robust Control Toolbox erforderlich. Ein Beispiel hierzu finden Sie unter Transfer Function with Uncertain Coefficients (Robust Control Toolbox).

Eigenschaften

alle erweitern

Zählerkoeffizienten, angegeben als:

  • Zeilenvektor von Polynomkoeffizienten in absteigender Potenz (für Variable-Werte 's', 'z', 'p' oder 'q') oder in aufsteigender Potenz (für Variable-Werte 'z^-1' oder 'q^-1').

  • Ein NyxNu-Zellenarray von Zeilenvektoren zur Angabe einer MIMO-Transferfunktion, wobei Ny die Anzahl der Ausgänge und Nu die Anzahl der Eingänge ist. Jedes Element des Zellenarrays gibt die Zählerkoeffizienten für ein bestimmtes Eingangs-/Ausgangspaar an. Wenn Sie sowohl Numerator als auch Denominator als Zellenarray angeben, müssen sie die gleichen Dimensionen haben.

Die Koeffizienten von Numerator können entweder reell oder komplexwertig sein.

Nennerkoeffizienten, angegeben als:

  • Ein Zeilenvektor von Polynomkoeffizienten in absteigender Potenz (für Variable-Werte 's', 'z', 'p' oder 'q') oder in aufsteigender Potenz (für Variable-Werte 'z^-1' oder 'q^-1').

  • Ein NyxNu-Zellenarray von Zeilenvektoren zur Angabe einer MIMO-Transferfunktion, wobei Ny die Anzahl der Ausgänge und Nu die Anzahl der Eingänge ist. Jedes Element des Zellenarrays gibt die Zählerkoeffizienten für ein bestimmtes Eingangs-/Ausgangspaar an. Wenn Sie sowohl Numerator als auch Denominator als Zellenarray angeben, müssen sie die gleichen Dimensionen haben.

Wenn alle SISO-Einträge einer MIMO-Transferfunktion denselben Nenner haben, können Sie Denominator als Zeilenvektor angeben, während Sie Numerator als Zellenarray angeben.

Die Koeffizienten von Denominator können entweder reell oder komplexwertig sein.

Anzeigevariable der Transferfunktion, angegeben als eine der folgenden Optionen:

  • 's' – Standard für zeitkontinuierliche Modelle

  • 'z' – Standard für zeitdiskrete Modelle

  • 'p' – äquivalent zu 's'

  • 'q' – äquivalent zu 'z'

  • 'z^-1' – invers zu 'z'

  • 'q^-1' – äquivalent zu 'z^-1'

Der Wert von Variable wird in der Anzeige widergespiegelt und wirkt sich bei zeitdiskreten Modellen auch auf die Interpretation der Koeffizientenvektoren von Numerator und Denominator aus.

  • Für die Variable-Werte 's', 'z', 'p' oder 'q' werden die Koeffizienten in absteigenden Potenzen der Variablen geordnet. Betrachten Sie zum Beispiel den Zeilenvektor [ak ... a1 a0]. Die Polynomreihenfolge wird als akzk+...+a1z+a0 angegeben.

  • Für die Variable-Werte 'z^-1' oder 'q^-1' werden die Koeffizienten in aufsteigenden Potenzen der Variablen geordnet. Betrachten Sie zum Beispiel den Zeilenvektor [b0 b1 ... bk]. Die Polynomreihenfolge wird als b0+b1z1+...+bkzk angegeben.

Beispiele finden Sie unter Angabe der polynomischen Ordnung einer zeitdiskreten Transferfunktion, Transferfunktionsmodelle unter Verwendung rationaler Ausdrücke und Zeitkontinuierliches Transferfunktionsmodell unter Verwendung rationaler Ausdrücke.

Transportverzögerung, die als eine der folgenden Optionen angegeben wird:

  • Skalar: Geben Sie die Transportverzögerung für ein SISO-System oder die gleiche Transportverzögerung für alle Eingangs-/Ausgangspaare eines MIMO-Systems an.

  • NyxNu-Array: Geben Sie separate Transportverzögerungen für jedes Eingangs-/Ausgangspaar eines MIMO-Systems an. Dabei ist Ny die Anzahl der Ausgänge und Nu die Anzahl der Eingänge.

Für zeitkontinuierliche Systeme geben Sie die Transportverzögerungen in der Zeiteinheit an, die durch die Eigenschaft TimeUnit festgelegt ist. Für zeitdiskrete Systeme geben Sie die Transportverzögerungen in ganzzahligen Vielfachen der Abtastzeit Ts an.

Eingangsverzögerung für jeden Eingangskanal, die als eine der folgenden Optionen angegeben wird:

  • Skalar: Geben Sie die Eingangsverzögerung für ein SISO-System oder die gleiche Transportverzögerung für alle Eingänge eines Systems mit mehreren Eingängen an.

  • Nux1-Vektor: Geben Sie separate Eingangsverzögerungen für die Eingänge eines Systems mit mehreren Eingängen an, wobei Nu die Anzahl der Eingänge ist.

Für zeitkontinuierliche Systeme geben Sie die Eingangsverzögerungen in der Zeiteinheit an, die durch die Eigenschaft TimeUnit festgelegt ist. Für zeitdiskrete Systeme geben Sie die Eingangsverzögerungen in ganzzahligen Vielfachen der Abtastzeit Ts an.

Weitere Informationen finden Sie unter Time Delays in Linear Systems.

Ausgangsverzögerung für jeden Ausgangskanal, die als eine der folgenden Optionen angegeben wird:

  • Skalar: Geben Sie die Ausgangsverzögerung für ein SISO-System oder die gleiche Verzögerung für alle Ausgänge eines Systems mit mehreren Ausgängen an.

  • Nyx1-Vektor: Geben Sie separate Ausgangsverzögerungen für die Ausgänge eines Systems mit mehreren Ausgängen an, wobei Ny die Anzahl der Ausgänge ist.

Für zeitkontinuierliche Systeme geben Sie die Ausgangsverzögerungen in der Zeiteinheit an, die durch die Eigenschaft TimeUnit festgelegt ist. Für zeitdiskrete Systeme geben Sie die Ausgangsverzögerungen in ganzzahligen Vielfachen der Abtastzeit Ts an.

Weitere Informationen finden Sie unter Time Delays in Linear Systems.

Abtastzeit, angegeben als:

  • 0 bei zeitkontinuierlichen Systemen.

  • Ein positiver Skalar, der die Abtastzeit eines zeitdiskreten Systems angibt. Geben Sie Ts in der Zeiteinheit an, die durch die Eigenschaft TimeUnit festgelegt ist.

  • -1 für ein zeitdiskretes System mit einer nicht festgelegten Abtastzeit.

Hinweis

Eine Änderung von Ts bewirkt keine Diskretisierung oder Neuabtastung des Modells. Verwenden Sie zur Konvertierung zwischen zeitkontinuierlichen und zeitdiskreten Systemen c2d und d2c. Verwenden Sie d2d, um die Abtastzeit eines zeitdiskreten Systems zu ändern.

Die Zeitvariablen können folgende Einheiten haben:

  • 'nanoseconds'

  • 'microseconds'

  • 'milliseconds'

  • 'seconds'

  • 'minutes'

  • 'hours'

  • 'days'

  • 'weeks'

  • 'months'

  • 'years'

Die Änderung von TimeUnit hat keine Auswirkungen auf andere Eigenschaften, ändert aber das gesamte Systemverhalten. Verwenden Sie chgTimeUnit, um zwischen Zeiteinheiten zu konvertieren, ohne das Systemverhalten zu ändern.

Namen der Eingangskanäle, die als eine der folgenden Optionen angegeben werden:

  • Zeichenvektor, für Modelle mit einem Eingang.

  • Zellenarray von Zeichenvektoren, für Modelle mit mehreren Eingängen.

  • '', ohne Angabe von Namen, für beliebige Eingangskanäle.

Sie können aber auch Eingangsnamen für Modelle mit mehreren Eingängen mithilfe der automatischen Vektorerweiterung zuweisen. Wenn sys zum Beispiel ein Modell mit zwei Eingängen ist, geben Sie Folgendes ein:

sys.InputName = 'controls';

Die Eingangsnamen werden automatisch zu {'controls(1)';'controls(2)'} erweitert.

Sie können die Kurzschreibweise u verwenden, um auf die Eigenschaft InputName zu verweisen. Beispielsweise ist sys.u gleichbedeutend mit sys.InputName.

Verwenden Sie InputName, um:

  • Kanäle auf der Modellanzeige und in Diagrammen zu identifizieren.

  • Subsysteme von MIMO-Systemen zu extrahieren.

  • Verbindungspunkte festzulegen, wenn Sie Modelle miteinander verbinden.

Die Eingangskanäle können folgende Einheiten haben:

  • Zeichenvektor, für Modelle mit einem Eingang.

  • Zellenarray von Zeichenvektoren, für Modelle mit mehreren Eingängen.

  • '', ohne Angabe von Einheiten, für beliebige Eingangskanäle.

Verwenden Sie InputUnit, um die Einheiten des Eingangssignals anzugeben. InputUnit hat keine Auswirkung auf das Systemverhalten.

Eingangskanalgruppen, angegeben als Struktur. Verwenden Sie InputGroup, um die Eingangskanäle von MIMO-Systemen in Gruppen einzuteilen und jede Gruppe mit einem Namen zu versehen. Die Feldnamen von InputGroup sind die Gruppennamen und die Feldwerte sind die Eingangskanäle der einzelnen Gruppen. Geben Sie zum Beispiel Folgendes ein, um Eingangsgruppen mit den Namen controls und noise zu erstellen, die die Eingangskanäle 1 und 2 bzw. 3 und 5 enthalten.

sys.InputGroup.controls = [1 2];
sys.InputGroup.noise = [3 5];

Sie können dann das Subsystem von den controls-Eingängen auf alle Ausgänge extrahieren, indem Sie Folgendes verwenden:

sys(:,'controls')

Standardmäßig ist InputGroup eine Struktur ohne Felder.

Namen der Ausgangskanäle, die als eine der folgenden Optionen angegeben werden:

  • Zeichenvektor, für Modelle mit einem Ausgang.

  • Zellenarray von Zeichenvektoren, für Modelle mit mehreren Ausgängen.

  • '', ohne Angabe von Namen, für beliebige Ausgangskanäle.

Sie können aber auch Ausgangsnamen für Modelle mit mehreren Ausgängen mithilfe der automatischen Vektorerweiterung zuweisen. Wenn sys zum Beispiel ein Modell mit zwei Ausgängen ist, geben Sie Folgendes ein:

sys.OutputName = 'measurements';

Die Ausgangsnamen werden automatisch zu {'measurements(1)';'measurements(2)'} erweitert.

Sie können auch die Kurzschreibweise y verwenden, um auf die Eigenschaft OutputName zu verweisen. Beispielsweise ist sys.y gleichbedeutend mit sys.OutputName.

Verwenden Sie OutputName, um:

  • Kanäle auf der Modellanzeige und in Diagrammen zu identifizieren.

  • Subsysteme von MIMO-Systemen zu extrahieren.

  • Verbindungspunkte festzulegen, wenn Sie Modelle miteinander verbinden.

Die Ausgangskanäle können folgende Einheiten haben:

  • Zeichenvektor, für Modelle mit einem Ausgang.

  • Zellenarray von Zeichenvektoren, für Modelle mit mehreren Ausgängen.

  • '', ohne Angabe von Einheiten, für beliebige Ausgangskanäle.

Verwenden Sie OutputUnit, um die Einheiten des Ausgangssignals anzugeben. OutputUnit hat keine Auswirkung auf das Systemverhalten.

Ausgangskanalgruppen, angegeben als Struktur. Verwenden Sie OutputGroup, um die Ausgangskanäle von MIMO-Systemen in Gruppen einzuteilen und jede Gruppe mit einem Namen zu versehen. Die Feldnamen von OutputGroup sind die Gruppennamen und die Feldwerte sind die Ausgangskanäle der einzelnen Gruppen. Geben Sie zum Beispiel Folgendes ein, um Ausgangsgruppen mit den Namen temperature und measurement zu erstellen, die die Ausgangskanäle 1 bzw. 3 bzw. 5 enthalten.

sys.OutputGroup.temperature = [1];
sys.OutputGroup.measurement = [3 5];

Sie können dann das Subsystem von allen Eingängen in die measurement-Ausgänge extrahieren, indem Sie Folgendes verwenden:

sys('measurement',:)

Standardmäßig ist OutputGroup eine Struktur ohne Felder.

Systemname, angegeben als Zeichenvektor. Zum Beispiel: 'system_1'.

Vom Benutzer angegebener Text, den Sie mit dem System verknüpfen möchten, angegeben als Zeichenvektor oder Zellenarray von Zeichenvektoren. Zum Beispiel: 'System is MIMO'.

Benutzerspezifische Daten, die Sie mit dem System verknüpfen möchten, angegeben als beliebiger MATLAB-Datentyp.

Abtastgitter für Modellarrays, angegeben als Struktur-Array.

Verwenden Sie SamplingGrid, um die Variablenwerte zu verfolgen, die mit jedem Modell in einem Modellarray verbunden sind, einschließlich identifizierter linearer zeitinvarianter Modellarrays (IDLTI-Modellarrays).

Setzen Sie die Feldnamen der Struktur auf die Namen der Abtastvariablen. Setzen Sie die Feldwerte auf die Werte der Abtastvariablen, die mit jedem Modell im Array verbunden sind. Alle Abtastvariablen müssen numerische Skalare sein und alle Arrays der Abtastwerte müssen den Dimensionen des Modellarrays entsprechen.

Sie können zum Beispiel ein 11x1-Array mit linearen Modellen, sysarr, erstellen, indem Sie Schnappschüsse eines linearen zeitvariablen Systems zu den Zeiten t = 0:10 machen. Der folgende Code speichert die Zeitabtastungen mit den linearen Modellen.

 sysarr.SamplingGrid = struct('time',0:10)

In ähnlicher Weise können Sie ein 6x9-Modellarray M erstellen, indem Sie zwei Variablen, zeta und w, unabhängig voneinander abtasten. Der folgende Code ordnet die (zeta,w)-Werte M zu.

[zeta,w] = ndgrid(<6 values of zeta>,<9 values of w>)
M.SamplingGrid = struct('zeta',zeta,'w',w)

Wenn Sie M anzeigen, enthält jeder Eintrag im Array die entsprechenden Werte für zeta und w.

M
M(:,:,1,1) [zeta=0.3, w=5] =
 
        25
  --------------
  s^2 + 3 s + 25
 

M(:,:,2,1) [zeta=0.35, w=5] =
 
         25
  ----------------
  s^2 + 3.5 s + 25
 
...

Bei Modellarrays, die durch die Linearisierung eines Simulink®-Modells bei mehreren Parameterwerten oder Betriebspunkten erzeugt werden, füllt die Software das SamplingGrid automatisch mit den Variablenwerten auf, die den einzelnen Einträgen im Array entsprechen. Zum Beispiel füllen die Simulink Control Design™-Befehle linearize (Simulink Control Design) und slLinearizer (Simulink Control Design) das SamplingGrid automatisch auf.

Standardmäßig handelt es sich bei SamplingGrid um eine Struktur ohne Felder.

Objektfunktionen

Die folgenden Listen enthalten eine repräsentative Teilmenge der Funktionen, die Sie mit tf-Modellen verwenden können. Im Allgemeinen ist jede Funktion, die auf Dynamische Systemmodelle anwendbar ist, auch auf ein tf-Objekt anwendbar.

alle erweitern

stepStep response of dynamic system
impulseImpulse response plot of dynamic system; impulse response data
lsimPlot simulated time response of dynamic system to arbitrary inputs; simulated response data
bodeBode plot of frequency response, or magnitude and phase data
nyquistNyquist plot of frequency response
nicholsNichols chart of frequency response
bandwidthFrequency response bandwidth
polePoles of dynamic system
zeroZeros and gain of SISO dynamic system
pzplotPole-zero plot of dynamic system model with additional plot customization options
marginGain margin, phase margin, and crossover frequencies
zpkZero-pole-gain model
ssState-space model
c2dConvert model from continuous to discrete time
d2cConvert model from discrete to continuous time
d2dResample discrete-time model
feedbackFeedback connection of multiple models
connectBlock diagram interconnections of dynamic systems
seriesReihenschaltung von zwei Modellen
parallelParallel connection of two models
pidtunePID tuning algorithm for linear plant model
rlocusWurzelortskurve dynamischer Systeme
lqrEntwurf eines linear-quadratischen Reglers (LQR)
lqgLinear-Quadratic-Gaussian (LQG) design
lqiLinear-quadratisch-integrale Steuerung
kalmanDesign Kalman filter for state estimation

Beispiele

alle reduzieren

Betrachten Sie in diesem Beispiel das folgende SISO-Transferfunktionsmodell:

sys(s)=12s2+3s+4.

Geben Sie die Zähler- und Nennerkoeffizienten in absteigenden Potenzen von s an und erstellen Sie das Transferfunktionsmodell.

numerator = 1;
denominator = [2,3,4];
sys = tf(numerator,denominator)
sys =
 
         1
  ---------------
  2 s^2 + 3 s + 4
 
Continuous-time transfer function.

Betrachten Sie in diesem Beispiel das folgende zeitdiskrete SISO-Transferfunktionsmodell:

sys(z)=2z4z3+3z-1.

Geben Sie die Zähler- und Nennerkoeffizienten in absteigenden Potenzen von z an und verwenden Sie eine Abtastzeit von 0,1 Sekunden. Erstellen Sie das zeitdiskrete Transferfunktionsmodell.

numerator = [2,0];
denominator = [4,0,3,-1];
ts = 0.1;
sys = tf(numerator,denominator,ts)
sys =
 
        2 z
  ---------------
  4 z^3 + 3 z - 1
 
Sample time: 0.1 seconds
Discrete-time transfer function.

Betrachten Sie in diesem Beispiel ein Transferfunktionsmodell, das ein System zweiter Ordnung mit bekannter Eigenfrequenz und bekanntem Dämpfungsverhältnis darstellt.

Die Transferfunktion eines Systems zweiter Ordnung, ausgedrückt durch das Dämpfungsverhältnis ζ und die Eigenfrequenz ω0 lautet:

sys(s)=ω02s2+2ζω0s+ω02.

Unter der Annahme des Dämpfungsverhältnisses ζ = 0,25 und der Eigenfrequenz ω0 = 3 rad/s, erstellen Sie die Transferfunktion zweiter Ordnung.

zeta = 0.25;
w0 = 3;
numerator = w0^2;
denominator = [1,2*zeta*w0,w0^2];
sys = tf(numerator,denominator)
sys =
 
         9
  ---------------
  s^2 + 1.5 s + 9
 
Continuous-time transfer function.

Untersuchen Sie die Antwort dieser Transferfunktion auf einen Eingangssprung.

stepplot(sys)

Figure contains an axes object. The axes object contains an object of type line. This object represents sys.

Das Diagramm zeigt das erwartete Abklingen eines Systems zweiter Ordnung mit einem geringen Dämpfungsverhältnis.

Erstellen Sie ein Transferfunktionsmodell für das folgende zeitdiskrete Modell mit mehreren Ein- und Ausgängen:

sys(z)=[1z+0.3zz+0.3-z+2z+0.33z+0.3]

mit einer Abtastzeit von ts = 0.2 Sekunden.

Geben Sie die Zählerkoeffizienten als 2x2-Matrix an.

numerators = {1 [1 0];[-1 2] 3};

Geben Sie die Koeffizienten des gemeinsamen Nenners als Zeilenvektor an.

denominator = [1 0.3];

Erstellen Sie das zeitdiskrete MIMO-Transferfunktionsmodell.

ts = 0.2;
sys = tf(numerators,denominator,ts)
sys =
 
  From input 1 to output...
          1
   1:  -------
       z + 0.3
 
       -z + 2
   2:  -------
       z + 0.3
 
  From input 2 to output...
          z
   1:  -------
       z + 0.3
 
          3
   2:  -------
       z + 0.3
 
Sample time: 0.2 seconds
Discrete-time transfer function.

Weitere Informationen zur Erstellung von MIMO-Transferfunktionen finden Sie unter MIMO-Transferfunktionen.

In diesem Beispiel erstellen Sie ein MIMO-Transferfunktionsmodell durch Verkettung von SISO-Transferfunktionsmodellen. Betrachten Sie die folgende Transferfunktion mit einem Eingang und zwei Ausgängen:

sys(s)=[s-1s+1s+2s2+4s+5].

Geben Sie das MIMO-Transferfunktionsmodell an, indem Sie die SISO-Einträge verketten.

sys1 = tf([1 -1],[1 1]);		
sys2 = tf([1 2],[1 4 5]);
sys = [sys1;sys2]
sys =
 
  From input to output...
       s - 1
   1:  -----
       s + 1
 
           s + 2
   2:  -------------
       s^2 + 4 s + 5
 
Continuous-time transfer function.

Weitere Informationen zur Erstellung von MIMO-Transferfunktionen finden Sie unter MIMO-Transferfunktionen.

In diesem Beispiel erstellen Sie ein zeitkontinuierliches Transferfunktionsmodell unter Verwendung rationaler Ausdrücke. Die Verwendung eines rationalen Ausdrucks kann manchmal einfacher und intuitiver sein als die Angabe von Polynomkoeffizienten für Zähler und Nenner.

Betrachten Sie das folgende System:

sys(s)=ss2+2s+10.

Um das Transferfunktionsmodell zu erstellen, geben Sie zunächst s als tf-Objekt an.

s = tf('s')
s =
 
  s
 
Continuous-time transfer function.

Erstellen Sie das Transferfunktionsmodell unter Verwendung von s im rationalen Ausdruck.

sys = s/(s^2 + 2*s + 10)
sys =
 
        s
  --------------
  s^2 + 2 s + 10
 
Continuous-time transfer function.

In diesem Beispiel erstellen Sie ein zeitdiskretes Transferfunktionsmodell unter Verwendung eines rationalen Ausdrucks. Die Verwendung eines rationalen Ausdrucks kann manchmal einfacher und intuitiver sein als die Angabe von Polynomkoeffizienten.

Betrachten Sie das folgende System:

sys(z)=z-1z2-1.85z+0.9.Discrete-time transfer function

Um das Transferfunktionsmodell zu erstellen, geben Sie zunächst z als tf-Objekt und die Abtastzeit Ts an.

ts = 0.1;
z = tf('z',ts)
z =
 
  z
 
Sample time: 0.1 seconds
Discrete-time transfer function.

Erstellen Sie das Transferfunktionsmodell unter Verwendung von z im rationalen Ausdruck.

sys = (z - 1) / (z^2 - 1.85*z + 0.9)
sys =
 
        z - 1
  ------------------
  z^2 - 1.85 z + 0.9
 
Sample time: 0.1 seconds
Discrete-time transfer function.

Für dieses Beispiel erstellen Sie ein Transferfunktionsmodell mit Eigenschaften, die von einem anderen Transferfunktionsmodell geerbt wurden. Betrachten Sie die folgenden beiden Transferfunktionen:

sys1(s)=2ss2+8sandsys2(s)=s-17s4+2s3+9.

In diesem Beispiel erstellen Sie sys1, wobei die Eigenschaften TimeUnit und InputDelay auf 'minutes' eingestellt sind.

numerator1 = [2,0];
denominator1 = [1,8,0];
sys1 = tf(numerator1,denominator1,'TimeUnit','minutes','InputUnit','minutes')
sys1 =
 
     2 s
  ---------
  s^2 + 8 s
 
Continuous-time transfer function.
propValues1 = [sys1.TimeUnit,sys1.InputUnit]
propValues1 = 1x2 cell
    {'minutes'}    {'minutes'}

Erstellen Sie das zweite Transferfunktionsmodell mit den von sys1 geerbten Eigenschaften.

numerator2 = [1,-1];
denominator2 = [7,2,0,0,9];
sys2 = tf(numerator2,denominator2,sys1)
sys2 =
 
        s - 1
  -----------------
  7 s^4 + 2 s^3 + 9
 
Continuous-time transfer function.
propValues2 = [sys2.TimeUnit,sys2.InputUnit]
propValues2 = 1x2 cell
    {'minutes'}    {'minutes'}

Beachten Sie, dass das Transferfunktionsmodell sys2 die gleichen Eigenschaften hat wie sys1.

Sie können eine for-Schleife verwenden, um ein Array von Transferfunktionsmodellen anzugeben.

Legen Sie zunächst das Array der Transferfunktionen mit Nullstellen an.

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

Die ersten beiden Indizes stehen für die Anzahl der Ausgänge und Eingänge der Modelle, während der dritte Index die Anzahl der Modelle im Array angibt.

Erstellen Sie das Array für die Transferfunktion mithilfe eines rationalen Ausdrucks in der for-Schleife.

s = tf('s');                                                  
for k = 1:3                                                             
    sys(:,:,k) = k/(s^2+s+k);                                          
end
sys
sys(:,:,1,1) =
 
       1
  -----------
  s^2 + s + 1
 

sys(:,:,2,1) =
 
       2
  -----------
  s^2 + s + 2
 

sys(:,:,3,1) =
 
       3
  -----------
  s^2 + s + 3
 
3x1 array of continuous-time transfer functions.

Berechnen Sie in diesem Beispiel die Transferfunktion des folgenden Zustandsraummodells:

A=[-2-11-2],B=[112-1],C=[10],D=[01].

Erstellen Sie das Zustandsraummodell unter Verwendung der Zustandsraummatrizen.

A = [-2 -1;1 -2];
B = [1 1;2 -1];
C = [1 0];
D = [0 1];
ltiSys = ss(A,B,C,D);

Konvertieren Sie das Zustandsraummodell ltiSys in eine Transferfunktion.

sys = tf(ltiSys)
sys =
 
  From input 1 to output:
        s
  -------------
  s^2 + 4 s + 5
 
  From input 2 to output:
  s^2 + 5 s + 8
  -------------
  s^2 + 4 s + 5
 
Continuous-time transfer function.

In diesem Beispiel extrahieren Sie die gemessenen Komponenten und die Rauschkomponenten eines identifizierten Polynommodells in zwei separate Transferfunktionen.

Laden Sie das Box-Jenkins-Polynommodell ltiSys in identifiedModel.mat.

load('identifiedModel.mat','ltiSys');

ltiSys ist ein identifiziertes zeitdiskretes Modell der Form: y(t)=BFu(t)+CDe(t), wobei BF die gemessene Komponente und CD die Rauschkomponente darstellt.

Extrahieren Sie die gemessenen Komponenten und die Rauschkomponenten als Transferfunktionen.

sysMeas = tf(ltiSys,'measured') 
sysMeas =
 
  From input "u1" to output "y1":
            -0.1426 z^-1 + 0.1958 z^-2
  z^(-2) * ----------------------------
           1 - 1.575 z^-1 + 0.6115 z^-2
 
Sample time: 0.04 seconds
Discrete-time transfer function.
sysNoise = tf(ltiSys,'noise')
sysNoise =
 
  From input "v@y1" to output "y1":
           0.04556 + 0.03301 z^-1
  ----------------------------------------
  1 - 1.026 z^-1 + 0.26 z^-2 - 0.1949 z^-3
 
Input groups:        
    Name     Channels
    Noise       1    
                     
Sample time: 0.04 seconds
Discrete-time transfer function.

Die gemessene Komponente kann als Regelstreckenmodell dienen, während die Rauschkomponente als Störungsmodell für den Entwurf des Regelungssystems verwendet werden kann.

Transferfunktions-Modellobjekte enthalten Modelldaten, die Ihnen helfen, den Überblick darüber zu behalten, was das Modell darstellt. So können Sie beispielsweise den Eingängen und Ausgängen Ihres Modells Namen zuweisen.

Betrachten Sie das folgende zeitdiskrete MIMO-Transferfunktionsmodell:

sys(s)=[s+1s2+2s+21s]

Dieses Modell hat einen Eingang -, Strom, und zwei Ausgänge -, Drehmoment und Winkelgeschwindigkeit.

Geben Sie zunächst die Zähler- und Nennerkoeffizienten des Modells an.

numerators = {[1 1] ; 1};
denominators = {[1 2 2] ; [1 0]};

Erstellen Sie das Transferfunktionsmodell und geben Sie die Namen der Eingänge und Ausgänge an.

sys = tf(numerators,denominators,'InputName','Current',...
        'OutputName',{'Torque' 'Angular Velocity'})
sys =
 
  From input "Current" to output...
                s + 1
   Torque:  -------------
            s^2 + 2 s + 2
 
                      1
   Angular Velocity:  -
                      s
 
Continuous-time transfer function.

In diesem Beispiel legen Sie die polynomiale Ordnung in zeitdiskreten Transferfunktionsmodellen mithilfe der Eigenschaft 'Variable' fest.

Betrachten Sie die folgenden zeitdiskreten Transferfunktionen mit einer Abtastzeit von 0,1 Sekunden:

sys1(z)=z2z2+2z+3sys2(z-1)=11+2z-1+3z-2.

Erstellen Sie die erste zeitdiskrete Transferfunktion, indem Sie die z-Koeffizienten angeben.

numerator = [1,0,0];
denominator = [1,2,3];
ts = 0.1;
sys1 = tf(numerator,denominator,ts)
sys1 =
 
       z^2
  -------------
  z^2 + 2 z + 3
 
Sample time: 0.1 seconds
Discrete-time transfer function.

Die Koeffizienten von sys1 sind in absteigenden Potenzen von z geordnet.

tf wechselt basierend auf dem Wert der Eigenschaft 'Variable' die Konvention. Da sys2 das inverse Transferfunktionsmodell von sys1 ist, geben Sie ‚z^-1‘ als ‚Variable‘ an und verwenden dieselben Koeffizienten für Zähler und Nenner.

sys2 = tf(numerator,denominator,ts,'Variable','z^-1')
sys2 =
 
           1
  -------------------
  1 + 2 z^-1 + 3 z^-2
 
Sample time: 0.1 seconds
Discrete-time transfer function.

Die Koeffizienten von sys2 sind jetzt in aufsteigenden Potenzen von z^-1 geordnet.

Basierend auf verschiedenen Konventionen können Sie die Polynomordnung in Transferfunktionsmodellen mithilfe der Eigenschaft 'Variable' festlegen.

In diesem Beispiel werden Sie einen Tiefpassfilter mit einem optimierbaren Parameter a erstellen:

F=as+a

Da die Koeffizienten von Zähler und Nenner eines tunableTF-Blocks unabhängig sind, können Sie tunableTF nicht zur Darstellung von F verwenden. Konstruieren Sie F stattdessen mit dem optimierbaren realen Parameterobjekt realp.

Erstellen Sie einen optimierbaren realen Parameter mit einem Anfangswert von 10.

a = realp('a',10)
a = 
       Name: 'a'
      Value: 10
    Minimum: -Inf
    Maximum: Inf
       Free: 1

Real scalar parameter.

Verwenden Sie tf, um den abstimmbaren Tiefpassfilter F zu erstellen.

numerator = a;
denominator = [1,a];
F = tf(numerator,denominator)
Generalized continuous-time state-space model with 1 outputs, 1 inputs, 1 states, and the following blocks:
  a: Scalar parameter, 2 occurrences.

Type "ss(F)" to see the current value and "F.Blocks" to interact with the blocks.

F ist ein genss-Objekt, das den optimierbaren Parameter a in seiner Blocks-Eigenschaft hat. Sie können F mit anderen optimierbaren oder numerischen Modellen verbinden, um komplexere Steuersystemmodelle zu erstellen. Ein Beispiel hierzu finden Sie unter Control System with Tunable Components.

In diesem Beispiel werden Sie ein MIMO-Transferfunktionsmodell mit statischer Verstärkung erstellen.

Betrachten Sie die folgende statische Verstärkungsmatrix m mit zwei Eingängen und zwei Ausgängen:

m=[2435]

Geben Sie die Verstärkungsmatrix an und erstellen Sie das Transferfunktionsmodell mit statischer Verstärkung.

m = [2,4;...
    3,5];
sys1 = tf(m)
sys1 =
 
  From input 1 to output...
   1:  2
 
   2:  3
 
  From input 2 to output...
   1:  4
 
   2:  5
 
Static gain.

Sie können das oben erhaltene Transferfunktionsmodell sys1 mit statischer Verstärkung verwenden, um es mit einem anderen Transferfunktionsmodell zu kaskadieren.

In diesem Beispiel erstellen Sie ein weiteres diskretes Transferfunktionsmodell mit zwei Eingängen und zwei Ausgängen und verwenden die series-Funktion, um die beiden Modelle zu verbinden.

numerators = {1,[1,0];[-1,2],3};
denominator = [1,0.3];
ts = 0.2;
sys2 = tf(numerators,denominator,ts)
sys2 =
 
  From input 1 to output...
          1
   1:  -------
       z + 0.3
 
       -z + 2
   2:  -------
       z + 0.3
 
  From input 2 to output...
          z
   1:  -------
       z + 0.3
 
          3
   2:  -------
       z + 0.3
 
Sample time: 0.2 seconds
Discrete-time transfer function.
sys = series(sys1,sys2)
sys =
 
  From input 1 to output...
       3 z^2 + 2.9 z + 0.6
   1:  -------------------
       z^2 + 0.6 z + 0.09
 
       -2 z^2 + 12.4 z + 3.9
   2:  ---------------------
        z^2 + 0.6 z + 0.09
 
  From input 2 to output...
       5 z^2 + 5.5 z + 1.2
   1:  -------------------
       z^2 + 0.6 z + 0.09
 
       -4 z^2 + 21.8 z + 6.9
   2:  ---------------------
        z^2 + 0.6 z + 0.09
 
Sample time: 0.2 seconds
Discrete-time transfer function.

Beschränkungen

  • Transferfunktionsmodelle sind für numerische Berechnungen schlecht geeignet. Konvertieren Sie die erstellten Modelle in die Zustandsraumform, bevor Sie sie mit anderen Modellen kombinieren oder Modelltransformationen durchführen. Sie können die resultierenden Modelle dann zu Prüfzwecken wieder in die Transferfunktionsform konvertieren.

  • Ein identifiziertes nichtlineares Modell kann nicht mit tf direkt in ein Transferfunktionsmodell umgewandelt werden. So erhalten Sie ein Transferfunktionsmodell:

    1. Konvertieren Sie das identifizierte nichtlineare Modell mit linapp (System Identification Toolbox), idnlarx/linearize (System Identification Toolbox) oder idnlhw/linearize (System Identification Toolbox) in ein identifiziertes LTI-Modell.

    2. Konvertieren Sie das resultierende Modell dann mit tf in ein Transferfunktionsmodell.

Versionsverlauf

Eingeführt vor R2006a