ss

Zustandsraummodell

Beschreibung

Verwenden Sie ss, um reellwertige oder komplexwertige Zustandsraummodelle zu erstellen oder um dynamische Systemmodelle in die Zustandsraummodell-Form zu konvertieren.

Ein Zustandsraummodell ist eine mathematische Darstellung eines physikalischen Systems als Eingangs-, Ausgangs- und Zustandsvariablen, die durch Differenzialgleichungen der ersten Ordnung miteinander verbunden sind. Die Zustandsvariablen definieren die Werte der Ausgangsvariablen. Das ss-Modellobjekt kann SISO- oder MIMO-Zustandsraummodelle in kontinuierlicher oder diskreter Zeit darstellen.

In kontinuierlicher Zeit weist ein Zustandsraummodell die folgende Form auf:

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

Hier stellen x, u und y die Zustände, Eingänge und Ausgänge dar; A, B, C und D stellen die Zustandsraum-Matrizen dar. In diskreter Zeit hat ein Zustandsraummodell die Form:

$$\begin{array}{l}x[n+1]=Ax[n]+Bu[n]\\ y[n]=Cx[n]+Du[n]\end{array}$$

Das ss-Objekt stellt ein zeitkontinuierliches oder zeitdiskretes Zustandsraummodell in MATLAB^® dar und speichert A, B, C und D zusammen mit anderen Informationen wie Abtastzeit, E/A-Namen, Verzögerungen und Offsets.

Sie können ein Zustandsraummodell erstellen, indem Sie entweder die Zustands-, Eingangs- und Ausgangsmatrizen direkt angeben oder ein Modell eines anderen Typs (wie ein Transferfunktionsmodell tf) in eine Zustandsraum-Form konvertieren. Weitere Informationen finden Sie unter Zustandsraummodelle. Sie können ein ss-Modellobjekt verwenden, um:

• Eine lineare Analyse vorzunehmen

• Ein lineares, zeitinvariantes Modell (LTI) für den Regelungsentwurf darzustellen

• Durch Kombination mit weiteren LTI-Modellen ein komplexeres System darzustellen

Erstellung

Syntax

sys = ss(A,B,C,D)

sys = ss(A,B,C,D,ts)

sys = ss(A,B,C,D,ltiSys)

sys = ss(D)

sys = ss(___,Name,Value)

sys = ss(ltiSys)

sys = ss(ltiSys,component)

sys = ss(ssSys,'minimal')

sys = ss(ssSys,'explicit')

Beschreibung

sys = ss(A,B,C,D) erstellt ein zeitkontinuierliches Zustandsraummodell-Objekt mit der folgenden Form:

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

Betrachten Sie beispielsweise eine Regelstrecke mit Nx Zuständen, Ny Ausgängen und Nu Eingängen. Die Zustandsraum-Matrizen sind:

• A ist eine Nx-mal-Nx-Matrix mit reellen oder komplexen Werten.

• B ist eine Nx-mal-Nu-Matrix mit reellen oder komplexen Werten.

• C ist eine Ny-mal-Nx-Matrix mit reellen oder komplexen Werten.

• D ist eine Ny-mal-Nu-Matrix mit reellen oder komplexen Werten.

sys = ss(A,B,C,D,ts) erstellt ein zeitdiskretes Zustandsraummodell-Objekt der folgenden Form mit der Abtastzeit ts (in Sekunden):

$$\begin{array}{l}x[n+1]=Ax[n]+Bu[n]\\ y[n]=Cx[n]+Du[n]\end{array}$$

Um die Abtastzeit nicht angeben zu müssen, setzen Sie ts auf -1.

sys = ss(A,B,C,D,ltiSys) erstellt ein Zustandsraummodell mit Eigenschaften wie Eingangs- und Ausgangsnamen, internen Verzögerungen und Abtastzeitwerten, die vom Modell ltisys geerbt werden.

sys = ss(D) erstellt ein Zustandsraummodell, das den statischen Verstärkungsfaktor D darstellt. Das Ausgangs-Zustandsraummodell ist äquivalent zu ss([],[],[],D).

sys = ss(___,Name,Value) legt die Eigenschaften des Zustandsraummodells mit einem oder mehreren Name,Value-Paar-Argumenten für eine beliebige vorherige Eingang-Argument-Kombination fest.

sys = ss(ltiSys) konvertiert das dynamische Systemmodell ltiSys in ein Zustandsraummodell. Wenn ltiSys optimierbare oder unsichere Elemente enthält, verwendet ss die aktuellen Werte bzw. Nennwerte für diese Elemente.

sys = ss(ltiSys,component) konvertiert die gemessene Komponente, die Rauschkomponente oder beide der angegebenen component eines identifizierten linearen zeitinvarianten Modells (LTI) ltiSys zu einer ss-Objektform. Verwenden Sie diese Syntax nur, wenn es sich bei ltiSys um ein identifiziertes lineares zeitinvariantes (LTI) Modell handelt, wie beispielsweise ein idtf (System Identification Toolbox)-, idss (System Identification Toolbox)-, idproc (System Identification Toolbox)-, idpoly (System Identification Toolbox)- oder idgrey (System Identification Toolbox)-Objekt.

sys = ss(ssSys,'minimal') gibt die minimale Zustandsraum-Realisierung ohne unkontrollierbare oder nicht beobachtbare Zustände aus. Die Realisierung ist äquivalent zu minreal(ss(sys)), wobei die Matrix A die kleinste mögliche Dimension aufweist.

Die Konvertierung in Zustandsraum-Form ist im Fall eines SISO nicht eindeutig definiert. Ebenfalls ist nicht garantiert, dass im MIMO-Fall eine minimale Realisierung erzeugt wird. Weitere Informationen finden Sie unter Recommended Working Representation.

sys = ss(ssSys,'explicit') gibt eine explizite Zustandsraum-Realisierung (E = I) des Zustandsraummodells des dynamischen Systems ssSys aus. ss gibt einen Fehler aus, wenn ssSys nicht korrekt ist. Weitere Informationen zur expliziten Zustandsraum-Realisierung finden Sie unter Zustandsraummodelle.

Eingangsargumente

A — Zustandsmatrix

Nx-mal-Nx-Matrix

Zustandsmatrix, angegeben als Nx-mal-Nx-Matrix, wobei Nx die Anzahl der Zustände ist. Dieser Eingang legt den Wert der Eigenschaft A fest.

B — Eingang-zu-Zustands-Matrix

Nx-mal-Nu-Matrix

