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

zpk

Modèle zéro-pôle-gain

Description

Utilisez zpk pour créer des modèles zéro-pôle-gain ou pour convertir des modèles de systèmes dynamiques en modèles zéro-pôle-gain.

Les modèles zéro-pôle-gain représentent les fonctions de transfert sous forme factorisée. Par exemple, considérons la fonction de transfert SISO en temps continu suivante :

$$G\left(s\right)=\frac{s^2-3s-4}{s^2+5s+6}$$

G(s) peut être factorisée sous la forme zéro-pôle-gain comme suit :

$$G\left(s\right)=\frac{\left(s+1\right)\left(s-4\right)}{\left(s+2\right)\left(s+3\right)}.$$

Une représentation plus générale du modèle SISO zéro-pôle-gain est la suivante :

$$h\left(s\right)=k\frac{\left(s-z\left(1\right)\right)\left(s-z\left(2\right)\right)\dots \left(s-z\left(m\right)\right)}{\left(s-p\left(1\right)\right)\left(s-p\left(2\right)\right)\dots \left(s-p\left(n\right)\right)}$$

Ici, z et p sont les vecteurs des zéros et des pôles à valeurs réelles ou complexes, et k est le gain scalaire à valeurs réelles ou complexes. Pour les modèles MIMO, chaque canal d'E/S est représenté par une fonction de transfert de ce type h_ij(s).

Vous pouvez créer un objet de modèle zéro-pôle-gain en spécifiant directement les pôles, zéros et gains ou en convertissant un modèle d’un autre type (tel qu’un modèle de représentation d’état ss) en modèle zéro-pôle-gain.

Vous pouvez également utiliser zpk pour créer des modèles de représentation d’état généralisés (genss) ou incertains (uss (Robust Control Toolbox)).

Création

Syntaxe

sys = zpk(zeros,poles,gain)

sys = zpk(zeros,poles,gain,ts)

sys = zpk(zeros,poles,gain,ltiSys)

sys = zpk(m)

sys = zpk(___,Name,Value)

sys = zpk(ltiSys)

sys = zpk(ltiSys,component)

s = zpk('s')

z = zpk('z',ts)

Description

sys = zpk(zeros,poles,gain) crée un modèle zéro-pôle-gain en temps continu avec zeros et poles spécifiés comme des vecteurs et la valeur scalaire de gain. La sortie sys obtenue est un objet modèle zpk stockant les données du modèle. Réglez zeros ou poles sur [] pour les systèmes sans zéros ni pôles. Ces deux entrées n’ont pas besoin de présenter la même longueur et le modèle n’a pas à être correct (autrement dit avoir un excès de pôles).

sys = zpk(zeros,poles,gain,ts) crée un modèle zéro-pôle-gain en temps discret avec un pas d'échantillonnage ts. Définissez ts sur -1 ou sur [] pour ne pas spécifier le pas d’échantillonnage.

sys = zpk(zeros,poles,gain,ltiSys) crée un modèle zéro-pôle-gain avec les propriétés héritées du modèle de système dynamique ltiSys, y compris le pas d’échantillonnage.

sys = zpk(m) crée un modèle zéro-pôle-gain représentant le gain statique, m.

sys = zpk(___,Name,Value) définit la propriété Propriétés du modèle zéro-pôle-gain au moyen d’une ou de plusieurs paires d'arguments nom-valeur pour définir d’autres propriétés du modèle. Cette syntaxe fonctionne avec toutes les combinaisons entrée-argument précédentes.

sys = zpk(ltiSys) convertit le modèle de systèmes dynamiques ltiSys en un modèle zéro-pôle-gain.

sys = zpk(ltiSys,component) convertit le component spécifié de ltiSys en modèle zéro-pôle-gain. Vous ne devez utiliser cette syntaxe que lorsque ltiSys est un modèle linéaire identifié invariant dans le temps (LTI) tel qu’un modèle idss ou idtf.

s = zpk('s') crée une variable spéciale s que vous pouvez utiliser dans une expression rationnelle pour créer un modèle zéro-pôle-gain en temps continu. Il est parfois plus aisé et plus intuitif de recourir à une expression rationnelle plutôt que de spécifier des coefficients polynomiaux.

