ss

Modello stato-spazio

Descrizione

Utilizzare ss per creare modelli stato-spazio a valore reale o a valore complesso oppure per convertire modelli di sistemi dinamici nella forma di modello stato-spazio.

Un modello stato-spazio è una rappresentazione matematica di un sistema fisico come un insieme di variabili di input, di output e di stato correlate da equazioni differenziali del primo ordine. Le variabili di stato definiscono i valori delle variabili di output. L'oggetto del modello ss può rappresentare modelli stato-spazio SISO o MIMO a tempo continuo o a tempo discreto.

A tempo continuo, un modello stato-spazio si presenta nella forma seguente:

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

In questo caso, x, u e y rappresentano rispettivamente gli stati, gli input e gli output, mentre A, B, C e D sono le matrici stato-spazio. A tempo discreto, un modello stato-spazio assume la forma:

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

L'oggetto ss rappresenta un modello stato-spazio a tempo continuo o a tempo discreto in MATLAB^® memorizzando A, B, C e D insieme ad altre informazioni, come il tempo di campionamento, i nomi di I/O, i ritardi e gli offset.

È possibile creare un oggetto del modello stato-spazio specificando direttamente le matrici di stato, di input e di output oppure convertendo un modello di altro tipo (come un modello di funzione di trasferimento tf) nella forma di stato-spazio. Per ulteriori informazioni, vedere Modelli stato-spazio. È possibile utilizzare un oggetto del modello ss per:

• Eseguire l'analisi lineare

• Rappresentare un modello lineare a tempo invariante (LTI) per eseguire la progettazione di controllo

• Eseguire un abbinamento con altri modelli LTI per rappresentare un sistema più complesso

Creazione

Sintassi

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

Descrizione

sys = ss(A,B,C,D) crea un oggetto del modello stato-spazio a tempo continuo nella forma seguente:

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

Ad esempio, si consideri un impianto con Nx stati, Ny output e Nu input. Le matrici stato-spazio sono:

• A è una matrice Nx x Nx a valore reale o a valore complesso.

• B è una matrice Nx x Nu a valore reale o a valore complesso.

• C è una matrice Ny x Nx a valore reale o a valore complesso.

• D è una matrice Ny x Nu a valore reale o a valore complesso.

sys = ss(A,B,C,D,ts) crea un oggetto del modello stato-spazio a tempo discreto nella forma seguente, con il tempo di campionamento ts (in secondi):

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

Se non si desidera specificare il tempo di campionamento, impostare ts su -1.

sys = ss(A,B,C,D,ltiSys) crea un modello stato-spazio con proprietà quali i nomi degli input e degli output, i ritardi interni e i valori del tempo di campionamento ereditati dal modello ltisys.

sys = ss(D) crea un modello stato-spazio che rappresenta il guadagno statico D. Il modello stato-spazio di output equivale a ss([],[],[],D).

sys = ss(___,Name,Value) imposta le proprietà del modello stato-spazio utilizzando uno o più argomenti della coppia Name,Value per una qualsiasi delle precedenti combinazioni input-argomento.

sys = ss(ltiSys) converte il modello di sistema dinamico ltiSys in un modello stato-spazio. Se ltiSys contiene elementi sincronizzabili o incerti, ss utilizza rispettivamente i valori correnti o nominali di tali elementi.

sys = ss(ltiSys,component) converte nella forma dell'oggetto ss il componente misurato, il componente di rumore o entrambi i componenti di un component specificato di un modello lineare a tempo invariante (LTI) ltiSys. Utilizzare questa sintassi solo quando ltiSys è un modello identificato (LTI), come un oggetto idtf (System Identification Toolbox), idss (System Identification Toolbox), idproc (System Identification Toolbox), idpoly (System Identification Toolbox) o idgrey (System Identification Toolbox).

sys = ss(ssSys,'minimal') restituisce la realizzazione minima dello stato-spazio priva di stati non controllabili o non osservabili. Questa realizzazione equivale a minreal(ss(sys)), dove la matrice A ha la dimensione più piccola possibile.

La conversione nella forma stato-spazio non è definita in modo univoco nel caso SISO. Inoltre, non è garantito che produca una realizzazione minima nel caso MIMO. Per ulteriori informazioni, vedere Recommended Working Representation.

sys = ss(ssSys,'explicit') restituisce una realizzazione esplicita dello stato-spazio (E = I) del modello stato-spazio di sistema dinamico ssSys. ss restituisce un errore se ssSys non è adeguato. Per ulteriori informazioni sulla realizzazione esplicita dello stato-spazio, vedere Modelli stato-spazio.

Argomenti di input

A — Matrice di stato

Matrice Nx x Nx