Eingang-zu-Zustandsmatrix, angegeben als Nx-mal-Nu-Matrix, wobei Nx die Anzahl der Zustände und Nu die Anzahl der Eingänge ist. Dieser Eingang legt den Wert der Eigenschaft B fest.

C — Zustand-Ausgangs-Matrix

Ny-mal-Nx-Matrix

Zustand-Ausgangs-Matrix, angegeben als Ny-mal-Nx-Matrix, wobei Nx der Anzahl der Zustände und Ny der Anzahl der Ausgänge entspricht. Dieser Eingang legt den Wert der Eigenschaft C fest.

D — Feedthrough-Matrix

Ny-mal-Nu-Matrix

Feedthrough-Matrix, angegeben als Ny-mal-Nu-Matrix, wobei Ny der Anzahl der Ausgänge und Nu der Anzahl der Eingänge entspricht. Dieser Eingang legt den Wert der Eigenschaft D fest.

ts — Abtastzeit

Skalar

Abtastzeit, angegeben als ein Skalar. Weitere Informationen finden Sie beim Abschnitt zur Eigenschaft Ts.

ltiSys — Dynamisches System, das in die Zustandsraumform konvertiert werden soll

dynamisches Systemmodell | Modellarray

Dynamisches System, das in die Zustandsraumform konvertiert werden soll, angegeben als dynamisches SISO- oder MIMO-Systemmodell oder Array dynamischer Systemmodelle. Die von Ihnen konvertierbaren dynamischen Systeme umfassen:

• 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.)

  Das resultierend Zustandsraummodell geht von den folgenden Annahmen aus:

  • 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 ss standardmäßig die gemessene Komponente des identifizierten Modells. (Für die Verwendung von identifizierten Modellen ist die Software System Identification Toolbox™ erforderlich.)

component — Komponente des identifizierten Modells

'measured' (Standardeinstellung) | 'noise' | 'augmented'

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.

ssSys — Dynamisches Systemmodell, das in minimale Realisierung oder explizite Form konvertiert werden soll

ss-Modellobjekt

Dynamisches Systemmodell, das in minimale Realisierung oder explizite Form konvertiert werden soll, angegeben als ss-Modellobjekt.

Ausgangsargumente

sys — Ausgang des Systemmodells

ss-Modellobjekt | genss-Modellobjekt | uss Modellobjekt

Ausgang des Systemmodells, geliefert als:

• Ein Zustandsraum-Modellobjekt (ss), wenn die Eingänge A, B, C und D numerische Matrizen sind oder aus einem anderen Modellobjekt-Typ konvertiert werden.

• Ein verallgemeinertes Zustandsraum-Modellobjekt (genss), wenn eine oder mehr der Matrizen A, B, C und D optimierbare Parameter enthalten, wie z. B. realp-Parameter oder verallgemeinerte Matrizen (genmat). Ein Beispiel hierzu finden Sie unter Erstellen eines Zustandsraummodells mit festen und optimierbaren Parametern.

• Ein verallgemeinertes Zustandsraum-Modellobjekt (uss), wenn einer oder mehr der Eingänge A, B, C und D unsichere Matrizen enthält. Für die Verwendung unsicherer Modelle ist die Software Robust Control Toolbox erforderlich.

Eigenschaften

A — Zustandsmatrix

Nx-mal-Nx-Matrix

Zustandsmatrix, angegeben als Nx-mal-Nx-Matrix, wobei Nx die Anzahl der Zustände ist. Die Zustandsmatrix kann auf zahlreiche Weisen dargestellt werden, abhängig von der gewünschten Zustandsraummodell-Realisierung wie:

• Kanonische Modellform

• Begleitende kanonische Form

• Beobachtbare kanonische Form

• Regelbare kanonische Form

Weitere Informationen finden Sie unter State-Space Realizations.

B — Eingang-zu-Zustands-Matrix

Nx-mal-Nu-Matrix

Eingang-zu-Zustandsmatrix, angegeben als Nx-mal-Nu-Matrix, wobei Nx die Anzahl der Zustände und Nu die Anzahl der Eingänge ist.

C — Zustand-Ausgangs-Matrix

Ny-mal-Nx-Matrix

Zustand-Ausgangs-Matrix, angegeben als Ny-mal-Nx-Matrix, wobei Nx der Anzahl der Zustände und Ny der Anzahl der Ausgänge entspricht.

D — Feedthrough-Matrix

Ny-mal-Nu-Matrix

Feedthrough-Matrix, angegeben als Ny-mal-Nu-Matrix, wobei Ny der Anzahl der Ausgänge und Nu der Anzahl der Eingänge entspricht. D wird auch als statische Verstärkungsmatrix bezeichnet, die das Verhältnis von Ausgang zu Eingang unter Steady-State-Bedingungen darstellt.

E — Matrix für implizite Zustandsraummodelle

[] (Standardeinstellung) | Nx-mal-Nx-Matrix

Matrix für implizite Zustandsraummodelle oder Deskriptor-Zustandsraummodelle, angegeben als Nx-mal-Nx-Matrix. E ist standardmäßig leer, was bedeutet, dass die Zustandsgleichung explizit ist. Um eine implizite Zustandsgleichung E dx/dt = Ax + Bu festzulegen, setzen Sie diese Eigenschaft auf eine quadratische Matrix mit derselben Größe wie A. Unter dss finden Sie weiter Informationen zur Erstellung von Deskriptor-Zustandsraummodellen.

Offsets — Modell-Offsets

[] (Standardeinstellung) | Struktur

Seit R2024a

Modell-Offsets, angegeben als Struktur mit den folgenden Feldern.

Feld	Beschreibung
u	Eingangs-Offsets, angegeben als Vektor mit einer Länge, die der Anzahl der Eingänge entspricht.
y	Ausgangs-Offsets, angegeben als Vektor mit einer Länge, die der Anzahl der Ausgänge entspricht.
x	Zustands-Offsets, angegeben als Vektor mit einer Länge, die der Anzahl der Zustände entspricht.
dx	Zustandsableitungs-Offsets, angegeben als Vektor mit einer Länge, die der Anzahl der Zustände entspricht.

Setzen Sie bei Zustandsraum-Modellarrays Offsets auf ein Struktur-Array mit denselben Dimensionen wie das Modellarray.

Wenn Sie das nicht lineare Modell

$$\begin{array}{cc}\dot{x}=f(x,u),& y=g(x,u)\end{array}$$

um einen Betriebspunkt (x₀,u₀) linearisieren, ist das resultierende Modell ein Zustandsraummodell mit den folgenden Offsets:

