La traduction de cette page n'est pas à jour. Cliquez ici pour voir la dernière version en anglais.

ss

Modèle de représentation d'état

Description

Utilisez ss pour créer des modèles de représentation d'état à valeurs réelles ou complexes, ou pour convertir des modèles de systèmes dynamiques en modèles de représentation d'état. Vous pouvez également utiliser ss pour créer des modèles de représentation d’état généralisés (genss) ou incertains (uss (Robust Control Toolbox)).

Un modèle de représentation d’état est une représentation mathématique d’un système physique qui se présente sous la forme d’un ensemble de variables d’entrée, de sortie et d’état reliées par des équations différentielles de premier ordre. Les variables d’état définissent les valeurs des variables de sortie. L’objet modèle ss peut représenter des modèles de représentation d’état SISO ou MIMO en temps continu ou discret.

En temps continu, un modèle de représentation d'état présente la forme suivante :

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

.Ici, x, u et y représentent respectivement les états, les entrées et les sorties, tandis que A, B, C et D correspondent aux matrices de représentation d'état. L'objet ss représente un modèle de représentation d'état dans MATLAB^® stockant A, B, C et D avec d'autres informations telles que le pas d'échantillonnage, les noms et les retards propres aux entrées et aux sorties.

Vous pouvez créer un objet de modèle de représentation d’état en spécifiant directement les matrices d’états, les matrices d’entrées et de sorties ou en convertissant un modèle d’un autre type (tel qu’un modèle de fonction de transfert tf) en un modèle de représentation d'état. Pour plus d’informations, consultez State-Space Models. Vous pouvez utiliser un objet de modèle ss pour :

• Effectuer une analyse linéaire

• Représenter un modèle linéaire fixe dans le temps (LTI) pour effectuer un design de contrôle

• L’associer à d’autres modèles LTI pour représenter un système plus complexe

Création

Syntaxe

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

Description

sys = ss(A,B,C,D) crée un objet de modèle de représentation d’état en temps continu sous la forme suivante :

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

Par exemple, considérons un système physique comportant Nx états, Ny sorties et Nu entrées. Les matrices de représentation d’état sont :

• A est une matrice Nx par Nx à valeurs réelles ou complexes.

• B est une matrice Nx par Nu à valeurs réelles ou complexes.

• C est une matrice Ny par Nx à valeurs réelles ou complexes.

• D est une matrice Ny par Nu à valeurs réelles ou complexes.

sys = ss(A,B,C,D,ts) crée un objet de modèle de représentation d’état en temps discret sous la forme suivante avec le pas d’échantillonnage ts (en secondes) :

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

Pour ne pas spécifier le pas d’échantillonnage, définissez ts à -1.

sys = ss(A,B,C,D,ltiSys) crée un modèle de représentation d’état avec des propriétés telles que les noms des entrées et sorties, les retards internes et des valeurs de pas d’échantillonnage hérités du modèle ltisys.

sys = ss(D) crée un modèle de représentation d'état représentant le gain statique, D. Le modèle de représentation d’état de sortie équivaut à ss([],[],[],D).

sys = ss(___,Name,Value) définit les propriétés du modèle de représentation d’état au moyen d’une ou de plusieurs paires d'arguments Name,Value pour n'importe quelle combinaison entrée-argument précédente.

sys = ss(ltiSys) convertit le modèle de systèmes dynamiques ltiSys en un modèle de représentation d’état. Si ltiSys contient des éléments réglables ou incertains, ss utilise respectivement les valeurs actuelles ou nominales de ces éléments.

sys = ss(ltiSys,component) convertit en objet ss la composant mesurée, la composante de bruit ou les deux, du component spécifié du modèle identifié linéaire invariant dans le temps (LTI) ltiSys. Vous ne devez utiliser cette syntaxe que lorsque ltiSys est un modèle identifié (LTI) tel qu’un objet idtf (System Identification Toolbox), idss (System Identification Toolbox), idproc (System Identification Toolbox), idpoly (System Identification Toolbox) ou idgrey (System Identification Toolbox).

sys = ss(ssSys,'minimal') renvoie la réalisation minimale de représentation d'état sans états non contrôlables ou non détectables. Cette réalisation équivaut à minreal(ss(sys)) où la matrice A présente la plus petite dimension possible.

La conversion sous forme de représentation d’état n’est pas définie de manière unique dans le cas d’un SISO. Il n'est pas non plus garanti qu'elle permette d’obtenir une réalisation minimale dans le cas d’un MIMO. Pour plus d’informations, consultez Recommended Working Representation.