z = zpk('z',ts) crée une variable spéciale z que vous pouvez utiliser dans une expression rationnelle pour créer un modèle zéro-pôle-gain en temps discret. Pour ne pas spécifier le pas d’échantillonnage, définissez l’argument ts en entrée à -1.

Arguments en entrée

zeros — Zéros du modèle zéro-pôle-gain

vecteur ligne | cell array Ny par Nu de vecteurs ligne

Zéros du modèle zéro-pôle-gain, spécifiés comme suit :

• Vecteur ligne de modèles SISO. Par exemple, utilisez [1,2+i,2-i] pour créer un modèle avec des zéros à s = 1, s = 2+i et s = 2-i. Pour un exemple, voir Modèle SISO zéro-pôle-gain en temps continu.

• Cell array Ny par Nu de vecteurs ligne servant à spécifier un modèle MIMO zéro-pôle-gain où Ny désigne le nombre de sorties et Nu, le nombre d’entrées. Pour un exemple, voir Modèle MIMO zéro-pôle-gain en temps discret.

Par exemple, si a est un paramètre realp réglable présentant la valeur nominale 3, vous pouvez utiliser zeros = [1 2 a] pour créer un modèle genss avec des zéros à s = 1 et s = 2 et un zéro réglable à s = 3.

Lorsque vous utilisez cet argument d'entrée pour créer un modèle zpk, l'argument définit la valeur initiale de la propriété Z.

poles — Pôles du modèle zéro-pôle-gain

vecteur ligne | cell array Ny par Nu de vecteurs ligne

Pôles du modèle zéro-pôle-gain, spécifiés comme suit :

• Vecteur ligne de modèles SISO. Pour un exemple, voir Modèle SISO zéro-pôle-gain en temps continu.

• Cell array Ny par Nu de vecteurs ligne servant à spécifier un modèle MIMO zéro-pôle-gain où Ny désigne le nombre de sorties et Nu, le nombre d’entrées. Pour un exemple, voir Modèle MIMO zéro-pôle-gain en temps discret.

Définissez également une propriété de l’objet zpk. Cet argument d’entrée définit la valeur de la propriété P.

gain — Gain du modèle zéro-pôle-gain

scalaire | Matrice Ny par Nu

Gain du modèle zéro-pôle-gain, spécifié comme suit :

• Scalaire pour modèles SISO. Pour un exemple, voir Modèle SISO zéro-pôle-gain en temps continu.

• Matrice Ny par Nu servant à spécifier un modèle MIMO zéro-pôle-gain où Ny désigne le nombre de sorties et Nu, le nombre d’entrées. Pour un exemple, voir Modèle MIMO zéro-pôle-gain en temps discret.

Définissez également une propriété de l’objet zpk. Cet argument d’entrée définit la valeur de la propriété K.

ts — Pas d’échantillonnage

scalaire

Pas d’échantillonnage spécifié en tant que scalaire. Définissez également une propriété de l’objet zpk. Cet argument d’entrée définit la valeur de la propriété Ts.

ltiSys — Système dynamique

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

Système dynamique 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 utiliser, 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, une licence Robust Control Toolbox™ est nécessaire.)

  Le modèle zéro-pôle-gain 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, tf 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)

  Un modèle non linéaire identifié ne peut pas être converti en objet modèle zpk. Vous pouvez commencer par utiliser des fonctions d'approximation linéaire telles que linearize et linapp (Cette fonctionnalité nécessite le software System Identification Toolbox.)

m — Gain statique

scalaire | matrice

Gain statique spécifié en tant que scalaire ou matrice. Le gain statique ou le gain à l'état stable d’un système représente le rapport sortie/entrée en présence d’un état stable.

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.

Arguments en sortie

sys — Modèle de système en sortie

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

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

• Un objet modèle zéro-pôle-gain (zpk), lorsque les arguments d'entrée zeros, poles et gain contiennent des valeurs numériques.

• Un modèle de représentation d’état généralisé (genss) lorsque les arguments d’entrée zeros, poles et gain comprennent des paramètres réglables, tels que les paramètres realp ou les matrices généralisées (genmat).

