Main Content

Modèles linéaires (LTI)

Qu'est-ce qu'un système physique ?

En général, les ingénieurs en contrôle commencent par élaborer une description mathématique du système dynamique qu'ils veulent contrôler. Le système à contrôler est appelé un système physique. Comme exemple de système physique, cette section utilise le moteur DC. Cette section développe les équations différentielles qui décrivent les propriétés électromécaniques d'un moteur DC avec une charge inertielle. Elle vous montre ensuite comment utiliser les fonctions de Control System Toolbox™ pour construire des modèles linéaires basés sur ces équations.

Représentations de modèles linéaires

Vous pouvez utiliser les fonctions de Control System Toolbox pour créer les représentations de modèle suivantes :

  • Modèles de représentation d'état (State-Space, SS) de la forme

    dxdt=Ax+Buy=Cx+Du

    A, B, C et D sont des matrices de dimensions appropriées, x est le vecteur d'état, et u et y sont les vecteurs d'entrée et de sortie.

  • Les fonctions de transfert (TF), par exemple,

    H(s)=s+2s2+s+10

  • Les modèles zéro-pôle-gain (ZPK), par exemple,

    H(z)=3(z+1+j)(z+1j)(z+0.2)(z+0.1)

  • Les modèles de données de réponses fréquentielles (Frequency Response Data, FRD), qui consistent en des mesures échantillonnées de la réponse fréquentielle d'un système. Par exemple, vous pouvez stocker des données de réponses fréquentielles recueillies expérimentalement dans un modèle FRD.

    Remarque

    Le design de modèles FRD est un sujet spécialisé que cette rubrique n'aborde pas. Consultez Frequency Response Data (FRD) Models pour voir une discussion sur ce sujet.

Exemple de SISO : le moteur DC

Un modèle simple d'un moteur DC entraînant une charge inertielle montre la vitesse angulaire de la charge, ω(t), en tant que tension appliquée et de sortie, υapp(t), en tant qu'entrée. Le but ultime de cet exemple est de contrôler la vitesse angulaire en faisant varier la tension appliquée. Cette figure montre un modèle simple du moteur DC.

Un modèle simple d'un moteur DC entraînant une charge inertielle

Dans ce modèle, la dynamique du moteur lui-même est idéalisée ; par exemple, le champ magnétique est supposé être constant. La résistance du circuit est désignée par R et l'auto-inductance de l'armature par L. Si vous n'êtes pas familier avec les bases de la modélisation des moteurs DC, consultez n'importe quel article de base sur la modélisation physique. Avec ce modèle simple et les lois fondamentales de la physique, il est possible de développer des équations différentielles qui décrivent le comportement de ce système électromécanique. Dans cet exemple, les relations entre le potentiel électrique et la force mécanique sont la loi d'induction de Faraday et la loi d'Ampère pour la force sur un conducteur se déplaçant dans un champ magnétique.

Dérivation mathématique

Le couple τ de l'arbre moteur est proportionnel au courant i induit par la tension appliquée,

τ(t)=Kmi(t)

Km, la constante d'armature, est liée aux propriétés physiques du moteur, telles que l'intensité du champ magnétique, le nombre de tours du fil autour de la bobine conductrice, etc. La force électromotrice arrière (induite), υemf, est une tension proportionnelle à la vitesse angulaire ω vue au niveau de l'arbre,

υemf(t)=Kbω(t)

Kb, la constante emf, dépend également de certaines propriétés physiques du moteur.

La partie mécanique des équations du moteur est dérivée en utilisant la loi de Newton, qui stipule que la charge d'inertie J multipliée par la dérivée de la vitesse angulaire est égale à la somme de tous les couples autour de l'arbre moteur. Le résultat est cette équation,

Jdwdt=τi=Kfω(t)+Kmi(t)

Kfω est une approximation linéaire pour la friction visqueuse.

Enfin, la partie électrique des équations du moteur peut être décrite par

υapp(t)υemf(t)=Ldidt+Ri(t)

ou, en résolvant l'équation pour la tension appliquée et en substituant la force électromotrice arrière,

υapp(t)=Ldidt+Ri(t)+Kbω(t)