sys = ss(ssSys,'explicit') renvoie une réalisation explicite de représentation d’état (E = I) du modèle de représentation d’état de système dynamique ssSys. ss émet une erreur si ssSys est incorrecte. Pour plus d’informations sur les réalisations explicites de représentation d’état, consultez State-Space Models.

Arguments en entrée

A — Matrice d'état

Matrice Nx par Nx

Matrice d'état spécifiée en tant que matrice Nx par Nx où Nx désigne le nombre d’états. Cette entrée définit la valeur de la propriété A.

B — Matrice entrée-état

Matrice Nx par Nu

Matrice entrée-état spécifiée en tant que matrice Nx par Nu où Nx désigne le nombre d’états et Nu, le nombre d’entrées. Cette entrée définit la valeur de la propriété B.

C — Matrice état-sortie

Matrice Ny par Nx

Matrice d'état-sortie spécifiée en tant que matrice Ny par Nx où Nx désigne le nombre d’états et Ny, le nombre de sorties. Cette entrée définit la valeur de la propriété C.

D — Matrice de traversée

Matrice Ny par Nu

Matrice de traversée spécifiée en tant que matrice Ny par Nu où Ny désigne le nombre de sorties et Nu, le nombre d’entrées. Cette entrée définit la valeur de la propriété D.

ts — Pas d’échantillonnage

scalaire

Pas d’échantillonnage spécifié en tant que scalaire. Pour plus d’informations, voir la propriété Ts.

ltiSys — Système dynamique à convertir sous la forme d’une représentation d’état

modèle de systèmes dynamiques | tableau de modèles

Système dynamique à convertir sous la forme d’une représentation d’état, spécifié en tant que modèle de système dynamique SISO or MIMO ou en tant que tableau de modèles de systèmes dynamiques. Parmi les systèmes dynamiques que vous pouvez convertir, citons :

• Modèles LTI numériques en temps continu ou discret, tels que les modèles tf, zpk, ss ou pid.

• Modèles LTI généralisés ou incertains tels que les modèles genss ou uss (Robust Control Toolbox). (Pour pouvoir utiliser les modèles incertains, le software Robust Control Toolbox™ est nécessaire.)

  Le modèle de représentation d’état obtenu s'appuie sur :

  • les valeurs actuelles des composants réglables pour les blocs de design de systèmes de contrôle réglables.

  • les valeurs de modèle nominales pour les blocs de design de systèmes de contrôle incertains.

• Modèles LTI identifiés tels que les modèles idtf (System Identification Toolbox), idss (System Identification Toolbox), idproc (System Identification Toolbox), idpoly (System Identification Toolbox) et idgrey (System Identification Toolbox). Pour sélectionner la composante du modèle identifié à convertir, spécifiez component. Si vous ne spécifiez pas component, ss convertit la composante mesurée du modèle identifié par défaut. (Pour pouvoir utiliser les modèles identifiés, le software System Identification Toolbox™ est nécessaire)

component — Composante du modèle identifié

'measured' (par défaut) | 'noise' | 'augmented'

Composante du modèle identifié à convertir, spécifiée sous l’une des formes suivantes :

• 'measured' : convertit la composante mesurée de sys.

• 'noise' : convertit la composante de bruit de sys

• 'augmented' : convertit à la fois la composante mesurée et la composante de bruit de sys.

component ne s’applique que lorsque sys est un modèle LTI identifié.

Pour plus d’informations sur les modèles LTI identifiés et leurs composantes mesurée et de bruit, voir Identified LTI Models.

ssSys — Modèle de système dynamique à convertir en réalisation minimale ou sous forme explicite

Objet de modèle ss

Modèle de système dynamique à convertir en réalisation minimale ou sous forme explicite, spécifié en tant qu’objet de modèle ss.

Arguments en sortie

sys — Modèle de système en sortie

Objet de modèle ss | Objet de modèle genss | Objet de modèle uss

Modèle de système en sortie renvoyé sous la forme suivante :

• Objet de modèle de représentation d’état (ss) lorsque les entrées A, B, C et D sont des matrices numériques ou lors de la conversion à partir d'un autre type d'objet de modèle.

• Objet de modèle de représentation d’état généralisé (genss) lorsqu'une ou plusieurs des matrices A, B, C et D comprennent des paramètres réglables, tels que les paramètres realp ou les matrices généralisées (genmat). Pour un exemple, voir Création d’un modèle de représentation d’état avec à la fois des paramètres fixes et réglables.

• Objet de modèle de représentation d'état incertain (uss) lorsqu'une ou plusieurs des entrées A, B, C et D comprennent des matrices incertaines. Pour pouvoir utiliser les modèles incertains, le software Robust Control Toolbox est nécessaire.

Propriétés

A — Matrice d'état

