Main Content

tf

Modèle de fonction de transfert

Description

Utilisez tf pour créer des modèles de fonction de transfert à valeurs réelles ou complexes, ou pour convertir des modèles de systèmes dynamiques en modèles de fonction de transfert.

Les fonctions de transfert sont une représentation du domaine fréquentiel des systèmes linéaires invariants dans le temps. Par exemple, considérons un système dynamique SISO en temps continu représenté par la fonction de transfert sys(s) = N(s)/D(s), où s = jw, N(s) et D(s) sont appelés respectivement les polynômes numérateur et dénominateur. L’objet de modèle tf peut représenter des fonctions de transfert SISO ou MIMO en temps continu ou discret.

Vous pouvez créer un objet de modèle de fonction de transfert en spécifiant directement ses coefficients ou en convertissant un modèle d’un autre type (tel qu’un modèle de représentation d’état ss) en modèle de fonction de transfert. Pour plus d’informations, consultez Fonctions de transfert.

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

Création

Description

exemple

sys = tf(numerator,denominator) crée un modèle de fonction de transfert en temps continu en définissant les propriétés Numerator et Denominator. Par exemple, considérons un système dynamique SISO en temps continu représenté par la fonction de transfert sys(s) = N(s)/D(s). Les arguments en entrée numerator et denominator sont respectivement les coefficients de N(s) et D(s).

exemple

sys = tf(numerator,denominator,ts) crée un modèle de fonction de transfert en temps discret en définissant les propriétés Numerator, Denominator et Ts. Par exemple, considérons un système dynamique SISO en temps discret représenté par la fonction de transfert sys(z) = N(z)/D(z). Les arguments en entrée numerator et denominator sont respectivement les coefficients de N(z) et D(z). Pour ne pas spécifier le pas d’échantillonnage, définissez l’argument ts en entrée à -1.

exemple

sys = tf(numerator,denominator,ltiSys) crée un modèle de fonction de transfert avec les propriétés héritées du modèle de système dynamique ltiSys, y compris le pas d’échantillonnage.

exemple

sys = tf(m) crée un modèle de fonction de transfert représentant le gain statique, m.

exemple

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

exemple

sys = tf(ltiSys) convertit le modèle de systèmes dynamiques ltiSys en un modèle de fonction de transfert.

exemple

sys = tf(ltiSys,component) convertit le component spécifié de ltiSys en modèle de fonction de transfert. Vous ne devez utiliser cette syntaxe que lorsque ltiSys est un modèle linéaire identifié invariant dans le temps.

exemple

s = tf('s') crée une variable spéciale s que vous pouvez utiliser dans une expression rationnelle pour créer un modèle de fonction de transfert 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.

exemple

z = tf('z',ts) crée une variable spéciale z que vous pouvez utiliser dans une expression rationnelle pour créer un modèle de fonction de transfert 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

développer tout

Coefficients du numérateur de la fonction de transfert, spécifiés sous les formes suivantes :

  • Vecteur ligne de coefficients polynomiaux.

  • Cell array Ny par Nu de vecteurs ligne servant à spécifier une fonction de transfert MIMO où Ny désigne le nombre de sorties et Nu, le nombre d’entrées.

Lorsque vous créez la fonction de transfert, spécifiez les coefficients du numérateur dans l’ordre des puissances décroissantes. Par exemple, si le numérateur de la fonction de transfert est 3s^2-4s+5, spécifiez numerator en tant que [3 -4 5]. Dans le cas d’une fonction de transfert en temps discret dotée du numérateur 2z-1, définissez numerator sur [2 -1].

Définissez également une propriété de l’objet tf. Pour plus d’informations, consultez Numerator.

Coefficients du dénominateur spécifiés sous les formes suivantes :

  • Vecteur ligne de coefficients polynomiaux.

  • Cell array Ny par Nu de vecteurs ligne servant à spécifier une fonction de transfert MIMO où Ny désigne le nombre de sorties et Nu, le nombre d’entrées.

Lorsque vous créez la fonction de transfert, spécifiez les coefficients du dénominateur dans l’ordre des puissances décroissantes. Par exemple, si le dénominateur de la fonction de transfert est 7s^2+8s-9, spécifiez denominator en tant que [7 8 -9]. Dans le cas d’une fonction de transfert en temps discret dotée du dénominateur 2z^2+1, définissez denominator sur [2 0 1].

