La traducción de esta página aún no se ha actualizado a la versión más reciente. Haga clic aquí para ver la última versión en inglés.

Especificar retardos de tiempo

Abrir script

Este ejemplo muestra cómo Control System Toolbox™ permite representar, manipular y analizar cualquier modelo LTI con un número finito de retardos. Los retardos pueden producirse en las entradas o salidas del sistema, entre pares E/S específicos o ser internos al modelo (por ejemplo, dentro de un lazo de feedback).

Retardos de tiempo en modelos LTI

Los objetos de función de transferencia (TF), cero-polo-ganancia (ZPK) y datos de respuesta en frecuencia (FRD) ofrecen tres propiedades para modelar retardos:

  • InputDelay, para especificar retardos en las entradas

  • OutputDelay, para especificar retardos en las salidas

  • IODelay, para especificar retardos de transporte independientes para cada par E/S.

El objeto de espacio de estados (SS) también tiene tres propiedades relacionadas con el retardo:

  • InputDelay, para especificar retardos en las entradas

  • OutputDelay, para especificar retardos en las salidas

  • InternalDelay, para realizar un seguimiento de los retardos cuando se combinan modelos o se cierran lazos de feedback.

La capacidad de realizar un seguimiento de los retardos internos hace que la representación en el espacio de estados sea la más adecuada para modelar y analizar los efectos del retardo en los sistemas de control. Este tutorial muestra cómo construir y manipular sistemas con retardos. Para más información sobre cómo analizar los efectos del retardo, consulte Analyzing Control Systems with Delays.

Modelos de primer orden con retraso de tiempo

Los modelos de primer orden con retraso de tiempo se suelen usar en aplicaciones de control de procesos. Un ejemplo es:

$$P(s) = {5 e^{-3.4 s} \over s+1} $$

Para especificar esta función de transferencia, utilice

num = 5;
den = [1 1];
P = tf(num,den,'InputDelay',3.4)

P =
 
                  5
  exp(-3.4*s) * -----
                s + 1
 
Continuous-time transfer function.

Como se esperaba, la respuesta al escalón de P es una versión desplazada de la respuesta sin retardos:

P0 = tf(num,den);
step(P0,'b',P,'r')

Si el modelo de proceso tiene múltiples salidas, por ejemplo:

$$P(s) = \left[\matrix{{5 e^{-3.4 s} \over s+1} \cr {-2 e^{-2.7 s} \over s+3} }\right] , $$

puede utilizar la propiedad OutputDelay para especificar un retardo diferente para cada canal de salida:

num = {5 ; -2};
den = {[1 1] ; [1 3]};
P = tf(num,den,'OutputDelay',[3.4 ; 2.7])

P =
 
  From input to output...
                       5
   1:  exp(-3.4*s) * -----
                     s + 1
 
                      -2
   2:  exp(-2.7*s) * -----
                     s + 3
 
Continuous-time transfer function.

Consideremos a continuación un modelo de múltiples entradas y salidas, por ejemplo,

$$P(s) = \left[\matrix{{5 e^{-3.4 s} \over s+1} & 1 \cr {-2 e^{-2.7 s} \over s+3} & {e^{-0.7 s} \over s} }\right] . $$

En este caso, los retardos son diferentes para cada par E/S, por lo que debe utilizar la propiedad IODelay:

num = {5 , 1; -2 1};
den = {[1 1] , 1; [1 3], [1 0]};
P = tf(num,den,'IODelay',[3.4  0;2.7 0.7]);

Una forma más directa y literal de especificar este modelo es introducir la variable de Laplace "s" y utilizar la aritmética de funciones de transferencia:

s = tf('s');
P = [ 5*exp(-3.4*s)/(s+1) , 1 ; -2*exp(-2.7*s)/(s+3) , exp(-0.7*s)/s ]

P =
 
  From input 1 to output...
                       5
   1:  exp(-3.4*s) * -----
                     s + 1
 
                      -2
   2:  exp(-2.7*s) * -----
                     s + 3
 
  From input 2 to output...
   1:  1
 
                     1
   2:  exp(-0.7*s) * -
                     s
 