Matrice di stato, specificata come matrice Nx x Nx, dove Nx è il numero degli stati. Questo input imposta il valore della proprietà A.

B — Matrice input-stato

Matrice Nx x Nu

Matrice input-stato, specificata come una matrice Nx x Nu, dove Nx è il numero degli stati e Nu è il numero degli input. Questo input imposta il valore della proprietà B.

C — Matrice stato-output

Matrice Ny x Nx

Matrice stato-output, specificata come una matrice Ny x Nx, dove Nx è il numero di stati e Ny è il numero di output. Questo input imposta il valore della proprietà C.

D — Matrice feedthrough

Matrice Ny x Nu

Matrice feedthrough, specificata come una matrice Ny x Nu, dove Ny è il numero di output e Nu è il numero di input. Questo input imposta il valore della proprietà D.

ts — Tempo di campionamento

scalare

Tempo di campionamento, specificato come scalare. Per ulteriori informazioni, vedere la proprietà Ts.

ltiSys — Sistema dinamico da convertire nella forma stato-spazio

modello di sistema dinamico | array del modello

Sistema dinamico da convertire nella forma stato-spazio, specificato come un modello di sistema dinamico SISO o MIMO o come array di modelli di sistema dinamico. I sistemi dinamici che si possono convertire includono:

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

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

  Il modello stato-spazio risultante assume

  • i valori attuali dei componenti sincronizzabili per i blocchi di progettazione del controllo di sincronizzazione.

  • i valori nominali del modello per i blocchi di progettazione del controllo incerto.

• Modelli LTI identificati, come i modelli idtf (System Identification Toolbox), idss (System Identification Toolbox), idproc (System Identification Toolbox), idpoly (System Identification Toolbox) e idgrey (System Identification Toolbox). Per selezionare il componente del modello identificato da convertire, specificare component. Se non si specifica component, ss converte il componente misurato del modello identificato per impostazione predefinita. (Per utilizzare i modelli identificati è necessario disporre del software System Identification Toolbox™).

component — Componente del modello identificato

'measured' (predefinito) | 'noise' | 'augmented'

Componente del modello identificato da convertire, specificato in uno dei seguenti modi:

• 'measured': convertire il componente misurato di sys.

• 'noise': convertire il componente di rumore di sys

• 'augmented': converte sia il componente misurato che il componente di rumore di sys.

component si applica solo quando sys è un modello LTI identificato.

Per ulteriori informazioni sui modelli LTI identificati e sui relativi componenti misurati e di rumore, vedere Identified LTI Models.

ssSys — Modello di sistema dinamico da convertire in realizzazione minima o in forma esplicita

oggetto del modello ss

Modello di sistema dinamico da convertire in realizzazione minima o in forma esplicita, specificato come un oggetto del modello ss.

Argomenti di output

sys — Modello del sistema di output

oggetto del modello ss | oggetto del modello genss | oggetto del modello uss

Modello del sistema di output, restituito come:

• Un oggetto del modello stato-spazio (ss), quando gli input A, B, C e D sono matrici numeriche o quando si converte da un altro tipo di oggetto del modello.

• Un oggetto del modello stato-spazio generalizzato (genss), quando una o più delle matrici A, B, C e D includono parametri sincronizzabili, come i parametri realp o le matrici generalizzate (genmat). Per un esempio, vedere Creazione di modelli stato-spazio con parametri fissi e sincronizzabili.

• Un oggetto del modello stato-spazio incerto (uss), quando uno o più input A, B, C e D includono matrici incerte. Per utilizzare i modelli incerti è necessario disporre del software Robust Control Toolbox.

Proprietà

A — Matrice di stato

Matrice Nx x Nx

Matrice di stato, specificata come una matrice Nx x Nx, dove Nx è il numero di stati. La matrice di stato può essere rappresentata in molti modi a seconda della realizzazione del modello stato-spazio desiderato, come ad esempio:

• Forma canonica del modello

• Forma canonica compagna

• Forma canonica osservabile

• Forma canonica controllabile

Per ulteriori informazioni, vedere State-Space Realizations.

B — Matrice input-stato

Matrice Nx x Nu

Matrice input-stato, specificata come una matrice Nx x Nu, dove Nx è il numero di stati e Nu è il numero di input.

C — Matrice stato-output

Matrice Ny x Nx

Matrice stato-output, specificata come una matrice Ny x Nx, dove Nx è il numero di stati e Ny è il numero di output.

D — Matrice feedthrough

Matrice Ny x Nu

Matrice feedthrough, specificata come una matrice Ny x Nu, dove Ny è il numero di output e Nu è il numero di input. D è anche chiamata matrice di guadagno statico che rappresenta il rapporto tra gli output e gli input in condizioni di stato stazionario.

