Modelos MIMO

Modelo de espacio de estados de una aeronave de reacción

Este ejemplo muestra cómo construir un modelo MIMO de una aeronave de reacción. Puesto que el desarrollo de un modelo físico para una aeronave de reacción es un proceso largo, aquí solo se presentan las ecuaciones de espacio de estados. Puede consultar cualquier texto estándar sobre aviación para ver explicaciones más completas acerca de los aspectos físicos del vuelo de una aeronave.

El modelo de reacción durante un vuelo de crucero a MACH = 0,8 y H = 40.000 pies es

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

Use los siguientes comandos para especificar este modelo de espacio de estados como objeto LTI y asigne nombres a los estados, entradas y salidas.

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

Puede mostrar el modelo LTI escribiendo 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.

El modelo tiene dos entradas y dos salidas. Las unidades son radianes para beta (ángulo de deslizamiento) y phi (ángulo de inclinación), y radianes/s para yaw (velocidad de guiñada) y roll (velocidad de alabeo). Las deflexiones del timón y el alerón están en grados.

Como en el caso del sistema SISO, use tf para derivar la representación de la función de transferencia.

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

Creación de funciones de transferencia MIMO

Las funciones de transferencia MIMO son arreglos bidimensionales de funciones de transferencia SISO elementales. Hay dos maneras de especificar modelos de función de transferencia MIMO:

Concatenación de modelos de función de transferencia SISO
Utilizando tf con argumentos de arreglo de celdas

Concatenación de modelos SISO

Considere la siguiente función de transferencia de una entrada y dos salidas:

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

Puede especificar H(s) a partir de la concatenación de sus entradas SISO. Por ejemplo,

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

o, de manera equivalente,

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

se pueden concatenar para formar H(s).

H = [h11; h21]

Esta sintaxis imita la concatenación de matrices estándar y tiende a ser más sencilla y más fácil de leer para los sistemas MIMO con múltiples entradas o salidas.

Usar la función `tf` con arreglos de celdas

De manera alternativa, para definir funciones de transferencia MIMO con tf, se necesitan dos arreglos de celdas (por ejemplo, N y D) para representar el conjunto de numeradores y denominadores polinomiales, respectivamente. Consulte Arreglos de celdas para obtener más información sobre los arreglos de celdas.

Por ejemplo, para la matriz de transferencia racional H(s), los dos arreglos de celdas N y D deberían contener las representaciones del vector fila de las entradas del polinomio de

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

Puede especificar la matriz de transferencia MIMO H(s) introduciendo lo siguiente:

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)

Estos comandos devuelven el siguiente resultado:

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

Tenga en cuenta que N y D tienen las mismas dimensiones que H. Para una matriz de transferencia MIMO general H(s), las entradas del arreglo de celdas N{i,j} y D{i,j} deberían ser representaciones del vector fila del numerador y denominador de H_ij(s), la entrada ij-ésima de la matriz de transferencia H(s).

Acceso a pares E/S en sistemas MIMO

Después de definir un sistema MIMO, puede acceder y manipular los pares E/S al especificar los pares de entrada y salida del sistema. Por ejemplo, si sys_mimo es un sistema MIMO con dos entradas y tres salidas,

sys_mimo(3,1)

se extrae el subsistema y mapea la primera entrada a la tercera salida. Los índices de fila seleccionan las salidas y los índices de columna, las entradas. Del mismo modo,

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