Continuous-time transfer function.

Tenga en cuenta que, en este caso, MATLAB® decide automáticamente cómo distribuir los retardos entre las propiedades InputDelay, OutputDelay e IODelay.

P.InputDelay
P.OutputDelay
P.IODelay

ans =

     0
     0


ans =

         0
    0.7000


ans =

    3.4000         0
    2.0000         0

La función totaldelay suma los valores de retardo de la entrada, salida y E/S para devolver los valores que hemos introducido:

totaldelay(P)

ans =

    3.4000         0
    2.7000    0.7000

Modelos de espacio de estados con retardos de entrada y salida

Considere el modelo de espacio de estados:

$$ {dx \over dt} = - x(t) + u(t-2.5) , \;\; y(t) = 12 x(t) . $$

Tenga en cuenta que la señal de entrada u(t) tiene un retardo de 2,5 segundos. Para especificar este modelo, introduzca:

sys = ss(-1,1,12,0,'InputDelay',2.5)

sys =
 
  A = 
       x1
   x1  -1
 
  B = 
       u1
   x1   1
 
  C = 
       x1
   y1  12
 
  D = 
       u1
   y1   0
 
  Input delays (seconds): 2.5 
 
Continuous-time state-space model.

Un modelo relacionado es

$$ {dx_1 \over dt} = - x_1(t) + u(t) , \;\; y(t) = 12 x_1(t-2.5) . $$

En este caso, el retardo de 2,5 segundos está en la salida, como se observa al reescribir estas ecuaciones de estado como:

$$ {dx_1 \over dt} = - x_1(t) + u(t) , \;\; y_1(t) = 12 x_1(t) , \;\;
y(t) = y_1(t-2.5) . $$

Por lo tanto, puede especificar este modelo como:

sys1 = ss(-1,1,12,0,'OutputDelay',2.5);

Tenga en cuenta que ambos modelos tienen la misma respuesta de E/S como se confirma mediante

step(sys,'b',sys1,'r--')

Sin embargo, sus trayectorias de estado no son las mismas porque los estados x y x1 están relacionados mediante

$$ x(t) = x_1 (t-2.5) $$

Combinar modelos con retardos de E/S

Hasta ahora, solamente hemos considerado modelos LTI con retardos de transporte entre pares E/S específicos. Si bien esto es suficiente para modelar muchos procesos, esta clase de modelos no es lo suficientemente general para analizar la mayoría de los sistemas de control con retardos, incluidos los lazos de feedback simples con retardos. Por ejemplo, considere la conexión paralela:

$$ H(s) = H_1(s) + H_2(s) = {1 \over s+2} + {5 e^{-3.4 s} \over s+1} $$

La función de transferencia resultante

$$ H(s) = {s + 1 + (5 s + 10) e^{-3.4 s} \over (s+1)(s+2) } $$

no puede representarse como una función de transferencia ordinaria con un retardo en la entrada o la salida. Para representar $H(s)$, debemos cambiar a la representación de espacio de estados y utilizar la noción de "retardo interno". Los modelos de espacio de estados (SS) tienen la capacidad de realizar seguimiento de los retardos cuando se conectan los sistemas. La información estructural sobre la ubicación del retardo y su acoplamiento con la dinámica restante se codifica de una manera eficiente y totalmente general. Al añadir las funciones de transferencia $H_1(s)$ y $H_2(s)$ se calcula automáticamente una representación de espacio de estados de $H(s)$:

H1 = 1/(s+2);
H2 = 5*exp(-3.4*s)/(s+1);
H = H1 + H2

H =
 
  A = 
       x1  x2
   x1  -2   0
   x2   0  -1
 
  B = 
       u1
   x1   1
   x2   2
 
  C = 
        x1   x2
   y1    1  2.5
 
  D = 
       u1
   y1   0
 
  (values computed with all internal delays set to zero)

  Internal delays (seconds): 3.4 
 
Continuous-time state-space model.

Tenga en cuenta que

  • El valor de retardo de 3.4 se indica como "interno"

  • Los datos A, B, C, D corresponden a la dinámica cuando todos los retardos se establecen en cero (aproximación de Padé de orden cero)