Matrice Nx par Nx

Matrice d'état spécifiée en tant que matrice Nx par Nx où Nx désigne le nombre d’états. Il est possible de représenter la matrice état de nombreuses manières selon la réalisation de modèle de représentation d’état souhaitée, par exemple :

• Forme canonique du modèle

• Forme canonique de commandabilité (forme compagnon)

• Forme canonique d'observabilité

• Forme canonique de contrôlabilité

Pour plus d’informations, consultez State-Space Realizations.

B — Matrice entrée-état

Matrice Nx par Nu

Matrice entrée-état spécifiée en tant que matrice Nx par Nu où Nx désigne le nombre d’états et Nu, le nombre d’entrées.

C — Matrice état-sortie

Matrice Ny par Nx

Matrice d'état-sortie spécifiée en tant que matrice Ny par Nx où Nx désigne le nombre d’états et Ny, le nombre de sorties.

D — Matrice de traversée

Matrice Ny par Nu

Matrice de traversée spécifiée en tant que matrice Ny par Nu où Ny désigne le nombre de sorties et Nu, le nombre d’entrées. D est également appelée matrice de gain statique qui représente le rapport sortie/entrée en présence d’un état stable.

E — Matrice pour modèles de représentation d'état implicites

[] (par défaut) | Matrice Nx par Nx

Matrice pour modèles de représentation d’état implicites ou avec descripteur, spécifiée en tant que matrice Nx par Nx. E est vide par défaut, ce qui signifie que l’équation d’état est explicite. Pour spécifier une équation d’état implicite E dx/dt = Ax + Bu, définissez cette propriété sur une matrice carrée de la même taille que A. Voir dss pour plus d'informations sur la création de modèles de représentation d’état de descripteur.

Scaled — Valeur logique indiquant si la mise à l’échelle est activée ou désactivée

0 (par défaut) | 1

Valeur logique indiquant si la mise à l’échelle est activée ou désactivée, spécifiée en tant que 0 ou 1.

Quand le paramètre Scaled est défini sur 0 (désactivé), la plupart des algorithmes numériques intervenant sur le modèle de représentation d’état sys mettent automatiquement à l’échelle le vecteur d’état afin d'améliorer la précision numérique. Vous pouvez empêcher cette mise à l’échelle automatique en définissant Scaled à 1 (activé).

Pour plus d'informations sur la mise à l'échelle, consultez prescale.

StateName — Noms des états

' ' (par défaut) | vecteur de caractères | cell array de vecteurs de caractères

Noms des états spécifiés sous l'une des formes suivantes :

• Vecteur de caractères : pour les modèles de premier ordre, par exemple, 'velocity'

• Cell array de vecteurs de caractères : pour les modèles avec au moins deux états

StateName est vide ' ' pour tous les états par défaut.

StatePath — Trajectoire des états

' ' (par défaut) | vecteur de caractères | cell array de vecteurs de caractères

Trajectoire des états pour faciliter la gestion de la trajectoire du bloc d'état dans la linéarisation, spécifiée sous l'une des formes suivantes :

• Vecteur de caractères : pour les modèles de premier ordre

• Cell array de vecteurs de caractères : pour les modèles avec au moins deux états

StatePath est vide ' ' pour tous les états par défaut.

StateUnit — Unités des états

' ' (par défaut) | vecteur de caractères | cell array de vecteurs de caractères

Unités des états spécifiées sous l’une des formes suivantes :

• Vecteur de caractères : pour les modèles de premier ordre, par exemple, 'm/s'

• Cell array de vecteurs de caractères : pour les modèles à au moins deux états

Utilisez StateUnit pour assurer le suivi des unités de chaque état. StateUnit n'a aucune incidence sur le comportement du système. StateUnit est vide ' ' pour tous les états par défaut.

InternalDelay — Retards internes dans le modèle

vecteur

Retards internes dans le modèle, spécifiés en tant que vecteur. Les retards internes surviennent, par exemple, lors de la fermeture de boucles de rétroaction sur des systèmes présentant des retards, ou lors de la connexion en série ou en parallèle de systèmes présentant des retards. Pour plus d'informations sur les retards internes, consultez Closing Feedback Loops with Time Delays.

Pour les modèles en temps continu, les retards internes sont exprimés dans l'unité temporelle spécifiée par la propriété TimeUnit du modèle. Pour les modèles en temps discret, les retards internes sont exprimés en tant qu’entiers multiples du pas d’échantillonnage Ts. Par exemple, InternalDelay = 3 correspond à un retard de trois périodes d’échantillonnage.