Définissez également une propriété de l’objet tf. Pour plus d’informations, consultez Denominator.

Pas d’échantillonnage spécifié en tant que scalaire. Définissez également une propriété de l’objet tf. Pour plus d’informations, consultez Ts.

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, le software Robust Control Toolbox™ est nécessaire.)

    La fonction de transfert résultante 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)

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.

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

développer tout

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

  • Objet de modèle de fonction de transfert (tf) où les arguments en entrée numerator et denominator sont des tableaux numériques.

  • Objet de modèle de représentation d’état généralisé (genss) lorsque l’argument en entrée numerator ou denominator comprend des paramètres réglables, tels que les paramètres realp ou les matrices généralisées (genmat). Pour un exemple, voir Filtre passe-bas réglable.

  • Objet de modèle de représentation d’état incertain (uss) lorsque l‘argument en entrée numerator ou denominator comprend des paramètres incertains. Pour pouvoir utiliser les modèles incertains, le software Robust Control Toolbox est nécessaire. Pour un exemple, voir Transfer Function with Uncertain Coefficients (Robust Control Toolbox).

Propriétés

développer tout

Coefficients du numérateur spécifiés sous les formes suivantes :

  • Vecteur ligne de coefficients polynomiaux organisé par ordre de puissances décroissantes (pour les valeurs Variable 's', 'z', 'p' ou 'q') ou par ordre de puissances croissantes (pour les valeurs Variable 'z^-1' ou 'q^-1').

  • Cell array Ny par Nu de vecteurs ligne servant à spécifier une fonction de transfert MIMO où Ny désigne le nombre de sorties et Nu, le nombre d’entrées. Chaque élément du cell array spécifie les coefficients du numérateur pour une paire entrée/sortie donnée. Si vous spécifiez Numerator et Denominator en tant que cell arrays, ils doivent présenter les mêmes dimensions.

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

Coefficients du dénominateur spécifiés sous les formes suivantes :

  • Vecteur ligne de coefficients polynomiaux par ordre de puissances décroissantes (pour les valeurs Variable 's', 'z', 'p', ou 'q') ou par ordre de puissances croissantes (pour les valeurs Variable 'z^-1' ou 'q^-1').

  • Cell array Ny par Nu de vecteurs ligne servant à spécifier une fonction de transfert MIMO où Ny désigne le nombre de sorties et Nu, le nombre d’entrées. Chaque élément du cell array spécifie les coefficients du numérateur pour une paire entrée/sortie donnée. Si vous spécifiez Numerator et Denominator en tant que cell arrays, ils doivent présenter les mêmes dimensions.

Si toutes les entrées SISO d’une fonction de transfert MIMO présentent le même dénominateur, vous pouvez spécifier Denominator en tant que vecteur ligne tout en spécifiant Numerator en tant que cell array.

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

Variable d’affichage de la fonction de transfert 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'

La valeur de Variable apparaît dans l'affichage et affecte également l'interprétation des vecteurs de coefficient Numerator et Denominator pour les modèles en temps discret.

  • Pour les valeurs Variable 's', 'z', 'p' ou 'q', les coefficients sont classés dans l’ordre des puissances décroissantes de la variable. Par exemple, considérons le vecteur ligne [ak ... a1 a0]. L’ordre polynomial est spécifié sous la forme akzk+...+a1z+a0.

  • Pour les valeurs Variable 'z^-1' ou 'q^-1', les coefficients sont classés dans l’ordre des puissances croissantes de la variable. Par exemple, considérons le vecteur ligne [b0 b1 ... bk]. L’ordre polynomial est spécifié sous la forme b0+b1z1+...+bkzk.

Pour consulter des exemples, voir Spécification de l’ordre polynomial dans la fonction de transfert en temps discret, Modèle de fonction de transfert utilisant une expression rationnelle et Modèle de fonction de transfert en temps discret utilisant une expression rationnelle.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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

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.

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

développer tout