• Un modèle de représentation d’état incertain (uss) lorsque les arguments d’entrée zeros poles et gain comprennent des paramètres incertains. Pour pouvoir utiliser les modèles incertains, une licence Robust Control Toolbox est nécessaire.

Propriétés

Z — Zéros du système

cell array | cell array Ny par Nu de vecteurs ligne

Zéros du système, spécifiés comme suit :

• Cell array des zéros de la fonction de transfert ou des racines du numérateur pour les modèles SISO.

• Cell array Ny par Nu de vecteurs ligne des zéros pour chaque paire d’E/S d’un modèle MIMO où Ny désigne le nombre de sorties et Nu, le nombre d’entrées.

Les valeurs du Z peuvent présenter des valeurs réelles ou complexes.

P — Pôles du système

cell array | cell array Ny par Nu de vecteurs ligne

Pôles du système, spécifiés comme suit :

• Cell array des pôles de la fonction de transfert ou des racines du dénominateur pour les modèles SISO.

• Cell array Ny par Nu de vecteurs ligne des pôles pour chaque paire d’E/S d’un modèle MIMO où Ny désigne le nombre de sorties et Nu, le nombre d’entrées.

Les valeurs du P peuvent présenter des valeurs réelles ou complexes.

K — Gains du système

scalaire | Matrice Ny par Nu

Gains du système, spécifiés comme suit :

• Valeur scalaire pour modèles SISO.

• Matrice Ny par Nu stockant les valeurs de gain pour chaque paire d’E/S d’un modèle MIMO où Ny désigne le nombre de sorties et Nu, le nombre d’entrées.

Les valeurs du K peuvent présenter des valeurs réelles ou complexes.

DisplayFormat — Spécifie le mode de factorisation des polynômes numérateur et dénominateur pour l'affichage

'roots' (par défaut) | 'frequency' | 'time constant'

Spécifie le mode de factorisation des polynômes numérateur et dénominateur pour l'affichage, spécifiés de l’une des manières suivantes :

• 'roots' : affiche les facteurs en termes d'emplacement des racines du polynôme. 'roots' correspond à la valeur par défaut de DisplayFormat.

• 'frequency' : affiche les facteurs en termes de fréquences naturelles de la racine ω₀ et d'amortissement ζ.

  Le format d'affichage 'frequency' n'est pas disponible pour les modèles en temps discret avec la valeur Variable 'z^-1' ou 'q^-1'.

• 'time constant' : affiche les facteurs en termes de constantes de temps de la racine τ0 et d'amortissement ζ.

  Le format d'affichage 'time constant' n'est pas disponible pour les modèles en temps discret avec la valeur Variable 'z^-1' ou 'q^-1'.

Pour les modèles en temps continu, le tableau suivant indique la manière dont les facteurs polynomiaux sont disposés dans chaque format d'affichage.

Valeur DisplayName	Facteur de premier ordre (racine réelle $$R$$)	Facteur de deuxième ordre (paire de racines complexes $$R=a\pm jb$$)
'roots'	$$(s-R)$$	$$(s^2-\alpha s+\beta ),$$ où $$\alpha =2a,\beta =a^2+b^2$$
'frequency'	$$\left(1-\frac{s}{{\omega }_0}\right),$$ où $${\omega }_0=R$$	$$1-2\zeta \left(\frac{s}{{\omega }_0}\right)+{\left(\frac{s}{{\omega }_0}\right)}^2,$$ où $${\omega }_0{}^2=a^2+b^2,\zeta =\frac{a}{{\omega }_0}$$
'time constant'	$$\left(1-\tau s\right),$$ où $$\tau =\frac{1}{R}$$	$$1-2\zeta \left(\tau s\right)+{\left(\tau s\right)}^2,$$ où $$\tau =\frac{1}{{\omega }_0},\zeta =a\tau$$

Pour les modèles en temps discret, les facteurs polynomiaux sont agencés de la même manière que pour les modèles en temps continu, avec les substitutions de variables suivantes :

$$s\to w=\frac{z-1}{T_s};R\to \frac{R-1}{T_s},$$