No es posible ni aconsejable mirar la función de transferencia de modelos con retardos internos. En su lugar, utilice gráficas de tiempo y frecuencia para comparar y validar modelos:

step(H1,H2,H)
legend('H1','H2','H','Location','NorthWest'), grid


bode(H1,'b',H-H2,'r--')  % verify that H-H2 = H1
grid

Crear modelos con retardos internos

Normalmente, los modelos de espacio de estados con retardos internos no se crean especificando datos A, B, C, D junto con un conjunto de retardos internos. En su lugar, se crean dichos modelos conectando modelos LTI más simples (algunos con retardos de E/S) en serie, en paralelo o con feedback. No hay límite en el número de retardos que puede haber ni en cómo se conectan los modelos LTI.

Por ejemplo, considere el lazo de control que se muestra a continuación, donde la planta se modela como un primer orden con retraso de tiempo.

Figura 1: Lazo de feedback con retardo.

Usando la representación de espacio de estados, se puede derivar un modelo T para la respuesta en lazo cerrado desde r hasta y, y simularla mediante

P = 5*exp(-3.4*s)/(s+1);
C = 0.1 * (1 + 1/(5*s));
T = feedback(P*C,1);

step(T,100)
grid, title('Closed-loop step response')

Para interconexiones más complicadas puede asignar un nombre a las señales de entrada y salida de cada bloque y utilizar connect para encargarse automáticamente del cableado. Supongamos, por ejemplo, que desea agregar feedforward al lazo de control de la Figura 1:

Figura 2: Control por feedback y feedforward.

Puede derivar el modelo de lazo cerrado correspondiente T mediante

F = 0.3/(s+4);
P.u = 'u';  P.y = 'y';
C.u = 'e';  C.y = 'uc';
F.u = 'r';  F.y = 'uf';
Sum1 = sumblk('e = r-y');
Sum2 = sumblk('u = uf+uc');
Tff = connect(P,C,F,Sum1,Sum2,'r','y');

y comparar su respuesta con el diseño de solo feedback:

step(T,'b',Tff,'r',100)
legend('No feedforward','Feedforward')
grid, title('Closed-loop step response with and without feedforward')

Ecuaciones de espacio de estados con términos con retardo

Una clase especial de modelos LTI con retardos son ecuaciones de espacio de estados con términos con retardo. La forma general es

$$ {dx \over dt} = A x(t) + B u(t) + \sum_j ( A_j x(t-\tau_j) + B_j u(t-\tau_j) ) $$

$$ y(t) = C x(t) + D u(t) + \sum_j ( C_j x(t-\tau_j) + B_j u(t-\tau_j) ) $$

La función delayss ayuda a especificar dichos modelos. Por ejemplo, considere

$${dx \over dt} = -x(t) - x(t-1.2) + 2 u(t-0.5) , \;\; y(t) = x(t-0.5) + u(t) $$

Para crear este modelo, especifique Aj,Bj,Cj,Dj para cada retardo y utilice delayss para montar el modelo:

DelayT(1) = struct('delay',0.5,'a',0,'b',2,'c',1,'d',0);   % tau1=0.5
DelayT(2) = struct('delay',1.2,'a',-1,'b',0,'c',0,'d',0);  % tau2=1.2
sys = delayss(-1,0,0,1,DelayT)

sys =
 
  A = 
       x1
   x1  -2
 
  B = 
       u1
   x1   2
 
  C = 
       x1
   y1   1
 
  D = 
       u1
   y1   1
 
  (values computed with all internal delays set to zero)

  Internal delays (seconds): 0.5  0.5  1.2 
 
Continuous-time state-space model.

Tenga en cuenta que los valores A,B,C,D corresponden a todos los retardos establecidos en cero. No es necesario que la respuesta para estos valores sea cercana a la respuesta real con retardos:

step(sys,'b',pade(sys,0),'r')

Modelos de tiempo discreto con retardos