E — Matrice per modelli impliciti stato-spazio

[] (predefinito) | Matrice Nx x Nx

Matrice per modelli impliciti o descrittori stato-spazio, specificata come una matrice Nx x Nx. Per impostazione predefinita, E è vuoto, a indicare che l'equazione di stato è esplicita. Per specificare un'equazione di stato implicita E dx/dt = Ax + Bu, impostare questa proprietà su una matrice quadrata della stessa grandezza di A. Per ulteriori informazioni sulla creazione di modelli stato-spazio descrittori, vedere dss.

Offsets — Offset del modello

[] (predefinito) | struttura

Da R2024a

Offset del modello, specificati come una struttura con questi campi.

Campo	Descrizione
u	Offset di input, specificati come un vettore di lunghezza pari al numero di input.
y	Offset di output, specificati come un vettore di lunghezza pari al numero di output.
x	Offset di stato, specificati come un vettore di lunghezza pari al numero di stati.
dx	Offset delle derivate di stato, specificati come un vettore di lunghezza pari al numero di stati.

Per gli array di modelli stato-spazio, impostare Offsets su un array di strutture con la stessa dimensione dell'array dei modelli.

Quando si linearizza il modello non lineare

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

intorno a un punto operativo (x₀, u₀), il modello risultante è un modello stato-spazio con offset:

$$\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}$$

dove

$$\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}$$

Affinché la linearizzazione rappresenti una buona approssimazione delle mappe non lineari, deve includere gli offset δ₀, x₀, u₀ e y₀. Il comando linearize (Simulink Control Design) restituisce sia A, B, C, D e gli offset quando si utilizza l'opzione StoreOffset.

Questa proprietà consente di gestire gli offset di linearizzazione e di utilizzarli in operazioni quali la simulazione della risposta, le interconnessioni e le trasformazioni del modello.

Scaled — Valore logico che indica se il ridimensionamento è abilitato o disabilitato

0 (predefinito) | 1

Valore logico che indica se il ridimensionamento è abilitato o disabilitato, specificato come 0 o 1.

Quando Scaled è impostato su 0 (disabilitato), la maggior parte degli algoritmi numerici che agiscono sul modello stato-spazio sys ridimensionano automaticamente il vettore di stato per migliorare la precisione numerica. Per impedire questo ridimensionamento automatico, impostare Scaled su 1 (abilitato).

Per ulteriori informazioni sul ridimensionamento, vedere prescale.

StateName — Nomi dello stato

' ' (predefinito) | vettore di caratteri | array di celle dei vettori di caratteri

Nomi dello stato, specificati in uno dei seguenti modi:

• Vettore di caratteri: per i modelli del primo ordine, ad esempio 'velocity'

• Array di celle di vettori di caratteri: per i modelli con due o più stati

Per impostazione predefinita, StateName è vuoto ' ' per tutti gli stati.

StatePath — Percorso dello stato

' ' (predefinito) | vettore di caratteri | array di celle dei vettori di caratteri

Percorso dello stato per facilitare la gestione del percorso del blocco di stato nella linearizzazione, specificato in uno dei seguenti modi:

• Vettore di caratteri: per i modelli del primo ordine

• Array di celle di vettori di caratteri: per i modelli con due o più stati

Per impostazione predefinita, StatePath è vuoto ' ' per tutti gli stati.

StateUnit — Unità dello stato

' ' (predefinito) | vettore di caratteri | array di celle dei vettori di caratteri

Unità dello stato, specificate in uno dei seguenti modi:

• Vettore di caratteri: per i modelli del primo ordine, ad esempio 'm/s'

• Array di celle di vettori di caratteri: per i modelli con due o più stati

Utilizzare StateUnit per tenere traccia delle unità di ogni stato. StateUnit non ha alcun effetto sul comportamento del sistema. Per impostazione predefinita, StateUnit è vuoto ' ' per tutti gli stati.

InternalDelay — Ritardi interni nel modello

vettore

Ritardi interni nel modello, specificati come un vettore. I ritardi interni si verificano, ad esempio, quando si chiudono i loop di feedback su sistemi con ritardi o quando si connettono sistemi ritardati in serie o in parallelo. Per ulteriori informazioni sui ritardi interni, vedere Closing Feedback Loops with Time Delays.

Per i modelli a tempo continuo, i ritardi interni sono espressi nell'unità di tempo specificata dalla proprietà TimeUnit del modello. Per i modelli a tempo discreto, i ritardi interni sono espressi come multipli interi del tempo di campionamento Ts. Ad esempio, InternalDelay = 3 indica un ritardo di tre periodi di campionamento.