Vous pouvez modifier les valeurs des retards internes au moyen de la propriété InternalDelay. Toutefois, le nombre d’entrées de sys.InternalDelay ne peut pas changer car il s’agit d’une propriété structurelle du modèle.

InputDelay — Retard en entrée

0 (par défaut) | scalaire | Vecteur Nu par 1

Retard en entrée pour chaque canal d’entrée spécifié sous l’une des formes suivantes :

• Scalaire : spécifiez le retard en entrée pour un système SISO ou le même retard pour toutes les entrées d'un système à entrées multiples.

• Vecteur Nu par 1 : spécifiez des retards d’entrée distincts pour l’entrée d’un système à entrées multiples où Nu désigne le nombre d’entrées.

Pour les systèmes en temps continu, spécifiez les retards en entrée dans l'unité temporelle spécifiée par la propriété TimeUnit. Pour les systèmes en temps discret, spécifiez les retards en entrée en tant qu’entiers multiples du pas d’échantillonnage, Ts.

Pour plus d’informations, consultez Time Delays in Linear Systems.

OutputDelay — Retard en sortie

0 (par défaut) | scalaire | Vecteur Ny par 1

Retard en sortie pour chaque canal de sortie spécifié sous l’une des formes suivantes :

• Scalaire : spécifiez le retard en sortie pour un système SISO ou le même retard pour toutes les sorties d'un système à sorties multiples.

• Vecteur Ny par 1 : spécifiez des retards de sortie distincts pour la sortie d’un système à sorties multiples où Ny désigne le nombre de sorties.

Pour les systèmes en temps continu, spécifiez les retards en sortie dans l'unité temporelle spécifiée par la propriété TimeUnit. Pour les systèmes en temps discret, spécifiez les retards en sortie en tant qu’entiers multiples du pas d’échantillonnage, Ts.

Pour plus d’informations, consultez Time Delays in Linear Systems.

Ts — Pas d’échantillonnage

0 (par défaut) | scalaire positif | -1

Pas d’échantillonnage spécifié en tant que :

• 0 pour les systèmes en temps continu.

• Scalaire positif représentant la période d’échantillonnage d’un système en temps discret. Spécifiez Ts dans l'unité temporelle définie par la propriété TimeUnit.

• -1 pour un système en temps discret avec un pas d’échantillonnage non spécifié.

Remarque

La modification de Ts ne discrétise pas ou ne rééchantillonne pas le modèle. Pour effectuer des conversions entre les représentations en temps continu et en temps discret, utilisez c2d et d2c. Pour modifier le pas d’échantillonnage d’un système en temps discret, utilisez d2d.

TimeUnit — Unités temporelles variables

'seconds' (par défaut) | 'nanoseconds' | 'microseconds' | 'milliseconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years' | ...

Unités temporelles variables spécifiées sous l’une des formes suivantes :

• 'nanoseconds'

• 'microseconds'

• 'milliseconds'

• 'seconds'

• 'minutes'

• 'hours'

• 'days'

• 'weeks'

• 'months'

• 'years'

La modification de TimeUnit n’a aucune incidence sur les autres propriétés mais change l’ensemble du comportement du système. Utilisez chgTimeUnit pour faire des conversions entre les unités temporelles sans modifier le comportement du système.

InputName — Noms des canaux en entrée

'' (par défaut) | vecteur de caractères | cell array de vecteurs de caractères

Noms des canaux en entrée spécifiés sous l'une des formes suivantes :

• Vecteur de caractères pour les modèles à entrée unique.

• Cell array de vecteurs de caractères pour les modèles à entrées multiples.

• '', pas de nom spécifié pour les canaux en entrée.

Sinon, vous pouvez attribuer des noms aux entrées pour les modèles à entrées multiples au moyen de l'expansion vectorielle automatique. Par exemple, si sys est un modèle à deux entrées, saisissez ce qui suit :

sys.InputName = 'controls';

Les noms en entrée s’étendent automatiquement à {'controls(1)';'controls(2)'}.

Vous pouvez utiliser la notation abrégée u pour faire référence à la propriété InputName. Par exemple, sys.u est équivalent à sys.InputName.

Utilisez InputName pour :

• Identifier des canaux sur l’affichage et les tracés du modèle.

• Extraire des sous-systèmes de systèmes MIMO.

• Spécifier des points de connexion au moment d’interconnecter les modèles.

InputUnit — Unités des canaux en entrée

'' (par défaut) | vecteur de caractères | cell array de vecteurs de caractères

Unités des canaux en entrée spécifiées sous l’une des formes suivantes :

• Vecteur de caractères pour les modèles à entrée unique.

• Cell array de vecteurs de caractères pour les modèles à entrées multiples.

• '', pas d'unité spécifiée pour les canaux en entrée.