Los retardos de tiempo discreto se manejan de manera similar con algunas diferencias menores:

  • Los retardos de tiempo discreto siempre son múltiplos enteros del periodo de muestreo

  • Los retardos de tiempo discreto son equivalentes a los polos en z = 0, por lo que siempre es posible absorber retardos en la dinámica del modelo. Sin embargo, mantener los retardos separados es mejor para el rendimiento, especialmente para sistemas con retardos largos en comparación con el periodo de muestreo.

Para especificar el modelo de primer orden

$$ H(z) = z^{-25} { 2 \over z - 0.95 } $$

con el periodo de muestreo Ts = 0,1, utilice

H = tf(2,[1 -0.95],0.1,'inputdelay',25)
step(H)

H =
 
               2
  z^(-25) * --------
            z - 0.95
 
Sample time: 0.1 seconds
Discrete-time transfer function.

La representación equivalente en el espacio de estados es

H = ss(H)

H =
 
  A = 
         x1
   x1  0.95
 
  B = 
       u1
   x1   2
 
  C = 
       x1
   y1   1
 
  D = 
       u1
   y1   0
 
  Input delays (sampling periods): 25 
 
Sample time: 0.1 seconds
Discrete-time state-space model.

Tenga en cuenta que los retardos se mantienen separados de los polos. Después, considere el lazo de feedback a continuación en el que g es una ganancia pura.

Figura 3: Lazo de feedback en tiempo discreto.

Para calcular la respuesta en lazo cerrado para g=0.01, escriba

g = .01;
T = feedback(g*H,1)
step(T)

T =
 
  A = 
         x1
   x1  0.93
 
  B = 
       u1
   x1   2
 
  C = 
         x1
   y1  0.01
 
  D = 
       u1
   y1   0
 
  (values computed with all internal delays set to zero)

  Internal delays (sampling periods): 25 
 
Sample time: 0.1 seconds
Discrete-time state-space model.

Tenga en cuenta que T sigue siendo un modelo de primer orden con un retardo interno de 25 muestras. A modo de comparación, asigne todos los retardos a los polos en z = 0 usando absorbDelay:

T1 = absorbDelay(T);
order(T1)

ans =

    26

El modelo resultante tiene 26 estados y, por lo tanto, es menos eficiente de simular. Tenga en cuenta que las respuestas al escalón de T y T1 coinciden exactamente tal y como se espera:

step(T,'b',T1,'r--')

En general, se recomienda mantener los retardos separados excepto cuando se analiza la dinámica de lazo cerrado de modelos con retardos internos:

rlocus(H)
axis([-1 2 -1 1])

Dentro de modelos de espacio de estados con retardos internos

Los objetos de espacio de estados utilizan ecuaciones de espacio de estados generalizadas para realizar un seguimiento de los retardos internos. Conceptualmente, tales modelos constan de dos partes interconectadas:

  • Un modelo de espacio de estados ordinario H(s) con conjunto de E/S aumentado

  • Un banco de retardos internos.

Figura 4: Representación interna de modelos de espacio de estados con retardos internos.

Las ecuaciones de espacio de estados correspondientes son:

$$\matrix{ \dot{x}(t) = A x(t) + B_1 u(t) + B_2 w(t) \;\;\;\; \cr
 y(t) = C_1 x(t) + D_{11} u(t) + D_{12} w(t) \cr
 z(t) = C_2 x(t) + D_{21} u(t) + D_{22} w(t) \cr
 w_j(t) = z_j(t - \tau_j) , \;\; j = 1,...,N } \;\;\;\; \;\;\;\; $$

No es necesario preocuparse por esta representación interna para utilizar las herramientas. Sin embargo, si por alguna razón quiere extraer H o las matrices A,B1,B2,..., puede hacerlo con getDelayModel. Para el ejemplo

P = 5*exp(-3.4*s)/(s+1);
C = 0.1 * (1 + 1/(5*s));
T = feedback(P*C,1);

[H,tau] = getDelayModel(T,'lft');
size(H)

State-space model with 2 outputs, 2 inputs, and 2 states.

Tenga en cuenta que H es un modelo de dos entradas y dos salidas mientras que T es SISO. La operación inversa (combinar H y tau para crear T) la realiza setDelayModel.