$$\begin{array}{c}\dot{x}=\underset{{\delta }_0}{\underbrace{f(x_0,u_0)}}+A(x-x_0)+B(u-u_0)\\ y=\underset{y_0}{\underbrace{g(x_0,u_0)}}+C(x-x_0)+D(u-u_0),\end{array}$$

Dabei gilt:

$$\begin{array}{cccc}A=\frac{\partial f}{\partial x}(x_0,u_0),& B=\frac{\partial f}{\partial u}(x_0,u_0),& C=\frac{\partial g}{\partial x}(x_0,u_0),& D=\frac{\partial g}{\partial u}(x_0,u_0).\end{array}$$

Damit die Linearisierung eine gute Annäherung an die nicht linearen Maps darstellt, muss sie die Offsets δ₀, x₀, u₀ und y₀ umfassen. Der Befehl linearize (Simulink Control Design) gibt sowohl A, B, C, D als auch die Offsets aus, wenn die Option StoreOffset verwendet wird.

Diese Eigenschaft unterstützt Sie bei der Verwaltung von Linearisierungs-Offsets und der Verwendung bei Operationen wie der Antwort-Simulation, Modellverbindungen und Modelltransformationen.

Scaled — Logischer Wert, der angibt, ob die Skalierung aktiviert oder deaktiviert ist

0 (Standardeinstellung) | 1

Logischer Wert, der angibt, ob die Skalierung aktiviert oder deaktiviert ist, angegeben als 0 oder 1.

Ist Scaled auf 0 (deaktiviert) gesetzt, skalieren die meisten numerischen Algorithmen, die auf das Zustandsraummodell sys wirken, den Zustandsvektor automatisch, um die numerische Präzision zu verbessern. Sie können diese automatische Skalierung verhindern, indem Sie Scaled auf 1 (aktiviert) setzen.

Weitere Informationen über die Skalierung finden Sie unter prescale.

StateName — Zustandsnamen

' ' (Standardeinstellung) | Zeichenvektor | Zellenarray von Zeichenvektoren

Zustandsnamen, angegeben über eine der folgenden Methoden:

• Zeichenvektor – Für Modelle erster Ordnung, beispielsweise 'velocity'

• Zellenarray aus Zeichenvektoren – Für Modelle mit zwei oder mehr Zuständen

StateName ist bei allen Zuständen standardmäßig leer ' '.

StatePath — Zustandspfad

' ' (Standardeinstellung) | Zeichenvektor | Zellenarray von Zeichenvektoren

Zustandspfad für die Zustandsblock-Pfadverwaltung bei der Linearisierung, angegeben über eine der folgenden Methoden:

• Zeichenvektor – Für Modelle erster Ordnung

• Zellenarray aus Zeichenvektoren – Für Modelle mit zwei oder mehr Zuständen

StatePath ist bei allen Zuständen standardmäßig leer ' '.

StateUnit — Zustandseinheiten

' ' (Standardeinstellung) | Zeichenvektor | Zellenarray von Zeichenvektoren

Zustandseinheiten, angegeben über eine der folgenden Methoden:

• Zeichenvektor – Für Modelle erster Ordnung, beispielsweise 'm/s'

• Zellenarray aus Zeichenvektoren – Für Modelle mit zwei oder mehr Zuständen

Verwenden Sie StateUnit, um die Einheiten jedes Zustands nachzuverfolgen. StateUnit hat keine Auswirkungen auf das Verhalten des Systems. StateUnit ist bei allen Zuständen standardmäßig leer ' '.

InternalDelay — Interne Verzögerungen im Modell

Vektor

Interne Verzögerungen im Modell, angegeben als Vektor. Interne Verzögerungen treten beispielsweise auf, wenn Feedbackschleifen in Systemen mit Verzögerungen geschlossen werden oder verzögerte Systeme in Reihe oder parallel geschaltet werden. Weitere Informationen zu internen Verzögerungen finden Sie unter Closing Feedback Loops with Time Delays.

Bei zeitkontinuierlichen Modellen werden interne Verzögerungen in Zeiteinheiten ausgedrückt, angegeben durch die Eigenschaft TimeUnit des Modells. Bei zeitdiskreten Modellen werden interne Verzögerungen in ganzzahligen Vielfachen der Abtastzeit Ts ausgedrückt. InternalDelay = 3 ist beispielsweise eine Verzögerung um drei Abtastperioden.

Sie können die Werte der internen Verzögerungen anhand der Eigenschaft InternalDelay modifizieren. Die Anzahl Einträge in sys.InternalDelay kann jedoch nicht geändert werden, da es sich um eine strukturelle Eigenschaft des Modells handelt.

InputDelay — Eingangsverzögerung

0 (Standardeinstellung) | Skalar | Nux1-Vektor

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.

OutputDelay — Ausgangsverzögerung

0 (Standardeinstellung) | Skalar | Nyx1-Vektor

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.

Ts — Abtastzeit

0 (Standardeinstellung) | Positiver Skalar | -1

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.

TimeUnit — Einheiten der Zeitvariablen

'seconds' (Standardeinstellung) | 'nanoseconds' | 'microseconds' | 'milliseconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years' | ...

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.

InputName — Namen der Eingangskanäle

'' (Standardeinstellung) | Zeichenvektor | Zellenarray von Zeichenvektoren

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.

InputUnit — Einheiten der Eingangskanäle

'' (Standardeinstellung) | Zeichenvektor | Zellenarray von Zeichenvektoren

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.

InputGroup — Eingangskanalgruppen

Struktur

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.

OutputName — Namen der Ausgangskanäle

'' (Standardeinstellung) | Zeichenvektor | Zellenarray von Zeichenvektoren

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.

OutputUnit — Einheiten der Ausgangskanäle

'' (Standardeinstellung) | Zeichenvektor | Zellenarray von Zeichenvektoren

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.

OutputGroup — Ausgangskanalgruppen

Struktur

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.

Name — Systemname

'' (Standardeinstellung) | Zeichenvektor

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

Notes — Benutzerspezifischer Text

{} (Standardeinstellung) | Zeichenvektor | Zellenarray von Zeichenvektoren

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

UserData — Benutzerspezifische Daten

[] (Standardeinstellung) | beliebiger MATLAB-Datentyp

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

SamplingGrid — Abtastgitter für Modellarrays

Struktur-Array

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 ss-Modellobjekten verwenden können. Im Allgemeinen ist jede Funktion, die auf Dynamische Systemmodelle anwendbar ist, auch auf ein ss-Objekt anwendbar.