È possibile modificare i valori dei ritardi interni utilizzando la proprietà InternalDelay. Tuttavia, il numero di voci in sys.InternalDelay non può cambiare in quanto si tratta di una proprietà strutturale del modello.

InputDelay — Ritardo di input

0 (predefinito) | scalare | Vettore Nu x 1

Ritardo di input per ciascun canale di input, specificato in uno dei seguenti modi:

• Scalare: specificare il ritardo di input di un sistema SISO o lo stesso ritardo per tutti gli input di un sistema a multiplo input.

• Vettore Nu x 1: specificare ritardi di input separati per l'input di un sistema a multiplo input, dove Nu è il numero di input.

Per i sistemi a tempo continuo, specificare i ritardi di input nell'unità di tempo specificata dalla proprietà TimeUnit. Per i sistemi a tempo discreto, specificare i ritardi di input in multipli interi del tempo di campionamento Ts.

Per ulteriori informazioni, vedere Time Delays in Linear Systems.

OutputDelay — Ritardo di output

0 (predefinito) | scalare | Vettore Ny x 1

Ritardo di output per ciascun canale di output, specificato in uno dei seguenti modi:

• Scalare: specificare il ritardo di output di un sistema SISO o lo stesso ritardo per tutti gli output di un sistema a multiplo output.

• Vettore Ny x 1: specificare ritardi di output separati per l'output di un sistema con multiplo output, dove Ny è il numero di output.

Per i sistemi a tempo continuo, specificare i ritardi di output nell'unità di tempo specificata dalla proprietà TimeUnit. Per i sistemi a tempo discreto, specificare i ritardi di output in multipli interi del tempo di campionamento Ts.

Per ulteriori informazioni, vedere Time Delays in Linear Systems.

Ts — Tempo di campionamento

0 (predefinito) | scalare positivo | -1

Tempo di campionamento, specificato come:

• 0 per sistemi a tempo continuo.

• Uno scalare positivo che rappresenta il periodo di campionamento di un sistema a tempo discreto. Specificare Ts nell'unità di tempo definita dalla proprietà TimeUnit.

• -1 per un sistema a tempo discreto con un tempo di campionamento non specificato.

Nota

La modifica di Ts non discretizza o ricampiona il modello. Per convertire tra le rappresentazioni a tempo continuo e a tempo discreto, utilizzare c2d e d2c. Per modificare il tempo di campionamento di un sistema a tempo discreto, utilizzare d2d.

TimeUnit — Unità della variabile tempo

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

Unità della variabile tempo, specificate in uno dei seguenti modi:

• 'nanoseconds'

• 'microseconds'

• 'milliseconds'

• 'seconds'

• 'minutes'

• 'hours'

• 'days'

• 'weeks'

• 'months'

• 'years'

La modifica di TimeUnit non ha alcun effetto sulle altre proprietà, ma cambia il comportamento complessivo del sistema. Utilizzare chgTimeUnit per convertire tra le unità di tempo senza modificare il comportamento del sistema.

InputName — Nomi dei canali di input

'' (predefinito) | vettore di caratteri | array di celle dei vettori di caratteri

Nomi dei canali di input, specificati in uno dei seguenti modi:

• Un vettore di caratteri, per i modelli a singolo input.

• Un array di celle dei vettori di caratteri, per i modelli a multiplo input.

• '', nessun nome specificato per qualsiasi canale di input.

In alternativa, è possibile assegnare i nomi agli input dei modelli a multiplo input utilizzando l'espansione automatica del vettore. Ad esempio, se sys è un modello a due input, inserire quanto segue.

sys.InputName = 'controls';

I nomi degli input si espandono automaticamente in {'controls(1)';'controls(2)'}.

È possibile utilizzare la notazione abbreviata u per fare riferimento alla proprietà InputName. Ad esempio, sys.u equivale a sys.InputName.

Utilizzare InputName per:

• Identificare i canali sulla visualizzazione del modello e sui grafici.

• Estrarre i sottosistemi dei sistemi MIMO.

• Specificare i punti di connessione quando si interconnettono i modelli.

InputUnit — Unità del canale di input

'' (predefinito) | vettore di caratteri | array di celle dei vettori di caratteri

Unità del canale di input, specificate in uno dei seguenti modi:

• Un vettore di caratteri, per i modelli a singolo input.

• Un array di celle dei vettori di caratteri, per i modelli a multiplo input.

• '', nessuna unità specificata per qualsiasi canale di input.

Utilizzare InputUnit per specificare le unità del segnale di input. InputUnit non ha alcun effetto sul comportamento del sistema.

InputGroup — Gruppi di canali di input

struttura