Utilisez InputUnit pour spécifier les unités des signaux en entrée. InputUnit n'a aucune incidence sur le comportement du système.

InputGroup — Groupes de canaux en entrée

structure

Groupes de canaux en entrée spécifiés en tant que structure. Utilisez InputGroup pour attribuer les canaux en entrée des systèmes MIMO à des groupes et faire référence à chaque groupe par son nom. Les noms des champs de InputGroup correspondent aux noms des groupes tandis que les valeurs des champs sont les canaux en entrée pour chaque groupe. Par exemple, saisissez ce qui suit pour créer des groupes d’entrée nommés controls et noise comprenant respectivement les canaux d'entrée 1, 2, 3 et 5.

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

Vous pouvez alors extraire le sous-système des entrées controls vers toutes les sorties en utilisant la commande suivante.

sys(:,'controls')

Par défaut, InputGroup est une structure dépourvue de champs.

OutputName — Noms des canaux en sortie

'' (par défaut) | vecteur de caractères | cell array de vecteurs de caractères

Noms des canaux en sortie spécifiés sous l’une des formes suivantes :

• Vecteur de caractères pour les modèles à sortie unique.

• Cell array de vecteurs de caractères pour les modèles à sorties multiples.

• '', pas de nom spécifié pour les canaux en sortie.

Sinon, vous pouvez attribuer des noms de sortie pour les modèles à sorties multiples au moyen de l'expansion vectorielle automatique. Par exemple, si sys est un modèle à deux sorties, saisissez ce qui suit :

sys.OutputName = 'measurements';

Les noms de sortie s’étendent automatiquement à {'measurements(1)';'measurements(2)'}.

Vous pouvez également utiliser la notation abrégée y pour faire référence à la propriété OutputName. Par exemple, sys.y est équivalent à sys.OutputName.

Utilisez OutputName pour :

• Identifier des canaux sur l’affichage et les tracés du modèle.

• Extraire des sous-systèmes de systèmes MIMO.

• Spécifier des points de connexion au moment d’interconnecter les modèles.

OutputUnit — Unités des canaux en sortie

'' (par défaut) | vecteur de caractères | cell array de vecteurs de caractères

Unités des canaux en sortie spécifiées sous l’une des formes suivantes :

• Vecteur de caractères pour les modèles à sortie unique.

• Cell array de vecteurs de caractères pour les modèles à sorties multiples.

• '', pas d'unité spécifiée pour les canaux en sortie.

Utilisez OutputUnit pour spécifier les unités des signaux en sortie. OutputUnit n'a aucune incidence sur le comportement du système.

OutputGroup — Groupes de canaux en sortie

structure

Groupes de canaux en sortie spécifiés en tant que structure. Utilisez OutputGroup pour attribuer les canaux en sortie des systèmes MIMO à des groupes et faire référence à chaque groupe par son nom. Les noms des champs de OutputGroup correspondent aux noms des groupes tandis que les valeurs des champs sont les canaux en sortie pour chaque groupe. Par exemple, créez des groupes de sortie nommés temperature et measurement et comprenant respectivement les canaux de sortie 1, 3 et 5.

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

Vous pouvez alors extraire le sous-système de toutes les entrées vers les sorties measurement en utilisant la commande suivante.

sys('measurement',:)

Par défaut, OutputGroup est une structure dépourvue de champs.

Name — Nom du système

'' (par défaut) | vecteur de caractères

Nom du système spécifié en tant que vecteur de caractères. Par exemple, 'system_1'.

Notes — Texte spécifié par l’utilisateur

{} (par défaut) | vecteur de caractères | cell array de vecteurs de caractères

Texte spécifié par l’utilisateur, que vous souhaitez associer au système, spécifié en tant que vecteur de caractères ou cell array de vecteurs de caractères. Par exemple, 'System is MIMO'.

UserData — Données spécifiées par l’utilisateur

[] (par défaut) | tout type de données MATLAB

Données spécifiées par l’utilisateur, que vous souhaitez associer au système, spécifié en tant que type de données MATLAB.

SamplingGrid — Grille d’échantillonnage pour tableaux de modèles

tableau de structures

Grille d’échantillonnage pour les tableaux de modèles, spécifiés en tant que structure array.

Utilisez SamplingGrid pour effectuer le suivi des valeurs variables associées à chaque modèle dans un tableau de modèles, y compris les tableaux de modèles linéaires identifiés fixes dans le temps (IDLTI).

Définissez les noms des champs de la structure sur les noms des variables d'échantillonnage. Définissez les valeurs des champs sur les valeurs variables échantillonnées associées à chaque modèle du tableau. Toutes les variables d'échantillonnage doivent être des scalaires numériques et tous les tableaux de valeurs échantillonnées doivent correspondre aux dimensions du tableau de modèles.