Cette séquence d'équations conduit à un ensemble de deux équations différentielles qui décrivent le comportement du moteur, la première pour le courant induit,

didt=RLi(t)KbLω(t)+1Lυapp(t)

et la seconde pour la vitesse angulaire résultante,

dωdt=1JKfω(t)+1JKmi(t)

Équations de représentation d'état pour le moteur DC

Étant donné les deux équations différentielles dérivées dans la dernière section, vous pouvez maintenant développer une représentation d'état du moteur DC en tant que système dynamique. Le courant i et la vitesse angulaire ω sont les deux états du système. La tension appliquée, υapp, est l'entrée du système, et la vitesse angulaire ω est la sortie.

ddt[iω]=[RLKbLKmJKfJ][iω]+[1L0]υapp(t)

Représentation d'état de l'exemple du moteur DC

y(t)=[01][iω]+[0]υapp(t)

Construire des modèles SISO

Après avoir développé un ensemble d'équations différentielles qui décrivent votre installation, vous pouvez construire des modèles SISO à l'aide de commandes simples. Les sections suivantes traitent de

  • Construction d'un modèle de représentation d'état du moteur DC

  • Conversion entre les représentations de modèle

  • Création de la fonction de transfert et des modèles zéro/pôle/gain

Construction d'un modèle de représentation d'état du moteur DC

Entrez les valeurs nominales suivantes pour les différents paramètres d'un moteur DC.

R= 2.0 % Ohms
L= 0.5 % Henrys
Km = .015 % torque constant
Kb = .015 % emf constant
Kf = 0.2 % Nms
J= 0.02 % kg.m^2

Étant donné ces valeurs, vous pouvez construire la représentation d'état numérique à l'aide de la fonction ss.

A = [-R/L -Kb/L; Km/J -Kf/J]
B = [1/L; 0];
C = [0 1];
D = [0];
sys_dc = ss(A,B,C,D)

Ces commandes renvoient le résultat suivant :

a = 
                        x1           x2
           x1           -4        -0.03
           x2         0.75          -10
 
 
b = 
                        u1
           x1            2
           x2            0
 
 
c = 
                        x1           x2
           y1            0            1
 
 
d = 
                        u1
           y1            0

Conversion entre les représentations de modèle

Maintenant que vous disposez d'une représentation d'état du moteur DC, vous pouvez passer à d'autres représentations de modèle, notamment la fonction de transfert (TF) et les modèles zéro/pôle/gain (ZPK).

Représentation de la fonction de transfert.  Vous pouvez utiliser tf pour convertir la représentation d'état en fonction de transfert. Par exemple, utilisez ce code pour réaliser la conversion vers la représentation de la fonction de transfert du moteur DC.

sys_tf = tf(sys_dc)
Transfer function:
       1.5
------------------
s^2 + 14 s + 40.02

Représentation zéro-pôle-gain.  De la même façon, la fonction zpk convertit les représentations d'état ou de la fonction de transfert au format zéro/pôle/gain. Utilisez ce code pour réaliser la conversion de la représentation d'état en une représentation zéro/pôle/gain pour le moteur DC.

sys_zpk = zpk(sys_dc)
 
Zero/pole/gain:
        1.5
-------------------
(s+4.004) (s+9.996)

Remarque

La représentation d'état est la mieux adaptée aux calculs numériques. Pour une précision maximale, convertissez en représentation d'état avant de combiner les modèles et évitez les représentations de la fonction de transfert et de zéro/pôle/gain, sauf pour la spécification et l'inspection du modèle.

Construction de la fonction de transfert et des modèles zéro/pôle/gain

Dans l'exemple du moteur DC, l'approche de représentation d'état produit un ensemble de matrices qui représente le modèle. Si vous choisissez une approche différente, vous pouvez construire les modèles correspondants à l'aide de tf, zpk, ss ou frd.

sys = tf(num,den)               % Transfer function
sys = zpk(z,p,k)                % Zero/pole/gain
sys = ss(a,b,c,d)               % State-space
sys = frd(response,frequencies) % Frequency response data

Par exemple, vous pouvez créer la fonction de transfert en spécifiant le numérateur et le dénominateur avec ce code.

sys_tf = tf(1.5,[1 14 40.02])
 