Lineare Analyse

step	Sprungantwort eines dynamischen Systems
impulse	Impulse response plot of dynamic system; impulse response data
lsim	Compute time response simulation data of dynamic system to arbitrary inputs
bode	Bode-Frequenzgang eines dynamischen Systems
nyquist	Nyquist-Antwort eines dynamischen Systems
nichols	Nichols response of dynamic system
bandwidth	Frequency response bandwidth

Stabilitätsanalyse

pole	Poles of dynamic system
zero	Zeros and gain of SISO dynamic system
pzplot	Plot pole-zero map of dynamic system
margin	Amplitudenrand, Phasenrand und Übergangsfrequenzen

Modelltransformation

zpk	Zero-pole-gain model
tf	Transferfunktionsmodelle
c2d	Konvertieren eines Modells von kontinuierlicher zu diskreter Zeit
d2c	Convert model from discrete to continuous time
d2d	Resample discrete-time model

Modellverbindung

feedback	Feedback-Verbindung mehrere Modelle
connect	Block diagram interconnections of dynamic systems
series	Reihenschaltung von zwei Modellen
parallel	Parallel connection of two models

Reglerentwurf

pidtune	PID tuning algorithm for linear plant model
rlocus	Wurzelort dynamischer Systeme
lqr	Entwurf eines linear-quadratischen Reglers (LQR)
lqg	Linear-Quadratic-Gaussian (LQG) design
lqi	Linear-quadratisch-integrale Steuerung
kalman	Design Kalman filter for state estimation

Beispiele

SISO-Zustandsraummodell

Erstellen Sie das SISO-Zustandsraummodell, das durch die folgenden Zustandsraum-Matrizen definiert ist:

$$A=\left[\begin{array}{cc}-1.5& -2\\ 1& 0\end{array}\right]B=\left[\begin{array}{c}0.5\\ 0\end{array}\right]C=\left[\begin{array}{cc}0& 1\end{array}\right]D=0$$

Geben Sie die Matrizen A, B, C und D an und erstellen Sie das Zustandsraummodell.

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

sys =
 
  A = 
         x1    x2
   x1  -1.5    -2
   x2     1     0
 
  B = 
        u1
   x1  0.5
   x2    0
 
  C = 
       x1  x2
   y1   0   1
 
  D = 
       u1
   y1   0
 
Continuous-time state-space model.
Model Properties

Erstellen eines zeitdiskreten Zustandsraummodells

Erstellen Sie ein Zustandsraummodell mit einer Abtastzeit von 0,25 Sekunden und den folgenden Zustandsraum-Matrizen:

$$A=\left[\begin{array}{cc}0& 1\\ -5& -2\end{array}\right]B=\left[\begin{array}{c}0\\ 3\end{array}\right]C=[\begin{array}{cc}0& 1\end{array}]D=[0]$$

Geben Sie die Zustandsraum-Matrizen an.

A = [0 1;-5 -2];
B = [0;3];
C = [0 1];
D = 0;

Geben Sie die Abtastzeit an.

Ts = 0.25;

Erstellen Sie das Zustandsraummodell.

sys = ss(A,B,C,D,Ts);

Zeitkontinuierliches MIMO-Zustandsraummodell

Betrachten Sie für dieses Beispiel einen Würfel, der sich auf einer Ecke dreht und einen Trägheitstensor J und eine Dämpfungskraft F mit Größe 0,2 aufweist. Der Eingang des Systems ist das Drehmoment, die Ausgänge sind die Winkelgeschwindigkeiten. Die Zustandsraum-Matrizen für den Würfel sind:

$$\begin{array}{l}A=-J^{-1}F,B=J^{-1},C=I,D=0,\\ where,J=\left[\begin{array}{ccc}8& -3& -3\\ -3& 8& -3\\ -3& -3& 8\end{array}\right]andF=\left[\begin{array}{ccc}0.2& 0& 0\\ 0& 0.2& 0\\ 0& 0& 0.2\end{array}\right]\end{array}$$

Legen Sie die Matrizen A, B, C und D fest und erstellen Sie das zeitkontinuierliche Zustandsraummodell.

J = [8 -3 -3; -3 8 -3; -3 -3 8];
F = 0.2*eye(3);
A = -J\F;
B = inv(J);
C = eye(3);
D = 0;
sys = ss(A,B,C,D)

sys =
 
  A = 
             x1        x2        x3
   x1  -0.04545  -0.02727  -0.02727
   x2  -0.02727  -0.04545  -0.02727
   x3  -0.02727  -0.02727  -0.04545
 
  B = 
           u1      u2      u3
   x1  0.2273  0.1364  0.1364
   x2  0.1364  0.2273  0.1364
   x3  0.1364  0.1364  0.2273
 
  C = 
       x1  x2  x3
   y1   1   0   0
   y2   0   1   0
   y3   0   0   1
 
  D = 
       u1  u2  u3
   y1   0   0   0
   y2   0   0   0
   y3   0   0   0
 
Continuous-time state-space model.
Model Properties

sys ist MIMO, da das System 3 Eingänge und 3 Ausgänge über die Matrizen C und D umfasst. Weitere Informationen zu MIMO-Zustandsraummodellen finden Sie unter MIMO State-Space Models.

Zeitdiskretes MIMO-Zustandsraummodell

Erstellen Sie ein Zustandsraummodell mithilfe der folgenden zeitdiskreten Zustandsmatrizen mit mehreren Eingängen und Ausgängen und einer Abtastzeit von ts = 0.2 Sekunden:

$$A=\left[\begin{array}{cc}-7& 0\\ 0& -10\end{array}\right]B=\left[\begin{array}{cc}5& 0\\ 0& 2\end{array}\right]C=\left[\begin{array}{cc}1& -4\\ -4& 0.5\end{array}\right]D=\left[\begin{array}{cc}0& -2\\ 2& 0\end{array}\right]$$

Geben Sie die Zustandsraum-Matrizen an und erstellen Sie das zeitdiskrete MIMO-Zustandsraummodell.

A = [-7,0;0,-10];
B = [5,0;0,2];
C = [1,-4;-4,0.5];
D = [0,-2;2,0];
ts = 0.2;
sys = ss(A,B,C,D,ts)

sys =
 
  A = 
        x1   x2
   x1   -7    0
   x2    0  -10
 
  B = 
       u1  u2
   x1   5   0
   x2   0   2
 
  C = 
        x1   x2
   y1    1   -4
   y2   -4  0.5
 
  D = 
       u1  u2
   y1   0  -2
   y2   2   0
 
