Modèles MIMO

Modèle de représentation d'état d'un avion de transport à réaction

Cet exemple montre comment construire un modèle MIMO d'un transport à réaction. Comme le développement d'un modèle physique pour un avion à réaction est long, seules les équations de représentation d'état sont présentées ici. Consultez des articles et documentations standard sur l'aviation pour une discussion plus complète sur la physique du vol des avions.

Le modèle de jet pendant le vol de croisière à MACH = 0,8 et H = 12 192 m est

A = [-0.0558   -0.9968    0.0802    0.0415
      0.5980   -0.1150   -0.0318         0
     -3.0500    0.3880   -0.4650         0
           0    0.0805    1.0000         0];

B = [ 0.0073         0
     -0.4750    0.0077
      0.1530    0.1430
           0         0];

C = [0     1     0     0
     0     0     0     1];

D = [0     0
     0     0];

Utilisez les commandes suivantes pour spécifier ce modèle de représentation d'état comme un objet LTI et attacher des noms aux états, aux entrées et aux sorties.

states = {'beta' 'yaw' 'roll' 'phi'};
inputs = {'rudder' 'aileron'};
outputs = {'yaw rate' 'bank angle'};

sys_mimo = ss(A,B,C,D,'statename',states,...
'inputname',inputs,...
'outputname',outputs);

Vous pouvez afficher le modèle LTI en saisissant sys_mimo.

sys_mimo
 
a = 
                      beta          yaw         roll          phi
         beta      -0.0558      -0.9968       0.0802       0.0415
          yaw        0.598       -0.115      -0.0318            0
         roll        -3.05        0.388       -0.465            0
          phi            0       0.0805            1            0
 
 
b = 
                    rudder      aileron
         beta       0.0073            0
          yaw       -0.475       0.0077
         roll        0.153        0.143
          phi            0            0
 
 
c = 
                      beta          yaw         roll          phi
     yaw rate            0            1            0            0
   bank angle            0            0            0            1
 
 
d = 
                    rudder      aileron
     yaw rate            0            0
   bank angle            0            0
 
Continuous-time model.

Le modèle comporte deux entrées et deux sorties. Les unités sont les radians pour beta (angle de dérapage) et phi (angle d'inclinaison) et les radians/sec pour yaw (taux de lacet) et roll (taux de roulis). Les déflexions de la gouverne de direction et des ailerons sont exprimées en degrés.

Comme dans le cas d'un SISO, utilisez tf pour dériver la représentation de la fonction de transfert.

tf(sys_mimo)
 
Transfer function from input "rudder" to output...
               -0.475 s^3 - 0.2479 s^2 - 0.1187 s - 0.05633
 yaw rate:  ---------------------------------------------------
            s^4 + 0.6358 s^3 + 0.9389 s^2 + 0.5116 s + 0.003674
 
                         0.1148 s^2 - 0.2004 s - 1.373
 bank angle:  ---------------------------------------------------
              s^4 + 0.6358 s^3 + 0.9389 s^2 + 0.5116 s + 0.003674
 
Transfer function from input "aileron" to output...
            0.0077 s^3 - 0.0005372 s^2 + 0.008688 s + 0.004523
 yaw rate:  ---------------------------------------------------
            s^4 + 0.6358 s^3 + 0.9389 s^2 + 0.5116 s + 0.003674
 
                        0.1436 s^2 + 0.02737 s + 0.1104
 bank angle:  ---------------------------------------------------
              s^4 + 0.6358 s^3 + 0.9389 s^2 + 0.5116 s + 0.003674

Construction des fonctions de transfert MIMO

Les fonctions de transfert MIMO sont des tableaux bidimensionnels de fonctions de transfert SISO élémentaires. Il existe deux façons de spécifier les modèles de fonction de transfert MIMO :

Concaténation de modèles de fonctions de transfert SISO
Utilisation de tf avec des cell array comme arguments

Concaténation de modèles SISO

Considérez la fonction de transfert suivante à une entrée et deux sorties.

$H (s) = [\begin{matrix} \frac{s - 1}{s + 1} \\ \frac{s + 2}{s^{2} + 4 s + 5} \end{matrix}]$

Vous pouvez spécifier H(s) par concaténation de ses entrées SISO. Par exemple,

h11 = tf([1 -1],[1 1]);		
h21 = tf([1 2],[1 4 5]);

ou, de manière équivalente,

s = tf('s')
h11 = (s-1)/(s+1);
h21 = (s+2)/(s^2+4*s+5);

peuvent être concaténés pour former H(s).

H = [h11; h21]

Cette syntaxe imite la concaténation de matrices standard et tend à être plus facile et plus lisible pour les systèmes MIMO avec de nombreuses entrées et/ou sorties.

Utilisation de la fonction `tf` avec des cell arrays

Alternativement, pour définir les fonctions de transfert MIMO en utilisant tf, vous avez besoin de deux cell arrays (disons, N et D) pour représenter respectivement les ensembles de polynômes numérateur et dénominateur. Voir Cell arrays pour plus de détails sur les cell arrays.

Par exemple, pour la matrice de transfert rationnelle H(s), les deux cell arrays N et D doivent contenir sous forme de vecteurs lignes les entrées polynomiales de

$N (s) = [\frac{s - 1}{s + 2}] D (s) = [\frac{s + 1}{s^{2} + 4 s + 5}]$

Vous pouvez spécifier cette matrice de transfert MIMO H(s) en saisissant

N = {[1 -1];[1 2]};   % Cell array for N(s)
D = {[1 1];[1 4 5]}; % Cell array for D(s)
H = tf(N,D)

Ces commandes renvoient le résultat suivant :

Transfer function from input to output...
      s - 1
 #1:  -----
      s + 1
 
          s + 2
 #2:  -------------
      s^2 + 4 s + 5

Notez que N et D ont les mêmes dimensions que H. Pour une matrice de transfert MIMO générale H(s), les entrées des cell array N{i,j} et D{i,j} doivent être le numérateur et le dénominateur sous forme de vecteurs lignes de H_ij(s), la ije entrée de la matrice de transfert H(s).

Accès aux paires d'E/S dans les systèmes MIMO

Après avoir défini un système MIMO, vous pouvez accéder aux paires d'E/S et les manipuler en spécifiant les paires d'entrée et de sortie du système. Par exemple, si sys_mimo est un système MIMO avec deux entrées et trois sorties,

sys_mimo(3,1)

extrait le sous-système, en mettant en correspondance la première entrée et la troisième sortie. Les indices de ligne sélectionnent les sorties et les indices de colonne sélectionnent les entrées. De même,

sys_mimo(3,1) = tf(1,[1 0])