Par exemple, vous pouvez créer un tableau 11 par 1 de modèles linéaires, sysarr, en prenant des snapshots d'un système linéaire variant dans le temps à des moments t = 0:10. Le code suivant stocke les pas d’échantillonnage avec les modèles linéaires.

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

De la même manière, vous pouvez créer un tableau de modèles 6 par 9, M, en échantillonnant indépendamment deux variables, zeta et w. Le code suivant fait correspondre les valeurs (zeta,w) à M.

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

Lorsque vous affichez M, chaque entrée du tableau comprend les valeurs zeta et w correspondantes.

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

Pour les tableaux de modèles générés par linéarisation d'un modèle Simulink^® à valeurs de paramètres ou points de fonctionnement multiples, le software remplit automatiquement SamplingGrid avec les valeurs de variables qui correspondent à chaque entrée du tableau. Par exemple, les commandes Simulink Control Design™ linearize (Simulink Control Design) et slLinearizer (Simulink Control Design) remplissent automatiquement SamplingGrid.

Par défaut, SamplingGrid est une structure dépourvue de champs.

Fonctions d'objet

Les listes suivantes contiennent un sous-ensemble représentatif des fonctions que vous pouvez utiliser avec les objets de modèle ss. En règle générale, toute fonction applicable à Modèles de systèmes dynamiques est applicable à un objet ss.

Analyse linéaire

step	Step response of dynamic system
impulse	Impulse response plot of dynamic system; impulse response data
lsim	Plot simulated time response of dynamic system to arbitrary inputs; simulated response data
bode	Bode plot of frequency response, or magnitude and phase data
nyquist	Nyquist plot of frequency response
nichols	Nichols chart of frequency response
bandwidth	Frequency response bandwidth

Analyse de stabilité

pole	Poles of dynamic system
zero	Zeros and gain of SISO dynamic system
pzplot	Pole-zero plot of dynamic system model with additional plot customization options
margin	Gain margin, phase margin, and crossover frequencies

Transformation des modèles

zpk	Zero-pole-gain model
tf	Modèle de fonction de transfert
c2d	Convert model from continuous to discrete time
d2c	Convert model from discrete to continuous time
d2d	Resample discrete-time model

Interconnexion des modèles

feedback	Feedback connection of multiple models
connect	Block diagram interconnections of dynamic systems
series	Connexion en série de deux modèles
parallel	Parallel connection of two models

Conception de contrôleurs

pidtune	PID tuning algorithm for linear plant model
rlocus	Tracé des lieux des racines d’un système dynamique
lqr	Design d'un régulateur linéaire quadratique (LQR, Linear Quadratic Regulator)
lqg	Linear-Quadratic-Gaussian (LQG) design
lqi	Linear-Quadratic-Integral control
kalman	Design Kalman filter for state estimation

Exemples

Modèle de représentation d'état SISO

Créez le modèle de représentation d’état SISO défini par les matrices de représentation d’état suivantes :

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

Spécifiez les matrices A, B, C et D, et créez le modèle de représentation d’état.

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.

Création d’un modèle de représentation d'état en temps discret

Créez un modèle de représentation d’état avec un pas d’échantillonnage de 0,25 s et les matrices de représentation d’état suivantes :

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

Spécifiez les matrices de représentation d’état.

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

Spécifiez le pas d’échantillonnage.

Ts = 0.25;

Créez le modèle de représentation d'état.

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

Modèle de représentation d'état MIMO en temps continu

Pour cet exemple, considérons un cube tournant autour de son coin avec un tenseur d'inertie J et une force d'amortissement F d'une magnitude de 0,2. L'entrée du système correspond au couple d’entraînement tandis que les sorties correspondent aux vitesses angulaires. Les matrices de représentation d’état du cube sont :

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

Spécifiez les matrices A, B, C et D, et créez le modèle de représentation d’état en temps continu.

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.

sys est MIMO étant donné que le système contient 3 entrées et 3 sorties détectées dans les matrices C et D. Pour plus d'informations sur les modèles de représentation d’état MIMO, consultez MIMO State-Space Models.

Modèle de représentation d'état MIMO en temps discret

Créez un modèle de représentation d’état au moyen des matrices MIMO (Multi-Input Multi-Output) en temps discret avec un pas d’échantillonnage de ts = 0.2 secondes :

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

Spécifiez les matrices de représentation d’état et créez un modèle de représentation d’état MIMO en temps discret.

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.

Spécifiez les noms des états et des entrées pour un modèle de représentation d'état