Sample time: 0.2 seconds
Discrete-time state-space model.
Model Properties

Angeben der Zustands- und Eingangsnamen für das Zustandsraummodell

Erstellen Sie die Zustandsraummatrizen und legen Sie die Abtastzeit fest.

A = [-0.2516 -0.1684;2.784 0.3549];
B = [0;3];
C = [0 1];
D = 0;
Ts = 0.05;

Erstellen Sie das Zustandsraummodell und geben Sie über Name-Wert-Paare die Namen für Zustände und Eingänge an.

sys = ss(A,B,C,D,Ts,'StateName',{'Position' 'Velocity'},...
    'InputName','Force');

Die Anzahl der Zustands- und Eingangsnamen muss den Dimensionen von A, B, C und D entsprechen.

Die Eingänge und Ausgänge zu benennen, kann nützlich sein, wenn Sie mit den Antwortdiagrammen für MIMO-Systeme arbeiten.

step(sys)

Beachten Sie den Eingangsnamen Force im Titel des Schrittantwort-Diagramms.

Zustandsraummodell mit geerbten Eigenschaften

Für dieses Beispiel erstellen Sie ein Zustandsraummodell mit denselben Zeit- und Eingangseinheit-Eigenschaften, die von einem anderen Zustandsraummodell geerbt wurden. Betrachten Sie die folgenden Zustandsraummodelle:

$$\begin{array}{l}{A}_1=\left[\begin{array}{cc}-1.5& -2\\ 1& 0\end{array}\right]B_1=\left[\begin{array}{c}0.5\\ 0\end{array}\right]C_1=\left[\begin{array}{cc}0& 1\end{array}\right]D_1=5\\ A_2=\left[\begin{array}{cc}7& -1\\ 0& 2\end{array}\right]B_2=\left[\begin{array}{c}0.85\\ 2\end{array}\right]C_2=\left[\begin{array}{cc}10& 14\end{array}\right]D_2=2\end{array}$$

Erstellen Sie zunächst ein Zustandsraummodell sys1, dessen Eigenschaften TimeUnit und InputUnit auf „minutes“ gesetzt sind.

A1 = [-1.5,-2;1,0];
B1 = [0.5;0];
C1 = [0,1];
D1 = 5;
sys1 = ss(A1,B1,C1,D1,'TimeUnit','minutes','InputUnit','minutes');

Überprüfen Sie, ob die Zeit- und Eingangseinheit-Eigenschaften von sys1 auf „minutes“ gesetzt sind.

propValues1 = [sys1.TimeUnit,sys1.InputUnit]

propValues1 = 1×2 cell
    {'minutes'}    {'minutes'}

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

A2 = [7,-1;0,2];
B2 = [0.85;2];
C2 = [10,14];
D2 = 2;
sys2 = ss(A2,B2,C2,D2,sys1);

Überprüfen Sie, ob die Zeit- und Eingangseinheit-Eigenschaften von sys2 von sys1 geerbt wurden.

propValues2 = [sys2.TimeUnit,sys2.InputUnit]

propValues2 = 1×2 cell
    {'minutes'}    {'minutes'}

MIMO-Zustandsraummodell mit statischem Verstärkungsfaktor

In diesem Beispiel erstellen Sie ein MIMO-Zustandsraummodell mit statischem Verstärkungsfaktor.

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

$$D=\left[\begin{array}{cc}2& 4\\ 3& 5\end{array}\right]$$

Legen Sie die Verstärkungsmatrix fest und erstellen Sie das Zustandsraummodell mit statischem Verstärkungsfaktor.

D = [2,4;3,5];
sys1 = ss(D)

sys1 =
 
  D = 
       u1  u2
   y1   2   4
   y2   3   5
 
Static gain.
Model Properties

Konvertieren der Transferfunktion zu einem Zustandsraummodell

Berechnen Sie das Zustandsraummodell der folgenden Transferfunktion:

$$H\left(s\right)=\left[\begin{array}{c}\frac{s+1}{s^3+3s^2+3s+2}\\ \frac{s^2+3}{s^2+s+1}\end{array}\right]$$

Erstellen Sie das Transferfunktionsmodell.

H = [tf([1 1],[1 3 3 2]) ; tf([1 0 3],[1 1 1])];

Konvertieren Sie dieses Modell zu einem Zustandsraummodell.

sys = ss(H);

Untersuchen Sie die Größe des Zustandsraummodells.

size(sys)

State-space model with 2 outputs, 1 inputs, and 5 states.

Die Anzahl Zustände entspricht der kumulativen Ordnung der SISO-Einträge unter H(s).

Um eine minimale Realisierung von H(s) zu erfassen, geben Sie folgendes ein

sys = ss(H,'minimal');
size(sys)

State-space model with 2 outputs, 1 inputs, and 3 states.

Das resultierende Modell hat die Ordnung 3, die minimal erforderliche Anzahl Zustände, um H(s) darzustellen. Um diese Anzahl Zustände zu erlangen, ordnen Sie H(s) als Produkt eines Systems erster Ordnung und eines Systems zweiter Ordnung um.

$$H(s)=\left[\begin{array}{cc}\frac{1}{s+2}& 0\\ 0& 1\end{array}\right]\left[\begin{array}{c}\frac{s+1}{s^2+s+1}\\ \frac{s^2+3}{s^2+s+1}\end{array}\right]$$

Extrahieren von Zustandsraummodellen aus identifizierten Modellen

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

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

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

ltiSys ist ein identifiziertes zeitdiskretes Modell der Form: $$y(t)=\frac{B}{F}u(t)+\frac{C}{D}e(t)$$, wobei $$\frac{B}{F}$$ die gemessene Komponente und $$\frac{C}{D}$$ die Rauschkomponente darstellt.

Extrahieren Sie die gemessenen Komponenten und die Rauschkomponenten als Zustandsraummodelle.

sysMeas = ss(ltiSys,'measured') 

sysMeas =
 
  A = 
            x1       x2
   x1    1.575  -0.6115
   x2        1        0
 
  B = 
        u1
   x1  0.5
   x2    0
 
  C = 
            x1       x2
   y1  -0.2851   0.3916
 
  D = 
       u1
   y1   0
 
  Input delays (sampling periods): 2 
 
Sample time: 0.04 seconds
Discrete-time state-space model.
Model Properties

sysNoise = ss(ltiSys,'noise')