où T_s correspond au pas d'échantillonnage. En temps discret, τ et ω₀ correspondent étroitement à la constante de temps et à la fréquence naturelle de la racine équivalente en temps continu, pour autant que la condition suivante soit remplie : $$\left|z-1\right|<<T_s\left({\omega }_0<<\frac{\pi }{T_s}=\text{Nyquist frequency}\right)$$.

Variable — Variable d’affichage du modèle zéro-pôle-gain

's' (par défaut) | 'z' | 'p' | 'q' | 'z^-1' | 'q^-1'

Variable d’affichage du modèle zéro-pôle-gain, spécifiée sous l’une des formes suivantes :

• 's' : valeur par défaut des modèles en temps continu

• 'z' : valeur par défaut des modèles en temps discret

• 'p' : équivalent de 's'

• 'q' : équivalent de 'z'

• 'z^-1' : inverse de 'z'

• 'q^-1' : équivalent de 'z^-1'

IODelay — Retard de transport

0 (par défaut) | scalaire | Tableau Ny par Nu

Retard de transport spécifié sous l’une des formes suivantes :

• Scalaire : spécifiez le retard de transport pour un système SISO ou le même retard de transport pour toutes les paires entrée/sortie d'un système MIMO.

• Tableau Ny par Nu : spécifiez des retards de transport distincts pour chaque paire entrée/sortie d'un système MIMO. Ici, Ny désigne le nombre de sorties et Nu, le nombre d’entrées.

Pour les systèmes en temps continu, spécifiez les retards de transport dans l'unité temporelle spécifiée par la propriété TimeUnit. Pour les systèmes en temps discret, spécifiez les retards de transport en tant qu’entiers multiples du pas d’échantillonnage, Ts. Pour plus d'informations sur le retard, consultez Time Delays in Linear Systems.

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 modèles zpk. En règle générale, toute fonction applicable à Modèles de systèmes dynamiques est applicable à un objet zpk.

Analyse linéaire

step	Step response of dynamic system
impulse	Impulse response plot of dynamic system; impulse response data
lsim	Compute time response simulation data of dynamic system to arbitrary inputs
bode	Réponse en fréquence de Bode d'un système dynamique
nyquist	Nyquist response of dynamic system
nichols	Nichols response of dynamic system
bandwidth	Frequency response bandwidth

Analyse de stabilité

pole	Poles of dynamic system
zero	Zeros and gain of SISO dynamic system
pzplot	Plot pole-zero map of dynamic system
margin	Marges de gain et de phase, et fréquences de crossover

Transformation des modèles

tf	Modèle de fonction de transfert
ss	Modèle de représentation d'état
c2d	Conversion de modèle du temps continu au temps discret
d2c	Convert model from discrete to continuous time
d2d	Resample discrete-time model

Interconnexion des modèles

feedback	Connexion rétroactive de plusieurs modèles
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	Lieu 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	Contrôle linéaire quadratique intégral
kalman	Design Kalman filter for state estimation

Exemples

Modèle SISO zéro-pôle-gain en temps continu

Pour les besoins de cet exemple, considérons le modèle SISO zéro-pôle-gain en temps continu suivant :

$$sys(s)=\frac{-2s}{(s-1-i)(s-1+i)(s-2)}$$

Spécifiez les zéros, les pôles et le gain, et créez le modèle SISO zéro-pôle-gain.

zeros = 0;
poles = [1-1i 1+1i 2];
gain = -2;
sys = zpk(zeros,poles,gain)

sys =
 
          -2 s
  --------------------
  (s-2) (s^2 - 2s + 2)
 
Continuous-time zero/pole/gain model.

Modèle SISO zéro-pôle-gain en temps discret

Pour cet exemple, considérons le modèle SISO zéro-pôle-gain en temps discret suivant, avec un pas d’échantillonnage de 0,1 s :

$$sys(s)=\frac{7(z-1)(z-2)(z-3)}{(z-6)(z-5)(z-4)}$$

Spécifiez les zéros, les pôles et le gain, ainsi que le pas d’échantillonnage, et créez le modèle SISO zéro-pôle-gain en temps discret.