Gruppi di canali di input, specificati come struttura. Utilizzare InputGroup per suddividere i canali di input di sistemi MIMO in gruppi e fare riferimento a ciascun gruppo per nome. I nomi dei campi di InputGroup sono i nomi dei gruppi e i valori dei campi sono i canali di input di ciascun gruppo. Ad esempio, inserire quanto segue per creare gruppi di input denominati controls e noise che includono rispettivamente i canali di input 1 e 2 e i canali di input 3 e 5.

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

È quindi possibile estrarre il sottosistema dagli input controls tutti gli output utilizzando quanto segue.

sys(:,'controls')

Per impostazione predefinita, InputGroup è una struttura senza campi.

OutputName — Nomi dei canali di output

'' (predefinito) | vettore di caratteri | array di celle dei vettori di caratteri

Nomi dei canali di output, specificati in uno dei seguenti modi:

• Un vettore di caratteri, per i modelli a singolo output.

• Un array di celle dei vettori di caratteri, per i modelli a multiplo output.

• '', nessun nome specificato per qualsiasi canale di output.

In alternativa, è possibile assegnare i nomi agli output dei modelli a multiplo output utilizzando l'espansione automatica del vettore. Ad esempio, se sys è un modello a due output, inserire quanto segue.

sys.OutputName = 'measurements';

I nomi degli output si espandono automaticamente in {'measurements(1)';'measurements(2)'}.

È inoltre possibile utilizzare la notazione abbreviata y per fare riferimento alla proprietà OutputName. Ad esempio, sys.y equivale a sys.OutputName.

Utilizzare OutputName per:

• Identificare i canali sulla visualizzazione del modello e sui grafici.

• Estrarre i sottosistemi dei sistemi MIMO.

• Specificare i punti di connessione quando si interconnettono i modelli.

OutputUnit — Unità del canale di output

'' (predefinito) | vettore di caratteri | array di celle dei vettori di caratteri

Unità del canale di output, specificate in uno dei seguenti modi:

• Un vettore di caratteri, per i modelli a singolo output.

• Un array di celle dei vettori di caratteri, per i modelli a multiplo output.

• '', nessuna unità specificata per qualsiasi canale di output.

Utilizzare OutputUnit per specificare le unità del segnale di output. OutputUnit non ha alcun effetto sul comportamento del sistema.

OutputGroup — Gruppi di canali di output

struttura

Gruppi di canali di output, specificati come struttura. Utilizzare OutputGroup per suddividere i canali di output di sistemi MIMO in gruppi e fare riferimento a ciascun gruppo per nome. I nomi dei campi di OutputGroup sono i nomi dei gruppi e i valori dei campi sono i canali di output di ciascun gruppo. Ad esempio, creare gruppi di output denominati temperature e measurement che includono rispettivamente i canali di output 1 e i canali di output 3 e 5.

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

È quindi possibile estrarre il sottosistema da tutti gli input agli output measurement utilizzando quanto segue.

sys('measurement',:)

Per impostazione predefinita, OutputGroup è una struttura senza campi.

Name — Nome del sistema

'' (predefinito) | vettore di caratteri

Nome del sistema, specificato come vettore di caratteri. Ad esempio, 'system_1'.

Notes — Testo specificato dall'utente

{} (predefinito) | vettore di caratteri | array di celle dei vettori di caratteri

Testo specificato dall'utente che si desidera associare al sistema, specificato come vettore di caratteri o array di celle di vettori di caratteri. Ad esempio, 'System is MIMO'.

UserData — Dati specificati dall'utente

[] (predefinito) | qualsiasi tipo di dati di MATLAB

Dati specificati dall'utente che si desidera associare al sistema, specificati come qualsiasi tipo di dati di MATLAB.

SamplingGrid — Griglia di campionamento per array di modelli

array di strutture

Griglia di campionamento per array di modelli, specificata come array di strutture.

Utilizzare SamplingGrid per tracciare i valori delle variabili associate a ciascun modello in un array di modelli, compresi gli array di modelli a tempo lineare invariante identificati (IDLTI).

Impostare i nomi dei campi della struttura sui nomi delle variabili di campionamento. Impostare i valori dei campi sui valori delle variabili campionate associate a ciascun modello dell'array. Tutte le variabili di campionamento devono essere scalari numerici e tutti gli array di valori campionati devono corrispondere alle dimensioni dell'array del modello.

Ad esempio, è possibile creare un array di modelli lineari 11x1 sysarr, acquisendo istantanee di un sistema lineare a tempo variabile nei momenti t = 0:10. Il codice seguente memorizza i campioni temporali con i modelli lineari.

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

Analogamente, è possibile creare un array di modelli 6x9 M, campionando due variabili zeta e w in modo indipendente. Il codice seguente mappa i valori (zeta,w) su M.

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