stepStep response of dynamic system
impulseImpulse response plot of dynamic system; impulse response data
lsimPlot simulated time response of dynamic system to arbitrary inputs; simulated response data
bodeBode plot of frequency response, or magnitude and phase data
nyquistNyquist plot of frequency response
nicholsNichols chart of frequency response
bandwidthFrequency response bandwidth
polePoles of dynamic system
zeroZeros and gain of SISO dynamic system
pzplotPole-zero plot of dynamic system model with additional plot customization options
marginGain margin, phase margin, and crossover frequencies
zpkZero-pole-gain model
ssModèle de représentation d'état
c2dConvert model from continuous to discrete time
d2cConvert model from discrete to continuous time
d2dResample discrete-time model
feedbackFeedback connection of multiple models
connectBlock diagram interconnections of dynamic systems
seriesConnexion en série de deux modèles
parallelParallel connection of two models
pidtunePID tuning algorithm for linear plant model
rlocusTracé des lieux des racines d’un système dynamique
lqrDesign d'un régulateur linéaire quadratique (LQR, Linear Quadratic Regulator)
lqgLinear-Quadratic-Gaussian (LQG) design
lqiLinear-Quadratic-Integral control
kalmanDesign Kalman filter for state estimation

Exemples

réduire tout

Pour cet exemple, considérons le modèle de fonction de transfert SISO suivant :

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

Spécifiez les coefficients du numérateur et du dénominateur classés dans l’ordre des puissances décroissantes de s, et créez le modèle de fonction de transfert.

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

Pour cet exemple, considérons le modèle de fonction de transfert SISO en temps discret suivant :

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

Spécifiez les coefficients du numérateur et du dénominateur classés dans l’ordre des puissances décroissantes de z, et un pas d’échantillonnage de 0,1 s. Créez le modèle de fonction de transfert en temps discret.

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

Pour cet exemple, considérons un modèle de fonction de transfert qui représente un système de deuxième ordre avec la fréquence naturelle et l’amortissement connus.

Voici la fonction de transfert d’un système de deuxième ordre, exprimée en fonction de son amortissement ζ et de la fréquence naturelle ω0 :

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

Sur la base d'un amortissement ζ = 0,25 et d’une fréquence naturelle ω0 = 3 rad/s, créez la fonction de transfert de deuxième ordre.

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

Examinez la réponse de cette fonction de transfert à une entrée indicielle.

stepplot(sys)

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

Le tracé indique l’appel en aval attendu d’un système de deuxième ordre avec un faible amortissement.

Créez une fonction de transfert pour le modèle MIMO en temps discret :

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

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

Spécifiez les coefficients du numérateur sous la forme d’une matrice 2 par 2.

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

Spécifiez les coefficients du dénominateur commun en tant que vecteur ligne.

denominator = [1 0.3];

Créez le modèle de fonction de transfert MIMO en temps discret.

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

Pour plus d'informations sur la création de fonctions de transfert MIMO, voir Fonctions de transfert MIMO.

Dans cet exemple, vous créez un modèle de fonction de transfert MIMO en concaténant des modèles de fonction de transfert SISO. Considérons la fonction de transfert SISO suivante :

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

Spécifiez le modèle de fonction de transfert MIMO en concaténant les entrées SISO.

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

Pour plus d'informations sur la création de fonctions de transfert MIMO, voir Fonctions de transfert MIMO.

Pour cet exemple, créez un modèle de fonction de transfert 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 les coefficients polynomiaux du numérateur et du dénominateur.

Considérons le système suivant :

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

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

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

Créez le modèle de fonction de transfert en utilisant s dans l’expression rationnelle.

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

Pour cet exemple, créez un modèle de fonction de transfert 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 coefficients polynomiaux.

Considérons le système suivant :

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

Pour créer le modèle de fonction de transfert, commencez par spécifier z en tant qu’objet tf et le pas d’échantillonnage Ts.

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

Créez le modèle de fonction de transfert en utilisant z dans l’expression rationnelle.

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

Pour cet exemple, créez un modèle de fonction de transfert avec les propriétés héritées d’un autre modèle du même type. Considérons les deux fonctions de transfert suivantes :

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

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

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

Créez le deuxième modèle de fonction de transfert avec les propriétés héritées de sys1.

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

Comme vous pouvez le constater, le modèle de fonction de transfert sys2 comporte les mêmes propriétés que sys1.

Vous pouvez utiliser une boucle for pour spécifier un tableau de modèles de fonction de transfert.

Commencez par pré-attribuer le tableau des fonctions de transfert avec des zéros.