zeros = [1 2 3];
poles = [6 5 4];
gain = 7;
ts = 0.1;
sys = zpk(zeros,poles,gain,ts)

sys =
 
  7 (z-1) (z-2) (z-3)
  -------------------
   (z-6) (z-5) (z-4)
 
Sample time: 0.1 seconds
Discrete-time zero/pole/gain model.

Concaténer les modèles SISO zéro-pole-gain en un modèle MIMO zéro-pole-gain

Dans cet exemple, vous créez un modèle MIMO zéro-pole-gain en concaténant des modèles SISO zéro-pole-gain. Considérons le modèle zéro-pôle-gain en temps continu à une entrée et deux sorties suivant :

$$sys(s)=\left[\begin{array}{c}\frac{(s-1)}{(s+1)}\\ \frac{(s+2)}{(s+2+i)(s+2-i)}\end{array}\right].$$

Spécifiez le modèle MIMO zéro-pôle-gain en concaténant les entrées SISO.

zeros1 = 1;
poles1 = -1;
gain = 1;
sys1 = zpk(zeros1,poles1,gain)

sys1 =
 
  (s-1)
  -----
  (s+1)
 
Continuous-time zero/pole/gain model.

zeros2 = -2;
poles2 = [-2+1i -2-1i];
sys2 = zpk(zeros2,poles2,gain)

sys2 =
 
      (s+2)
  --------------
  (s^2 + 4s + 5)
 
Continuous-time zero/pole/gain model.

sys = [sys1;sys2]

sys =
 
  From input to output...
       (s-1)
   1:  -----
       (s+1)
 
           (s+2)
   2:  --------------
       (s^2 + 4s + 5)
 
Continuous-time zero/pole/gain model.

Modèle MIMO zéro-pôle-gain en temps discret

Créez un modèle zéro-pôle-gain en temps discret, à entrées et sorties multiples :

$$sys\left(z\right)=\left[\begin{array}{cc}\frac{1}{(z+0.3)}& \frac{z}{(z+0.3)}\\ \frac{-(z-2)}{(z+0.3)}& \frac{3}{(z+0.3)}\end{array}\right]$$

avec un pas d’échantillonnage de ts = 0.2 secondes.

Spécifiez les zéros et pôles sous la forme de cell arrays et les gains sous la forme d’un tableau.

zeros = {[] 0;2 []};
poles = {-0.3 -0.3;-0.3 -0.3};
gain = [1 1;-1 3];
ts = 0.2;

Créez un modèle MIMO zéro-pôle-gain en temps discret.

sys = zpk(zeros,poles,gain,ts)

sys =
 
  From input 1 to output...
          1
   1:  -------
       (z+0.3)
 
       - (z-2)
   2:  -------
       (z+0.3)
 
  From input 2 to output...
          z
   1:  -------
       (z+0.3)
 
          3
   2:  -------
       (z+0.3)
 
Sample time: 0.2 seconds
Discrete-time zero/pole/gain model.

Spécifier les noms d'entrée du modèle zéro-pôle-gain

Spécifiez les zéros, pôles et le gain, ainsi que le pas d’échantillonnage et créez le modèle zéro-pôle-gain en spécifiant les noms des noms d’état et d’entrée au moyen de paires nom-valeur.

zeros = 4;
poles = [-1+2i -1-2i];
gain = 3;
ts = 0.05;
sys = zpk(zeros,poles,gain,ts,'InputName','Force')

sys =
 
  From input "Force" to output:
     3 (z-4)
  --------------
  (z^2 + 2z + 5)
 
Sample time: 0.05 seconds
Discrete-time zero/pole/gain model.

Le nombre de noms d’entrée doit être cohérent avec le nombre de zéros.

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 zéro-pôle-gain en temps continu utilisant une expression rationnelle

Pour cet exemple, créez un modèle zéro-pôle-gain en temps continu avec des expressions rationnelles. Il est parfois plus aisé et plus intuitif de recourir à une expression rationnelle plutôt que de spécifier des pôles et des zéros.

Considérons le système suivant :

$$sys(s)=\frac{s}{s^2+2s+10}.$$

Pour créer le modèle de fonction de transfert, commencez par spécifier s en tant qu’objet zpk.