Quando si visualizza M, ciascuna voce dell'array include i valori zeta e w corrispondenti.

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

Per gli array di modelli generati dalla linearizzazione di un modello Simulink^® con più valori di parametri o di punti operativi, il software popola automaticamente SamplingGrid con i valori delle variabili corrispondenti a ciascuna voce dell'array. Ad esempio, i comandi di Simulink Control Design™ linearize (Simulink Control Design) e slLinearizer (Simulink Control Design) popolano SamplingGrid automaticamente.

Per impostazione predefinita, SamplingGrid è una struttura senza campi.

Funzioni oggetto

I seguenti elenchi contengono un sottoinsieme rappresentativo delle funzioni utilizzabili con gli oggetti del modello ss. In linea generale, qualsiasi funzione applicabile a Modelli di sistemi dinamici è applicabile a un oggetto ss.

Analisi lineare

step	Risposta al gradino di un sistema dinamico
impulse	Impulse response plot of dynamic system; impulse response data
lsim	Compute time response simulation data of dynamic system to arbitrary inputs
bode	Risposta in frequenza di Bode del sistema dinamico
nyquist	Nyquist response of dynamic system
nichols	Nichols response of dynamic system
bandwidth	Frequency response bandwidth

Analisi di stabilità

pole	Poles of dynamic system
zero	Zeros and gain of SISO dynamic system
pzplot	Plot pole-zero map of dynamic system
margin	Margine di guadagno, margine di fase e frequenze di crossover

Trasformazione del modello

zpk	Zero-pole-gain model
tf	Modelli della funzione di trasferimento
c2d	Convertire il modello da tempo continuo a tempo discreto
d2c	Convert model from discrete to continuous time
d2d	Resample discrete-time model

Interconnessione del modello

feedback	Connessione di feedback di più modelli
connect	Block diagram interconnections of dynamic systems
series	Collegamento in serie di due modelli
parallel	Parallel connection of two models

Progettazione del controller

pidtune	PID tuning algorithm for linear plant model
rlocus	Luogo della radice del sistema dinamico
lqr	Progettazione del regolatore lineare quadratico (LQR)
lqg	Linear-Quadratic-Gaussian (LQG) design
lqi	Controllo lineare-quadratico-integrale
kalman	Design Kalman filter for state estimation

Esempi

Modello stato-spazio SISO

Creare il modello stato-spazio SISO definito dalle seguenti matrici stato-spazio:

$$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$$

Specificare le matrici A, B, C e D e creare il modello stato-spazio.

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

Creazione di un modello stato-spazio a tempo discreto

Creare un modello stato-spazio con un tempo di campionamento di 0,25 secondi e le seguenti matrici stato-spazio:

$$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]$$

Specificare le matrici stato-spazio.

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

Specificare il tempo di campionamento.

Ts = 0.25;

Creare il modello stato-spazio.

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

Modello stato-spazio MIMO a tempo continuo

Per questo esempio, si consideri un cubo che ruota attorno al suo vertice con tensore d'inerzia J e una forza di smorzamento F di grandezza 0,2. L'input del sistema è la coppia motrice, mentre le velocità angolari sono gli output. Le matrici stato-spazio per il cubo sono:

$$\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}$$

Specificare le matrici A, B, C e D e creare il modello stato-spazio a tempo continuo.

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 è un sistema MIMO poiché contiene 3 input e 3 output osservati dalle matrici C e D. Per ulteriori informazioni sui modelli stato-spazio MIMO, vedere MIMO State-Space Models.

Modello stato-spazio MIMO a tempo discreto

Creare un modello stato-spazio utilizzando le seguenti matrici di stato a tempo discreto, a più input e più output, con tempo di campionamento ts = 0.2 secondi:

$$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]$$

Specificare le matrici stato-spazio e creare il modello stato-spazio MIMO a tempo discreto.

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

Specifica dei nomi di stato e di input per il modello stato-spazio

Creare matrici stato-spazio e specificare il tempo di campionamento.

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

Creare il modello stato-spazio, specificando i nomi di stato e di input utilizzando le coppie nome-valore.

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

Il numero dei nomi di stato e di input deve essere coerente con le dimensioni di A, B, C e D.

Assegnare un nome agli input e agli output può risultare utile quando si tratta di grafici di risposta per i sistemi MIMO.

step(sys)

Si noti il nome dell'input Force nel titolo del grafico di risposta al gradino.

Modello stato-spazio con proprietà ereditate

Per questo esempio, creare un modello stato-spazio con le stesse proprietà di unità di tempo e di input ereditate da un altro modello stato-spazio. Si considerino i seguenti modelli stato-spazio:

$$\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}$$

Per prima cosa, creare un modello stato-spazio sys1 con le proprietà TimeUnit e InputUnit impostate su 'minutes'.

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