sysNoise =
 
  A = 
           x1      x2      x3
   x1   1.026   -0.26  0.3899
   x2       1       0       0
   x3       0     0.5       0
 
  B = 
       v@y1
   x1  0.25
   x2     0
   x3     0
 
  C = 
             x1        x2        x3
   y1     0.319  -0.04738   0.07106
 
  D = 
          v@y1
   y1  0.04556
 
Input groups:        
    Name     Channels
    Noise       1    
                     
Sample time: 0.04 seconds
Discrete-time state-space model.
Model Properties

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

Explizite Realisierung eines Deskriptor-Zustandsraummodells

Erstellen Sie ein Deskriptor-Zustandsraummodell (E ≠ I).

a = [2 -4; 4 2];
b = [-1; 0.5];
c = [-0.5, -2];
d = [-1];
e = [1 0; -3 0.5];
sysd = dss(a,b,c,d,e);

Berechnen Sie eine explizite Realisierung des Systems (E = I).

syse = ss(sysd,'explicit')

syse =
 
  A = 
        x1   x2
   x1    2   -4
   x2   20  -20
 
  B = 
       u1
   x1  -1
   x2  -5
 
  C = 
         x1    x2
   y1  -0.5    -2
 
  D = 
       u1
   y1  -1
 
Continuous-time state-space model.
Model Properties

Überprüfen Sie, ob Deskriptor und explizite Realisierungen eine äquivalente Dynamik aufweisen.

bodeplot(sysd,syse,'g--')

Erstellen eines Zustandsraummodells mit festen und optimierbaren Parametern

Dieses Beispiel demonstriert die Erstellung eines Zustandsraumgenss-Modells mit festen und optimierbaren Parametern.

$$A=\left[\begin{array}{cc}1& a+b\\ 0& ab\end{array}\right],B=\left[\begin{array}{c}-3.0\\ 1.5\end{array}\right],C=\left[\begin{array}{cc}0.3& 0\end{array}\right],D=0,$$

wobei a und b optimierbare Parameter sind, deren Anfangswerte -1 bzw. 3 sind.

Erstellen Sie die optimierbaren Parameter mithilfe von realp.

a = realp('a',-1);
b = realp('b',3);

Legen Sie eine verallgemeinerte Matrix mithilfe der algebraischen Ausdrücke a und b fest.

A = [1 a+b;0 a*b];

A ist eine verallgemeinerte Matrix, deren Eigenschaft Blocks a und b enthält. Der Anfangswert von A ist [1 2;0 -3], ausgehend von den Anfangswerten a und b.

Erstellen Sie die Zustandsraum-Matrizen mit festem Wert.

B = [-3.0;1.5];
C = [0.3 0];
D = 0;

Verwenden Sie ss zum Erstellen des Zustandsraummodells.

sys = ss(A,B,C,D)

Generalized continuous-time state-space model with 1 outputs, 1 inputs, 2 states, and the following blocks:
  a: Scalar parameter, 2 occurrences.
  b: Scalar parameter, 2 occurrences.
Model Properties

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

sys ist ein verallgemeinertes LTI-Modell (genss) mit den optimierbaren Parametern a und b.

Zustandsraummodell mit Eingangs- und Ausgangsverzögerung

Betrachten Sie für dieses Beispiel ein SISO-Zustandsraummodell, das von den folgenden Zustandsraum-Matrizen definiert ist:

$$A=\left[\begin{array}{cc}-1.5& -2\\ 1& 0\end{array}\right]B=\left[\begin{array}{c}0.5\\ 0\end{array}\right]C=\left[\begin{array}{cc}0& 1\end{array}\right]D=0$$

Erstellen Sie unter Annahme einer Eingangsverzögerung von 0,5 Sekunden und einer Ausgangsverzögerung von 2,5 Sekunden ein Zustandsraummodell-Objekt, um die Matrizen A, B, C und D darzustellen.

A = [-1.5,-2;1,0];
B = [0.5;0];
C = [0,1];
D = 0;
sys = ss(A,B,C,D,'InputDelay',0.5,'OutputDelay',2.5)

sys =
 
  A = 
         x1    x2
   x1  -1.5    -2
   x2     1     0
 
  B = 
        u1
   x1  0.5
   x2    0
 
  C = 
       x1  x2
   y1   0   1
 
  D = 
       u1
   y1   0
 
  Input delays (seconds): 0.5 
  Output delays (seconds): 2.5 
 
Continuous-time state-space model.
Model Properties

Zudem können Sie über den Befehl get alle Eigenschaften eines MATLAB-Objekts darstellen.

get(sys)

                A: [2×2 double]
                B: [2×1 double]
                C: [0 1]
                D: 0
                E: []
          Offsets: []
           Scaled: 0
        StateName: {2×1 cell}
        StatePath: {2×1 cell}
        StateUnit: {2×1 cell}
    InternalDelay: [0×1 double]
       InputDelay: 0.5000
      OutputDelay: 2.5000
        InputName: {''}
        InputUnit: {''}
       InputGroup: [1×1 struct]
       OutputName: {''}
       OutputUnit: {''}
      OutputGroup: [1×1 struct]
            Notes: [0×1 string]
         UserData: []
             Name: ''
               Ts: 0
         TimeUnit: 'seconds'
     SamplingGrid: [1×1 struct]

Weitere Informationen zur Angabe einer Zeitverzögerung für ein LTI-Modell finden Sie unter Specifying Time Delays.

Stabilitätsanalyse von Zustandsraumsystemen

Betrachten Sie für dieses Beispiel ein Zustandsraum-System object™, das die folgenden Zustandsmatrizen darstellt:

$$A=\left[\begin{array}{ccc}-1.2& -1.6& 0\\ 1& 0& 0\\ 0& 1& 0\end{array}\right],B=\left[\begin{array}{c}1\\ 0\\ 0\end{array}\right],C=\left[\begin{array}{ccc}0& 0.5& 1.3\end{array}\right],D=0,$$

Erstellen Sie über den Befehl ss ein Zustandsraum-Objekt sys.

A = [-1.2,-1.6,0;1,0,0;0,1,0];
B = [1;0;0];
C = [0,0.5,1.3];
D = 0;
sys = ss(A,B,C,D);

Berechnen Sie daraufhin das geschlossene Zustandsraummodell für eine negative Einheitsverstärkung und finden Sie die Polstellen des geschlossenen Zustandsraum-System object sysFeedback.

sysFeedback = feedback(sys,1);
P = pole(sysFeedback)

P = 3×1 complex

  -0.2305 + 1.3062i
  -0.2305 - 1.3062i
  -0.7389 + 0.0000i