s = zpk('s')

s =
 
  s
 
Continuous-time zero/pole/gain model.

Créez le modèle zéro-pôle-gain en utilisant s dans l’expression rationnelle.

sys = s/(s^2 + 2*s + 10)

sys =
 
         s
  ---------------
  (s^2 + 2s + 10)
 
Continuous-time zero/pole/gain model.

Modèle zéro-pôle-gain en temps discret utilisant une expression rationnelle

Pour cet exemple, créez un modèle zéro-pôle-gain en temps discret au moyen d’une expression rationnelle. Il est parfois plus aisé et plus intuitif de recourir à une expression rationnelle plutôt que de spécifier des pôles et des zéros.

Considérons le système suivant :

$$sys(z)=\frac{z-1}{z^2-1.85z+0.9}.$$

Pour créer le modèle zéro-pôle-gain, commencez par spécifier z en tant qu’objet zpk et le pas d’échantillonnage ts.

ts = 0.1;
z = zpk('z',ts)

z =
 
  z
 
Sample time: 0.1 seconds
Discrete-time zero/pole/gain model.

Créez le modèle zéro-pôle-gain en utilisant z dans l’expression rationnelle.

sys = (z - 1) / (z^2 - 1.85*z + 0.9)

sys =
 
         (z-1)
  -------------------
  (z^2 - 1.85z + 0.9)
 
Sample time: 0.1 seconds
Discrete-time zero/pole/gain model.

Modèle zéro-pôle-gain aux propriétés héritées

Pour cet exemple, créez un modèle zéro-pôle-gain avec les propriétés héritées d’un autre modèle du même type. Considérons les deux modèles zéro-pôle-gain suivants :

$$sys1(s)=\frac{2s}{s(s+8)}andsys2(s)=\frac{0.8(s-1)}{(s+3)(s-5)}.$$

Pour cet exemple, créez sys1 en configurant les propriétés TimeUnit et InputDelay en minutes.

zero1 = 0;
pole1 = [0;-8];
gain1 = 2;
sys1 = zpk(zero1,pole1,gain1,'TimeUnit','minutes','InputUnit','minutes')

sys1 =
 
    2 s
  -------
  s (s+8)
 
Continuous-time zero/pole/gain model.

propValues1 = [sys1.TimeUnit,sys1.InputUnit]

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

Créez le deuxième modèle zéro-pôle-gain avec les propriétés héritées de sys1.

zero = 1;
pole = [-3,5];
gain2 = 0.8;
sys2 = zpk(zero,pole,gain2,sys1)

sys2 =
 
   0.8 (s-1)
  -----------
  (s+3) (s-5)
 
Continuous-time zero/pole/gain model.

propValues2 = [sys2.TimeUnit,sys2.InputUnit]

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

Comme vous pouvez le constater, le modèle zéro-pôle-gain sys2 comporte les mêmes propriétés que sys1.

Modèle MIMO zéro-pôle-gain à gain statique

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

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

Spécifiez la matrice de gain et créez le modèle zéro-pôle-gain à gain statique.

m = [2,4;...
    3,5];
sys1 = zpk(m)

sys1 =
 
  From input 1 to output...
   1:  2
 
   2:  3
 
  From input 2 to output...
   1:  4
 
   2:  5
 
Static gain.

Vous pouvez utiliser le modèle zéro-pôle-gain à gain statique sys1 obtenu précédemment et l’organiser en cascade avec un autre modèle du même type.

sys2 = zpk(0,[-1 7],1)

sys2 =
 
       s
  -----------
  (s+1) (s-7)
 
Continuous-time zero/pole/gain model.

sys = series(sys1,sys2)

sys =
 
  From input 1 to output...
           2 s
   1:  -----------
       (s+1) (s-7)
 
           3 s
   2:  -----------
       (s+1) (s-7)
 
  From input 2 to output...
           4 s
   1:  -----------
       (s+1) (s-7)
 
           5 s
   2:  -----------
       (s+1) (s-7)
 
Continuous-time zero/pole/gain model.

Conversion d’un modèle de représentation d’état en modèle zéro-pôle-gain