Créez des matrices de représentation d’état et spécifiez un pas d’échantillonnage.

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

Créez le modèle de représentation d’état en spécifiant les noms des états et des entrées au moyen de paires nom-valeur.

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

Le nombre de noms pour les états et les entrées doit être cohérent avec les dimensions de A, B, C et D.

Il peut être utile d’attribuer des noms aux entrées et aux sorties lorsque vous utilisez des tracés de réponse pour les systèmes MIMO.

step(sys)

Notez le nom de l'entrée Force dans le titre du tracé de réponse indicielle.

Modèle de représentation d’état aux propriétés héritées

Pour cet exemple, créez un modèle de représentation d’état avec les propriétés pour les unités de temps et les unités des entrées héritées d’un autre modèle du même type. Considérons le modèle de représentation d’état suivant :

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

Commencez par créer un modèle de représentation d’état sys1 en configurant les propriétés TimeUnit et InputUnit sur 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');

Vérifiez que les propriétés pour les unités de temps et des entrées de sys1 sont configurées sur minutes.

propValues1 = [sys1.TimeUnit,sys1.InputUnit]

propValues1 = 1x2 cell
    {'minutes'}    {'minutes'}

Créez le deuxième modèle de représentation d'état avec les propriétés héritées de sys1.

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

Vérifiez que les unités de temps et des entrées de sys2 ont été héritées de sys1.

propValues2 = [sys2.TimeUnit,sys2.InputUnit]

propValues2 = 1x2 cell
    {'minutes'}    {'minutes'}

Modèle de représentation d'état à gain statique MIMO

Dans cet exemple, vous allez créer un modèle de représentation d’état MIMO à gain statique.

Considérons la matrice de gain statique suivante à deux entrées et deux sorties :

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

Spécifiez la matrice de gain et créez le modèle de représentation d'état à gain statique.

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

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

Convertissez la fonction de transfert en modèle de représentation d'état

Calculez le modèle de représentation d’état de la fonction de transfert suivante :

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

Créez le modèle de fonction de transfert.

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

Convertissez ce modèle en un modèle de représentation d’état.

sys = ss(H);

Examinez la taille du modèle de représentation d’état.

size(sys)

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

Le nombre d’états est égal à l’ordre cumulé des entrées SISO dans H(s).

Pour obtenir une réalisation minimale de H(s), saisissez

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

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

Le modèle obtenu présente un ordre de trois, ce qui correspond au nombre minimal d’états nécessaires pour représenter H(s). Pour voir ce nombre d'états, refactorisez H(s) en tant que produit d'un système de premier ordre et d'un système de deuxième ordre.

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

Extraction des modèles de représentation d’état d’un modèle identifié

Pour cet exemple, extrayez la composante mesurée et la composante de bruit d’un modèle polynomial identifié vers deux modèles de représentation d’état distincts.

Chargez le modèle polynomial de Box-Jenkins ltiSys dans identifiedModel.mat.

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

ltiSys est un modèle identifié en temps discret du type : $$y(t)=\frac{B}{F}u(t)+\frac{C}{D}e(t)$$ où $$\frac{B}{F}$$ représente la composante mesurée et $$\frac{C}{D}$$, la composante de bruit.

Extrayez la composante mesurée et la composante de bruit en tant que modèles de représentation d’état.

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.

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.

La composante mesurée peut servir de modèle de système physique tandis que la composante de bruit peut être utilisée en tant que modèle de perturbations pour le design du système de contrôle.

Réalisation explicite du modèle de représentation d'état du descripteur

Créez un modèle de représentation d'état avec descripteur (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);

Calculez une réalisation explicite du système (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.

Confirmez que le descripteur et les réalisations explicites présentent une dynamique équivalente.

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

Création d’un modèle de représentation d’état avec à la fois des paramètres fixes et réglables

Cet exemple montre comment créer un modèle de représentation d’état genss ayant à la fois des paramètres fixes et réglables.

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

où a et b sont des paramètres réglables dont les valeurs initiales sont respectivement -1 et 3.

Créez les paramètres réglables au moyen de realp.

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

Définissez une matrice généralisée au moyen des expressions algébriques de a et de b.

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

A est une matrice généralisée dont la propriété Blocks contient a et b. La valeur initiale de A est [1 2;0 -3], à partir des valeurs initiales de a et de b.

Créez les matrices de représentation d’état à valeur fixe.

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

Utilisez ss pour créer le modèle de représentation d'état.

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.

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

sys est un modèle LTI généralisé (genss) disposant de paramètres réglables a et b.

Modèle de représentation d’état avec retard en entrée et en sortie

Pour cet exemple, considérons un modèle de représentation d’état SISO défini par les matrices de représentation d’état suivantes :

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

Sur la base d’un retard en entrée de 0,5 seconde et d’un retard en sortie de 2,5 secondes, créez un objet de modèle de représentation d’état pour représenter les matrices A, B, C et 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.

Vous pouvez également utiliser la commande get pour afficher toutes les propriétés d’un objet MATLAB.

get(sys)

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

Pour plus d'informations sur la spécification d’un retard pour un modèle LTI, consultez Specifying Time Delays.

Analyse de la stabilité des systèmes de représentation d'état

Pour cet exemple, considérons un objet de système de représentation d’état qui représente les matrices d’état suivantes :

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

Créez un objet de représentation d’état sys au moyen de la commande 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);