sys = tf(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 de fonction de transfert en utilisant une expression rationnelle dans la boucle for.

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

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

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

Pour cet exemple, calculez la fonction de transfert du modèle de représentation d’état suivant :

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

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 une fonction de transfert.

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

Pour cet exemple, extrayez la composante mesurée et la composante de bruit d’un modèle polynomial identifié vers deux fonctions de transfert distinctes.

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)=BFu(t)+CDe(t)BF représente la composante mesurée et CD, la composante de bruit.

Extrayez la composante mesurée et la composante de bruit en tant que fonctions de transfert.

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

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.

Les objets de modèle de fonction de transfert comportent des données de modèle qui vous aident à assurer le suivi de ce que représente le modèle. Par exemple, vous pouvez attribuer des noms aux entrées et sorties de votre modèle.

Considérons le modèle de fonction de transfert MIMO en temps continu suivant :

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

Le modèle comporte une entrée - et deux sorties -, le couple et la vitesse angulaire.

Commencez par spécifier les coefficients du numérateur et du dénominateur du modèle.

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

Créez le modèle de fonction de transfert en spécifiant le nom de l'entrée et les noms des sorties.

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

Pour cet exemple, spécifiez l’ordre polynomial dans la fonction de transfert en temps discret au moyen de la propriété Variable.

Considérons les fonctions de transfert en temps discret suivantes avec un pas d’échantillonnage de 0,1 s :

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

Créez la fonction de transfert en temps discret en spécifiant les coefficients z.

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

Les coefficients de sys1 sont classés dans l’ordre des puissances décroissantes de z.

tf change de convention sur la base de la valeur de la propriété Variable. Étant donné que sys2 est le modèle de fonction de transfert inverse de sys1, spécifiez Variable en tant que z^-1 et utilisez les mêmes coefficients pour le numérateur et le dénominateur.

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

Les coefficients de sys2 sont à présent classés dans l’ordre des puissances croissantes de z^-1.

Sur la base des différentes conventions, vous pouvez spécifier l’ordre polynomial dans les modèles de fonction de transfert au moyen de la propriété Variable.

Dans cet exemple, vous allez créer un filtre passe-bas avec un seul paramètre réglable, a :

F=as+a

Étant donné que les coefficients du numérateur et du dénominateur d’un bloc tunableTF sont indépendants, vous ne pouvez pas utiliser tunableTF pour représenter F. Au lieu de cela, construisez F avec l’objet de paramètre réel réglable realp.

Créez un paramètre réglable réel avec une valeur initiale de 10.

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

Real scalar parameter.

Utilisez tf pour créer le filtre passe-bas réglable F.

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

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

F est un objet genss doté du paramètre réglable a dans sa propriété Blocks. Vous pouvez connecter F avec d’autres modèles réglables ou numériques afin de créer des modèles de systèmes de contrôle plus complexes. Pour un exemple, voir Control System with Tunable Components.

Dans cet exemple, vous allez créer un modèle de fonction de transfert MIMO à gain statique.

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

m=[2435]

Spécifiez la matrice de gain et créez le modèle de fonction de transfert à gain statique.

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

Vous pouvez utiliser le modèle de fonction de transfert à gain statique sys1 obtenu précédemment et l’organiser en cascade avec un autre modèle de fonction de transfert.

Pour cet exemple, créez un autre modèle de fonction de transfert à deux entrées et deux sorties, et utilisez la fonction series pour connecter les deux modèles.

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

Limitations

  • Les modèles de fonction de transfert sont mal adaptés aux calculs numériques. Une fois créés, convertissez-les en modèles de représentation d’état avant de les associer à d'autres modèles ou de les transformer. Vous pouvez alors reconvertir les modèles obtenus en fonctions de transfert à des fins d’inspection

  • Un modèle non linéaire identifié ne peut pas être converti directement en modèle de fonction de transfert au moyen de tf. Pour obtenir un modèle de fonction de transfert :

    1. Convertissez le modèle non linéaire identifié en un modèle LTI identifié au moyen de linapp (System Identification Toolbox), de idnlarx/linearize (System Identification Toolbox) ou de idnlhw/linearize (System Identification Toolbox).

    2. Convertissez ensuite le modèle obtenu en un modèle de fonction de transfert au moyen de tf.

Historique des versions

Introduit avant R2006a