Die Feedbackschleife für die Einheitsverstärkung ist stabil, da alle Polstellen negative reelle Teile aufweisen. Sie können die Stabilität binär beurteilen, indem Sie die geschlossenen Polstellen untersuchen. In der Praxis ist es oft hilfreicher, die Robustheit (oder Fragilität) der Stabilität zu kennen. Einen Hinweis auf die Robustheit gibt die mögliche Veränderung der Schleifenverstärkung, bevor die Stabilität verloren geht. Sie können das Wurzelort-Diagramm verwenden, um den Bereich der k-Werte mit stabiler Schleife zu schätzen.

rlocus(sys)

Veränderungen in der Schleifenverstärkung sind nur ein Aspekt einer robusten Stabilität. Im Allgemeinen bedeutet die nicht perfekte Modellierung der Regelstrecke, dass sowohl Verstärkung als auch Phase nicht genau bekannt sind. Da Modellierungsfehler im Bereich der Verstärkungs-Crossover-Frequenz (Frequenz, bei der die offene Schleifenverstärkung 0 dB beträgt) die schädlichste Auswirkung haben, ist zudem relevant, wie viel Phasenvariation bei dieser Frequenz toleriert wird.

Sie können die Verstärkung und Phasenränder folgendermaßen auf einem Bode-Diagramm darstellen.

bode(sys)
grid

Ein detailliertes Beispiel finden Sie unter Bewertung von Amplituden- und Phasenrändern.

Regelungsentwurf mit Zustandsraummodellen

In diesem Beispiel entwickeln Sie einen 2-DOF-PID-Regler mit einer Ziel-Bandbreite von 0,75 rad/s für ein System, das von den folgenden Matrizen dargestellt wird:

$$A=\left[\begin{array}{cc}-0.5& -0.1\\ 1& 0\end{array}\right],B=\left[\begin{array}{c}1\\ 0\end{array}\right],C=\left[\begin{array}{cc}0& 1\end{array}\right],D=0.$$

Erstellen Sie über den Befehl ss ein Zustandsraum-Objekt sys.

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

sys =
 
  A = 
         x1    x2
   x1  -0.5  -0.1
   x2     1     0
 
  B = 
       u1
   x1   1
   x2   0
 
  C = 
       x1  x2
   y1   0   1
 
  D = 
       u1
   y1   0
 
Continuous-time state-space model.
Model Properties

Verwenden Sie die Ziel-Bandbreite und pidtune, um einen 2-DOF-Regler zu generieren.

wc = 0.75;
C2 = pidtune(sys,'PID2',wc)

C2 =
 
                       1              
  u = Kp (b*r-y) + Ki --- (r-y) + Kd*s (c*r-y)
                       s              

  with Kp = 0.513, Ki = 0.0975, Kd = 0.577, b = 0.344, c = 0
 
Continuous-time 2-DOF PID controller in parallel form.
Model Properties

Verwenden Sie den Typ 'PID2', um mit pidtune einen 2-DOF-Regler zu generieren, der als pid2-Objekt dargestellt wird. Die Anzeige bestätigt dieses Ergebnis. Die Anzeige zeigt zudem, dass pidtune alle Regler-Koeffizienten optimiert, darunter die Sollpunkt-Gewichte b und c, um Leistung und Robustheit zu balancieren.

Mehr über interaktive PID-Optimierung im Live-Editor finden Sie im Live-Editor-Task Tune PID Controller. Mit diesem Task können Sie einen PID-Regler interaktiv entwickeln und MATLAB Programmcode für Ihr Live-Script automatisch generieren.

Verwenden Sie für die interaktive PID-Optimierung in einer eigenständigen App PID Tuner. Ein Beispiel zur Entwicklung eines Reglers mithilfe der App finden Sie unter Entwurf von PID-Reglern für eine schnelle Referenzverfolgung.

Verbinden bestimmter Eingänge und Ausgänge von Zustandsraummodellen in einer Feedbackschleife

Betrachten Sie eine Zustandsraum-Regelstrecke G mit fünf Eingängen und vier Ausgängen und einen Zustandsraum-Feedbackregler K mit drei Eingängen und zwei Ausgängen. Die Ausgänge 1, 3 und 4 der Regelstrecke G müssen mit den Eingängen des Reglers K verbunden sein; die Regler-Ausgänge müssen mit den Eingängen 4 und 2 der Regelstrecke verbunden sein.

Dieses Beispiel umfasst zwei zeitkontinuierliche Zustandsraummodelle für G und K, dargestellt von den folgenden Matrizen-Sätzen:

$$A_G=\left[\begin{array}{ccc}-3& 0.4& 0.3\\ -0.5& -2.8& -0.8\\ 0.2& 0.8& -3\end{array}\right],B_G=\left[\begin{array}{ccccc}0.4& 0& 0.3& 0.2& 0\\ -0.2& -1& 0.1& -0.9& -0.5\\ 0.6& 0.9& 0.5& 0.2& 0\end{array}\right],C_G=\left[\begin{array}{ccc}0& -0.1& -1\\ 0& -0.2& 1.6\\ -0.7& 1.5& 1.2\\ -1.4& -0.2& 0\end{array}\right],D_G=\left[\begin{array}{ccccc}0& 0& 0& 0& -1\\ 0& 0.4& -0.7& 0& 0.9\\ 0& 0.3& 0& 0& 0\\ 0.2& 0& 0& 0& 0\end{array}\right]$$

$$A_K=\left[\begin{array}{ccc}-0.2& 2.1& 0.7\\ -2.2& -0.1& -2.2\\ -0.4& 2.3& -0.2\end{array}\right],B_K=\left[\begin{array}{ccc}-0.1& -2.1& -0.3\\ -0.1& 0& 0.6\\ 1& 0& 0.8\end{array}\right],C_K=\left[\begin{array}{ccc}-1& 0& 0\\ -0.4& -0.2& 0.3\end{array}\right],D_K=\left[\begin{array}{ccc}0& 0& 0\\ 0& 0& -1.2\end{array}\right]$$

AG = [-3,0.4,0.3;-0.5,-2.8,-0.8;0.2,0.8,-3];
BG = [0.4,0,0.3,0.2,0;-0.2,-1,0.1,-0.9,-0.5;0.6,0.9,0.5,0.2,0];
CG = [0,-0.1,-1;0,-0.2,1.6;-0.7,1.5,1.2;-1.4,-0.2,0];
DG = [0,0,0,0,-1;0,0.4,-0.7,0,0.9;0,0.3,0,0,0;0.2,0,0,0,0];
sysG = ss(AG,BG,CG,DG)