Transfer function:
       1.5
------------------
s^2 + 14 s + 40.02

Sinon, si vous souhaitez créer directement la fonction de transfert du moteur DC, utilisez ces commandes.

s = tf('s');
sys_tf = 1.5/(s^2+14*s+40.02)

Ces commandes donnent lieu à cette fonction de transfert.

Transfer function:
        1.5
--------------------
s^2 + 14 s + 40.02

Pour construire le modèle zéro-pôle-gain, utilisez cette commande.

sys_zpk = zpk([],[-9.996 -4.004], 1.5)

Cette commande renvoie la représentation zéro-pôle-gain suivante.

Zero/pole/gain:
        1.5
-------------------
(s+9.996) (s+4.004)

Construire des systèmes à temps discret

Le logiciel Control System Toolbox offre un support complet pour les systèmes à temps discret. Vous pouvez créer des systèmes discrets de la même manière que vous créez des systèmes analogiques ; la seule différence est que vous devez spécifier un pas d'échantillonnage pour tout modèle que vous construisez. Par exemple,

sys_disc = tf(1, [1 1], .01);

crée un modèle SISO au format de la fonction de transfert.

Transfer function:
  1
-----
z + 1
 
Sample time: 0.01

Ajout de retards aux modèles à temps discret

Vous pouvez ajouter des retards aux modèles à temps discret en spécifiant un retard d'entrée, un retard de sortie ou un retard d'E/S lors de la construction du modèle. Le retard doit être un nombre entier non négatif qui représente un multiple du pas d'échantillonnage. Par exemple,

sys_delay = tf(1, [1 1], 0.01,'ioDelay',5)

renvoie un système avec un retard d'E/S de 5 s.

Transfer function:
           1
z^(-5) * -----
         z + 1
 
Sample time: 0.01

Ajout de retards aux modèles linéaires

Vous pouvez ajouter des retards aux modèles linéaires en spécifiant un retard d'entrée, un retard de sortie ou un retard d'E/S lors de la construction d'un modèle. Par exemple, pour ajouter un retard d'E/S au moteur DC, utilisez ce code.

sys_tfdelay = tf(1.5,[1 14 40.02],'ioDelay',0.05)

Cette commande construit la fonction de transfert du moteur DC, mais ajoute un retard de 0,05 seconde.

Transfer function:
                      1.5
exp(-0.05*s) * ------------------
               s^2 + 14 s + 40.02

Pour plus d'informations sur l'ajout de retards aux modèles, voir Time Delays in Linear Systems.

Objets LTI

Pour plus de commodité, le software Control System Toolbox utilise des structures de données personnalisées appelées LTI objects pour stocker les données liées au modèle. Par exemple, la variable sys_dc créée pour l'exemple du moteur DC est appelée un SS object. Il existe également des objets TF, ZPK et FRD pour, respectivement, les modèles de fonction de transfert, de zéro/pôle/gain et de réponse aux données de fréquence. Les quatre objets LTI encapsulent les données du modèle et vous permettent de manipuler les systèmes linéaires comme des entités uniques plutôt que comme des collections de vecteurs ou de matrices.

Pour voir ce que les objets LTI contiennent, utilisez la commande get. Ce code décrit le contenu de sys_dc pour l'exemple du moteur DC.

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

Vous pouvez manipuler les données contenues dans les objets LTI à l'aide de la commande set ; consultez les pages de référence en ligne de Control System Toolbox pour obtenir une description de set et get.

Une autre façon pratique de définir ou de récupérer les propriétés du modèle LTI est d'y accéder directement en utilisant la notation par points. Par exemple, si vous voulez accéder à la valeur de la matrice A, au lieu d'utiliser get, vous pouvez saisir

sys_dc.A

dans l'invite de commande de MATLAB®. Cette notation renvoie la matrice A.

ans =

   -4.0000   -0.0300
    0.7500  -10.0000

De même, si vous souhaitez modifier les valeurs de la matrice A, vous pouvez le faire directement, comme le montre ce code.

A_new = [-4.5 -0.05; 0.8 -12.0];
sys_dc.A = A_new;

Voir aussi

| |

Exemples associés

En savoir plus