Calculez ensuite le modèle de représentation d’état en boucle fermée pour un gain négatif unitaire et trouvez les pôles de l’objet de système de représentation d’état en boucle fermée sysFeedback.

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

P = 3×1 complex

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

La boucle de rétroaction du gain unitaire est stable étant donné que tous les pôles présentent des parties réelles négatives. La vérification des pôles en boucle fermée permet d’obtenir une évaluation binaire de la stabilité. Dans la pratique, il est plus utile de connaître la robustesse (ou la fragilité) de la stabilité. La robustesse est notamment indiquée par l'ampleur de la variation du gain en boucle avant que la stabilité ne soit perdue. Vous pouvez utiliser le tracé des lieux des racines afin d’estimer la plage de valeurs k pour laquelle la boucle est stable.

rlocus(sys)

Les changements de gain en boucle ne constituent que l’un des aspects d’une stabilité robuste. En règle générale, une modélisation imparfaite du système physique signifie que le gain et la phase ne sont pas connus avec exactitude. Étant donné que les erreurs de modélisation sont les plus néfastes près de la fréquence de crossover du gain (fréquence à laquelle le gain en boucle ouverte s’élève à 0 dB), il est également important de connaître la variation de phase admissible à cette fréquence.

Vous pouvez afficher les marges de gain et de phase sur un diagramme de Bode comme suit.

bode(sys)
grid

Pour consulter un exemple plus détaillé, voir Assessing Gain and Phase Margins.

Design de contrôle avec des modèles de représentation d'état

Pour cet exemple, concevez un contrôleur PID 2-DOF avec une bande passante cible de 0,75 rad/s pour un système représenté par les matrices suivantes :

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

Créez un objet de représentation d’état sys au moyen de la commande 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.

Au moyen de la bande passante cible, utilisez pidtune pour générer un contrôleur 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.

Lorsque le type 'PID2' est utilisé, pidtune génère un contrôleur 2-DOF représenté en tant qu’objet pid2. L’affichage confirme ce résultat. L’affichage indique également que pidtune règle tous les coefficients du contrôleur, y compris les poids des points de consigne b et c, pour équilibrer la performance et la robustesse.

Pour en savoir plus sur le réglage PID interactif dans le Live Editor, voir la tâche Tune PID Controller Live Editor. Cette tâche vous permet de concevoir un contrôleur PID de manière interactive et génère automatiquement un code MATLAB pour votre live script.

Pour effectuer un réglage PID interactif dans une application autonome, utilisez PID Tuner. Pour consulter un exemple de conception d’un contrôleur au moyen de l’application, voir Design d'un contrôleur PID pour le suivi rapide des consignes.

Connexion d’entrées et de sorties spécifiques des modèles de représentation d’état dans une boucle de rétroaction

Considérons un système physique de représentation d’état G regroupant cinq entrées et quatre sorties, et un système d’asservissement de représentation d’état K doté de trois entrées et de deux sorties. Les sorties 1, 3 et 4 du système physique G doivent être connectées aux entrées K du contrôleur, tandis que les sorties du contrôleur doivent être connectées aux entrées 4 et 2 du système physique.

Pour cet exemple, considérons deux modèles de représentation d’état en temps continu pour à la fois G et K, représentés par l‘ensemble de matrices suivant :

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

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.

Définissez les vecteurs feedout et feedin sur la base des entrées et sorties à connecter dans une boucle de rétroaction.

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.

size(sys)

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

sys est le modèle de représentation d’état en boucle fermée obtenu en connectant les entrées et sorties spécifiées de G et de K.

Historique des versions

Introduit avant R2006a

Voir aussi

dss | frd | get | set | ssdata | tf | zpk

Rubriques

• Modèles de systèmes dynamiques
• What Are Model Objects?
• State-Space Models
• MIMO State-Space Models
• State-Space Realizations
• Recommended Working Representation
• Time Delays in Linear Systems
• Specifying Time Delays