sysG =
 
  A = 
         x1    x2    x3
   x1    -3   0.4   0.3
   x2  -0.5  -2.8  -0.8
   x3   0.2   0.8    -3
 
  B = 
         u1    u2    u3    u4    u5
   x1   0.4     0   0.3   0.2     0
   x2  -0.2    -1   0.1  -0.9  -0.5
   x3   0.6   0.9   0.5   0.2     0
 
  C = 
         x1    x2    x3
   y1     0  -0.1    -1
   y2     0  -0.2   1.6
   y3  -0.7   1.5   1.2
   y4  -1.4  -0.2     0
 
  D = 
         u1    u2    u3    u4    u5
   y1     0     0     0     0    -1
   y2     0   0.4  -0.7     0   0.9
   y3     0   0.3     0     0     0
   y4   0.2     0     0     0     0
 
Continuous-time state-space model.
Model Properties

AK = [-0.2,2.1,0.7;-2.2,-0.1,-2.2;-0.4,2.3,-0.2];
BK = [-0.1,-2.1,-0.3;-0.1,0,0.6;1,0,0.8];
CK = [-1,0,0;-0.4,-0.2,0.3];
DK = [0,0,0;0,0,-1.2];
sysK = ss(AK,BK,CK,DK)

sysK =
 
  A = 
         x1    x2    x3
   x1  -0.2   2.1   0.7
   x2  -2.2  -0.1  -2.2
   x3  -0.4   2.3  -0.2
 
  B = 
         u1    u2    u3
   x1  -0.1  -2.1  -0.3
   x2  -0.1     0   0.6
   x3     1     0   0.8
 
  C = 
         x1    x2    x3
   y1    -1     0     0
   y2  -0.4  -0.2   0.3
 
  D = 
         u1    u2    u3
   y1     0     0     0
   y2     0     0  -1.2
 
Continuous-time state-space model.
Model Properties

Definieren Sie die Vektoren feedout und feedin auf Grundlage der Eingänge und Ausgänge, die in der Feedbackschleife verbunden werden sollen.

feedin = [4 2];
feedout = [1 3 4];
sys = feedback(sysG,sysK,feedin,feedout,-1)

sys =
 
  A = 
           x1      x2      x3      x4      x5      x6
   x1      -3     0.4     0.3     0.2       0       0
   x2    1.18   -2.56    -0.8    -1.3    -0.2     0.3
   x3  -1.312   0.584      -3    0.56    0.18   -0.27
   x4   2.948  -2.929   -2.42  -0.452   1.974   0.889
   x5   -0.84   -0.11     0.1    -2.2    -0.1    -2.2
   x6   -1.12   -0.26      -1    -0.4     2.3    -0.2
 
  B = 
            u1       u2       u3       u4       u5
   x1      0.4        0      0.3      0.2        0
   x2    -0.44       -1      0.1     -0.9     -0.5
   x3    0.816      0.9      0.5      0.2        0
   x4  -0.2112    -0.63        0        0      0.1
   x5     0.12        0        0        0      0.1
   x6     0.16        0        0        0       -1
 
  C = 
           x1      x2      x3      x4      x5      x6
   y1       0    -0.1      -1       0       0       0
   y2  -0.672  -0.296     1.6    0.16    0.08   -0.12
   y3  -1.204   1.428     1.2    0.12    0.06   -0.09
   y4    -1.4    -0.2       0       0       0       0
 
  D = 
          u1     u2     u3     u4     u5
   y1      0      0      0      0     -1
   y2  0.096    0.4   -0.7      0    0.9
   y3  0.072    0.3      0      0      0
   y4    0.2      0      0      0      0
 
Continuous-time state-space model.
Model Properties

size(sys)

State-space model with 4 outputs, 5 inputs, and 6 states.

sys ist das resultierende geschlossene Zustandsraummodell, das durch Verbindung der festgelegten Eingänge und Ausgänge von G und K erstellt wird.

Erstellen eines Zustandsraummodells mit Offsets

Seit R2024a

Dieses Beispiel demonstriert die Linearisierung eines Simulink®-Modells und das Speichern der Linearisierungs-Offsets in der Eigenschaft Offsets des Modellobjekts ss.

Öffnen Sie das Simulink-Modell.

mdl = 'watertankNLModel';
open_system(mdl)

Legen Sie die Anfangsbedingung für die Wasserhöhe fest.

h0 = 10;

Legen Sie die linearen Analysepunkte des Modells fest.

io(1) = linio('watertankNLModel/Step',1,'input');
io(2) = linio('watertankNLModel/H',1,'output');

Simulieren Sie das Modell und extrahieren Sie die Betriebspunkte zu den Zeitpunkt-Snapshots.

tlin = [0 15 30];
op = findop(mdl,tlin);

Berechnen Sie das Linearisierungsergebnis und die Offsets.

options = linearizeOptions('StoreOffsets',true);
[linsys,~,info] = linearize(mdl,io,op,options);

Die Funktion gibt ein Array aus Zustandsraummodellen linsys und die entsprechenden Linearisierungs-Offsets in info.Offsets aus.

Die Eigenschaft Offsets des Modellobjekts ss erfordert eine Struktur mit den Feldern u, y, x und dx. Sie können den Ausgang info.Offsets von linearize verwenden, um diese Offsets direkt festzulegen.

linsys.Offsets = info.Offsets;
linsys.Offsets

ans=3×1 struct array with fields:
    dx
    x
    u
    y

Versionsverlauf

Eingeführt vor R2006a

R2024a: Erstellen von Zustandsraummodellen mit Offsets

Verwenden Sie die neue Offsets-Eigenschaft zur Speicherung von Modell-Offsets. Offsets entstehen normalerweise unter bestimmten Betriebsbedingungen bei der Linearisierung nicht linearer Dynamiken. Diese Eigenschaft unterstützt Sie bei der Verwaltung von Linearisierungs-Offsets und der Verwendung bei Operationen wie der Antwort-Simulation, Modellverbindungen und Modelltransformationen.

Siehe auch

dss | frd | get | set | ssdata | tf | zpk | genss | uss (Robust Control Toolbox) | mechss | sparss | ltvss | lpvss

Themen

• Dynamische Systemmodelle
• What Are Model Objects?
• Zustandsraummodelle
• MIMO State-Space Models
• State-Space Realizations
• Recommended Working Representation
• Time Delays in Linear Systems
• Specifying Time Delays