Verificare che le proprietà dell'unità di tempo e di input di sys1 siano impostate su 'minutes'.

propValues1 = [sys1.TimeUnit,sys1.InputUnit]

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

Creare il secondo modello stato-spazio con le proprietà ereditate da sys1.

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

Verificare che le unità di tempo e di input di sys2 siano state ereditate da sys1.

propValues2 = [sys2.TimeUnit,sys2.InputUnit]

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

Modello stato-spazio MIMO a guadagno statico

In questo esempio, si crea un modello stato-spazio MIMO a guadagno statico.

Si consideri la seguente matrice di guadagno statico a due input e due output:

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

Specificare la matrice di guadagno e creare il modello stato-spazio a guadagno statico.

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

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

Conversione della funzione di trasferimento in modello stato-spazio

Calcolare il modello stato-spazio della seguente funzione di trasferimento:

$$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]$$

Creare il modello di funzione di trasferimento.

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

Convertire questo modello in un modello stato-spazio.

sys = ss(H);

Esaminare la grandezza del modello stato-spazio.

size(sys)

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

Il numero di stati è pari all'ordine cumulativo delle voci SISO in H(s).

Per ottenere una realizzazione minima di H(s), immettere

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

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

Il modello risultante è un modello del terzo ordine, che è il numero minimo di stati necessario per rappresentare H(s). Per vedere questo numero di stati, fattorizzare nuovamente H(s) come il prodotto di un sistema del primo ordine e di un sistema del secondo ordine.

$$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]$$

Estrazione di modelli stato-spazio dal modello identificato

Per questo esempio, estrarre i componenti misurati e di rumore di un modello polinomiale identificato in due modelli stato-spazio separati.

Caricare il modello polinomiale Box-Jenkins ltiSys in identifiedModel.mat.

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

ltiSys è un modello a tempo discreto identificato di forma: $$y(t)=\frac{B}{F}u(t)+\frac{C}{D}e(t)$$, dove $$\frac{B}{F}$$ rappresenta il componente misurato e $$\frac{C}{D}$$ rappresenta il componente di rumore.

Estrarre i componenti misurati e di rumore come modelli stato-spazio.

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

Il componente misurato può servire come modello dell'impianto, mentre il componente di rumore può essere utilizzato come modello di disturbo per la progettazione del sistema di controllo.

Realizzazione esplicita del modello stato-spazio con descrittore

Creare un modello stato-spazio con descrittore (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);

Calcolare una realizzazione esplicita del sistema (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

Confermare che il descrittore e le realizzazioni esplicite presentano dinamiche equivalenti.

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

Creazione di modelli stato-spazio con parametri fissi e sincronizzabili

Questo esempio mostra come creare un modello stato-spazio genss con parametri fissi e sincronizzabili.

$$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,$$

dove a e b sono parametri sincronizzabili, i cui valori iniziali sono rispettivamente -1 e 3.

Creare i parametri sincronizzabili utilizzando realp.

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

Definire una matrice generalizzata utilizzando le espressioni algebriche di a e b.

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

A è una matrice generalizzata la cui proprietà Blocks contiene a e b. Il valore iniziale di A è [1 2;0 -3], dai valori iniziali di a e b.

Creare le matrici stato-spazio a valore fisso.

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

Utilizzare ss per creare il modello stato-spazio.

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 è un modello LTI generalizzato (genss) con parametri a e b sincronizzabili.

Modello stato-spazio con ritardi di input e di output

Per questo esempio, si consideri un modello stato-spazio SISO definito dalle seguenti matrici stato-spazio:

$$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$$

Considerando un ritardo di input di 0,5 secondi e un ritardo di output di 2,5 secondi, creare un oggetto del modello stato-spazio per rappresentare le matrici A, B, C e D.

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

È inoltre possibile utilizzare il comando get per visualizzare tutte le proprietà di un oggetto MATLAB.

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]

Per ulteriori informazioni sulla specifica del ritardo temporale per un modello LTI, vedere Specifying Time Delays.

Analisi di stabilità dei sistemi stato-spazio

Per questo esempio, si consideri un System object™ stato-spazio che rappresenti le seguenti matrici di stato:

$$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,$$

Creare un oggetto stato-spazio sys utilizzando il comando ss.

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

Quindi, calcolare il modello stato-spazio a loop chiuso per un guadagno negativo unitario e trovare i poli del System object stato-spazio a loop chiuso sysFeedback.

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

P = 3×1 complex

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