Pour cet exemple, calculez le modèle zéro-pôle-gain du modèle de représentation d’état suivant :

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

Créez le modèle de représentation d’état au moyen des matrices de représentation d’état.

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

Convertissez le modèle de représentation d’état ltiSys en un modèle zéro-pôle-gain.

sys = zpk(ltiSys)

sys =
 
  From input 1 to output:
        s
  --------------
  (s^2 + 4s + 5)
 
  From input 2 to output:
  (s^2 + 5s + 8)
  --------------
  (s^2 + 4s + 5)
 
Continuous-time zero/pole/gain model.

Tableau de modèles zéro-pôle-gain

Vous pouvez utiliser une boucle for pour spécifier un tableau de modèles zéro-pôle-gain.

Commencez par pré-attribuer le tableau des modèles zéro-pôle-gain avec des zéros.

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

Les deux premiers indices représentent le nombre de sorties et d'entrées pour les modèles, tandis que le troisième indice correspond au nombre de modèles figurant dans le tableau.

Créez le tableau de modèles zéro-pôle-gain en utilisant une expression rationnelle dans la boucle for.

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

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

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

sys(:,:,3,1) =
 
        3
  -------------
  (s^2 + s + 3)
 
3x1 array of continuous-time zero/pole/gain models.

Extraction des modèles zéro-pôle-gain 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 zéro-pôle-gain 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 zéro-pôle-gain.

sysMeas = zpk(ltiSys,'measured') 

sysMeas =
 
  From input "u1" to output "y1":
            -0.14256 z^-1 (1-1.374z^-1)
  z^(-2) * -----------------------------
           (1-0.8789z^-1) (1-0.6958z^-1)
 
Sample time: 0.04 seconds
Discrete-time zero/pole/gain model.

sysNoise = zpk(ltiSys,'noise')

sysNoise =
 
  From input "v@y1" to output "y1":
            0.045563 (1+0.7245z^-1)
  --------------------------------------------
  (1-0.9658z^-1) (1 - 0.0602z^-1 + 0.2018z^-2)
 
Input groups:        
    Name     Channels
    Noise       1    
                     
Sample time: 0.04 seconds
Discrete-time zero/pole/gain 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.

Modèle zéro-pôle-gain avec retard en entrée et en sortie

Pour cet exemple, créez un modèle SISO zéro-pôle-gain avec un retard en entrée de 0,5 seconde et un retard en sortie de 2,5 secondes.

zeros = 5;
poles = [7+1i 7-1i -3];
gains = 1;
sys = zpk(zeros,poles,gains,'InputDelay',0.5,'OutputDelay',2.5)

sys =
 
                      (s-5)
  exp(-3*s) * ----------------------
              (s+3) (s^2 - 14s + 50)
 
Continuous-time zero/pole/gain model.

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

get(sys)

                Z: {[5]}
                P: {[3x1 double]}
                K: 1
    DisplayFormat: 'roots'
         Variable: 's'
          IODelay: 0
       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.

Design de contrôle avec des modèles zéro-pôle-gain

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 le modèle zéro-pôle-gain suivant :

$$sys(s)=\frac{1}{s^2+0.5s+0.1}$$

Créez un objet modèle zéro-pôle-gain sys au moyen de la commande zpk.

zeros = [];
poles = [-0.25+0.2i;-0.25-0.2i];
gain = 1;
sys = zpk(zeros,poles,gain)

sys =
 
            1
  ---------------------
  (s^2 + 0.5s + 0.1025)
 
Continuous-time zero/pole/gain 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.512, Ki = 0.0975, Kd = 0.574, b = 0.38, 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.

Algorithmes

zpk utilise la fonction MATLAB roots pour convertir des fonctions de transfert et les fonctions zero et pole pour convertir des modèles de représentation d’état.

Historique des versions

Introduit avant R2006a

Voir aussi

filt | frd | get | set | ss | zpkdata | genss | tf | realp | genmat

Rubriques

• Fonctions de transfert
• What Are Model Objects?
• Discrete-Time Numeric Models
• Using the Right Model Representation
• Utilisation de la commande FEEDBACK pour fermer les boucles de rétroaction