Il loop di feedback per il guadagno unitario è stabile poiché tutti i poli presentano parti reali negative. Il controllo dei poli a loop chiuso fornisce una valutazione binaria della stabilità. In pratica, è più utile sapere quanto la stabilità sia robusta (o fragile). Un'indicazione della robustezza è la misura in cui il guadagno del loop può variare prima che si perda la stabilità. È possibile utilizzare il grafico del luogo della radice per stimare l'intervallo di valori k per i quali il loop è stabile.

rlocus(sys)

Le variazioni del guadagno del loop sono solo un aspetto della stabilità robusta. In generale, una modellazione imperfetta dell'impianto indica che sia il guadagno che la fase non sono noti con esattezza. Poiché l'effetto degli errori di modellazione è più dannoso in prossimità della frequenza di crossover del guadagno (frequenza alla quale il guadagno a loop aperto è pari a 0 dB), un altro elemento importante è la variazione di fase che può essere tollerata a questa frequenza.

È possibile visualizzare i margini di guadagno e di fase in un grafico di Bode come segue.

bode(sys)
grid

Per un esempio più dettagliato, vedere Valutazione dei margini di guadagno e di fase.

Progettazione di controllo utilizzando i modelli stato-spazio

Per questo esempio, progettare un controller PID 2-DOF con una larghezza di banda target di 0,75 rad/s per un sistema rappresentato dalle seguenti matrici:

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

Creare un oggetto stato-spazio sys utilizzando il comando ss.

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

Utilizzando la larghezza di banda target, utilizzare pidtune per generare un controller 2-DOF.

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

L'utilizzo del tipo 'PID2', determina la generazione di un controller 2-DOF da parte di pidtune, rappresentato come un oggetto pid2. La visualizzazione conferma questo risultato. La visualizzazione mostra inoltre che pidtune sincronizza tutti i coefficienti del controller, inclusi i pesi dei setpoint b e c per bilanciare prestazioni e robustezza.

Per sincronizzare il PID in modo interattivo nel Live Editor, vedere l'attività Tune PID Controller Live Editor. Questa attività consente di progettare un controller PID in modo interattivo e genera automaticamente il codice MATLAB per lo script live.

Per sincronizzare il PID in modo interattivo in un'applicazione autonoma, utilizzare PID Tuner. Per un esempio di progettazione di un controller utilizzando l'app, vedere Progettazione di un controller PID per un tracking di riferimento veloce.

Connessioni di input e output specifici di modelli stato-spazio in un loop di feedback

Si consideri un impianto stato-spazio G con cinque input e quattro output e un controller stato-spazio di feedback K con tre input e due output. Gli output 1, 3 e 4 dell'impianto G devono essere connessi agli input del controller K e gli output del controller agli input 4 e 2 dell'impianto.

Per questo esempio, si considerino due modelli stato-spazio a tempo continuo sia per G che per K, rappresentati dal seguente insieme di matrici:

$$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

Definire i vettori feedout e feedin sulla base degli input e degli output da connettere in un loop di feedback.

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 è il modello stato-spazio a loop chiuso risultante, ottenuto connettendo gli input e gli output specificati di G e K.

Creazione del modello stato-spazio con offset

Da R2024a

Questo esempio mostra come linearizzare un modello Simulink® e memorizzare gli offset della linearizzazione nella proprietà Offsets dell'oggetto del modello ss.

Aprire il modello Simulink.

mdl = 'watertankNLModel';
open_system(mdl)

Specificare la condizione iniziale per l'altezza dell'acqua.

h0 = 10;

Specificare i punti di analisi lineare del modello.

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

Simulare il modello ed estrarre i punti operativi in corrispondenza di istanti specifici di tempo.

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

Calcolare il risultato della linearizzazione con gli offset.

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

La funzione restituisce un array di modelli stato-spazio linsys e i corrispondenti offset di linearizzazione in info.Offsets.

La proprietà Offsets dell'oggetto del modello ss richiede una struttura con i campi u, y, x e dx. Per impostare direttamente questi offset, è possibile utilizzare l'output info.Offsets da linearize.

linsys.Offsets = info.Offsets;
linsys.Offsets

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

Cronologia versioni

Introduzione prima di R2006a

R2024a: Creazione di modelli stato-spazio con offset

Utilizzare la nuova proprietà Offsets per memorizzare gli offset del modello. Gli offset si verificano di solito quando si linearizzano dinamiche non lineari in alcune condizioni operative. Questa proprietà consente di gestire gli offset di linearizzazione e di utilizzarli in operazioni quali la simulazione della risposta, le interconnessioni e le trasformazioni del modello.

Vedi anche

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

Argomenti

• Modelli di sistemi dinamici
• What Are Model Objects?
• Modelli stato-spazio
• MIMO State-Space Models
• State-Space Realizations
• Recommended Working Representation
• Time Delays in Linear Systems
• Specifying Time Delays