lqg

Diseño lineal cuadrático gaussiano (LQG)

Sintaxis

reg = lqg(sys,QXU,QWV)
reg = lqg(sys,QXU,QWV,QI)
reg = lqg(sys,QXU,QWV,QI,'1dof')
reg = lqg(sys,QXU,QWV,QI,'2dof')
reg = lqg(___,'current')
[reg,info] = lqg(___)


Descripción

reg = lqg(sys,QXU,QWV) calcula un regulador lineal cuadrático gaussiano (LQG) óptimo reg a partir de un modelo de espacio de estados sys de la planta y las matrices de ponderación QXU y QWV. El regulador dinámico reg utiliza las mediciones y para generar una señal de control u que regula y en torno al valor cero. Utilice feedback positivo para conectar este regulador con la salida de la planta y.

El regulador LQG minimiza la función de coste

$$J=E\left\{\underset{\tau \to \infty }{\lim }\frac{1}{\tau }{\displaystyle {\int }_0^{\tau }\left[x^T,u^T\right]Q_{xu}\left[\begin{array}{c}x\\ u\end{array}\right]dt}\right\}$$

en función de las ecuaciones de planta

$$\begin{array}{c}dx/dt=Ax+Bu+w\\ y=Cx+Du+v\end{array}$$

donde el ruido de proceso w y el ruido de medición v son ruidos blancos gaussianos con covarianza:

$$E\left(\left[\begin{array}{c}w\\ v\end{array}\right]\cdot \left[\begin{array}{cc}w\text{'}& v\text{'}\end{array}\right]\right)=QWV$$

reg = lqg(sys,QXU,QWV,QI) utiliza el comando de valor de consigna r y las mediciones y para generar la señal de control u. reg tiene acción integral para garantizar que y realice el seguimiento del comando r.

El servocontrolador LQG minimiza la función de coste

$$J=E\left\{\underset{\tau \to \infty }{\lim }\frac{1}{\tau }{\displaystyle {\int }_0^{\tau }\left(\left[x^T,u^T\right]Q_{xu}\left[\begin{array}{c}x\\ u\end{array}\right]+x_i^T{Q}_i{x}_i\right)}dt\right\}$$

donde x_i es la integral del error de seguimiento r - y. Para los sistemas MIMO, r, y y x_i deben tener la misma longitud.

reg = lqg(sys,QXU,QWV,QI,'1dof') calcula un servocontrolador de un grado de libertad que toma e = r - y en lugar de [r ; y] como entrada.

reg = lqg(sys,QXU,QWV,QI,'2dof') equivale a LQG(sys,QXU,QWV,QI) y produce el servocontrolador de dos grados de libertad mostrado anteriormente.

reg = lqg(___,'current') utiliza el estimador de Kalman "actual", que utiliza x[n|n] como la estimación de estado al calcular un regulador LQG para un sistema de tiempo discreto.

[reg,info] = lqg(___) devuelve las matrices de ganancia del controlador y el estimador en la estructura info para cualquiera de las sintaxis anteriores. Puede utilizar las ganancias del controlador y el estimador para, por ejemplo, implementar el controlador en forma de observador. Para más información, consulte Algoritmos.

Ejemplos

Diseños de reguladores y servocontroladores lineales cuadráticos gaussianos (LQG)

En este ejemplo se muestra cómo diseñar un regulador lineal cuadrático gaussiano (LQG), un servocontrolador LQG de un grado de libertad y un servocontrolador LQG de dos grados de libertad para el sistema siguiente.

La planta tiene tres estados (x), dos entradas de control (u), tres entradas aleatorias (w), una salida (y), ruido de medición para la salida (v) y las ecuaciones de estado y medición siguientes.

$$\begin{array}{l}\frac{dx}{dt}=Ax+Bu+w\\ y=Cx+Du+v\end{array}$$

donde

$$\begin{array}{l}A=\left[\begin{array}{ccc}0& 1& 0\\ 0& 0& 1\\ 1& 0& 0\end{array}\right]B=\left[\begin{array}{cc}0.3& 1\\ 0& 1\\ -0.3& 0.9\end{array}\right]\\ \\ C=\left[\begin{array}{ccc}1.9& 1.3& 1\end{array}\right]D=\left[\begin{array}{cc}0.53& -0.61\end{array}\right]\end{array}$$

El sistema tiene los siguientes datos de covarianza de ruido:

$$\begin{array}{l}{Q}_n=E\left(w{w}^T\right)=\left[\begin{array}{ccc}4& 2& 0\\ 2& 1& 0\\ 0& 0& 1\end{array}\right]\\ R_n=E\left(v{v}^T\right)=0.7\end{array}$$

Para el regulador, utilice la siguiente función de coste para definir el tradeoff entre rendimiento de regulación y esfuerzo de control:

$$J(u)={\displaystyle {\int }_0^{\infty }\left(0.1x^{T}x+u^T\left[\begin{array}{cc}1& 0\\ 0& 2\end{array}\right]u\right)dt}$$

Para los servocontroladores, utilice la siguiente función de coste para definir el tradeoff entre rendimiento del seguidor y esfuerzo de control:

$$J(u)={\displaystyle {\int }_0^{\infty }\left(0.1x^{T}x+x_i^2+u^T\left[\begin{array}{cc}1& 0\\ 0& 2\end{array}\right]u\right)dt}$$

Para diseñar los controladores LQG para este sistema:

1. Cree el sistema de espacio de estados escribiendo la siguiente instrucción en la ventana de comandos de MATLAB:

   A = [0 1 0;0 0 1;1 0 0];    
   B = [0.3 1;0 1;-0.3 0.9];
   C = [1.9 1.3 1];  
   D = [0.53 -0.61];
   sys = ss(A,B,C,D);

2. Defina los datos de covarianza de ruido y las matrices de ponderación escribiendo los comandos siguientes:

   nx = 3;    %Number of states
   ny = 1;    %Number of outputs
   Qn = [4 2 0; 2 1 0; 0 0 1];
   Rn = 0.7;
   R = [1 0;0 2]
   QXU = blkdiag(0.1*eye(nx),R);
   QWV = blkdiag(Qn,Rn);
   QI = eye(ny);

3. Forme el regulador LQG escribiendo el comando siguiente:

   KLQG = lqg(sys,QXU,QWV)

   Este comando devuelve el siguiente regulador LQG:

   A = 
              x1_e    x2_e    x3_e
      x1_e  -6.212  -3.814  -4.136
      x2_e  -4.038  -3.196  -1.791
      x3_e  -1.418  -1.973  -1.766
    
   B = 
                y1
      x1_e   2.365
      x2_e   1.432
      x3_e  0.7684
    
   C = 
               x1_e       x2_e       x3_e
      u1   -0.02904  0.0008272     0.0303
      u2    -0.7147    -0.7115    -0.7132
    
   D = 
          y1
      u1   0
      u2   0
    
   Input groups:              
          Name        Channels
       Measurement       1    
                              
   Output groups:             
         Name      Channels   
       Controls      1,2      
                              
   Continuous-time model.

4. Forme el servocontrolador LQG de un grado de libertad escribiendo el comando siguiente:

   KLQG1 = lqg(sys,QXU,QWV,QI,'1dof')

   Este comando devuelve el siguiente servocontrolador LQG:

   A = 
              x1_e    x2_e    x3_e     xi1
      x1_e  -7.626  -5.068  -4.891  0.9018
      x2_e  -5.108  -4.146  -2.362  0.6762
      x3_e  -2.121  -2.604  -2.141  0.4088
      xi1        0       0       0       0
    
   B = 
                 e1
      x1_e   -2.365
      x2_e   -1.432
      x3_e  -0.7684
      xi1         1
    
   C = 
             x1_e     x2_e     x3_e      xi1
      u1  -0.5388  -0.4173  -0.2481   0.5578
      u2   -1.492   -1.388   -1.131   0.5869
    
   D = 
          e1
      u1   0
      u2   0
    
   Input groups:           
       Name     Channels   
       Error       1       
                           
   Output groups:          
         Name      Channels
       Controls      1,2   
                           
   Continuous-time model.

5. Forme el servocontrolador LQG de dos grados de libertad escribiendo el comando siguiente:

   KLQG2 = lqg(sys,QXU,QWV,QI,'2dof')

   Este comando devuelve el siguiente servocontrolador LQG:

   A = 
              x1_e    x2_e    x3_e     xi1
      x1_e  -7.626  -5.068  -4.891  0.9018
      x2_e  -5.108  -4.146  -2.362  0.6762
      x3_e  -2.121  -2.604  -2.141  0.4088
      xi1        0       0       0       0
    
   B = 
                r1      y1
      x1_e       0   2.365
      x2_e       0   1.432
      x3_e       0  0.7684
      xi1        1      -1
    
   C = 
             x1_e     x2_e     x3_e      xi1
      u1  -0.5388  -0.4173  -0.2481   0.5578
      u2   -1.492   -1.388   -1.131   0.5869
    
   D = 
          r1  y1
      u1   0   0
      u2   0   0
    
   Input groups:              
          Name        Channels
        Setpoint         1    
       Measurement       2    
                              
   Output groups:             
         Name      Channels   
       Controls      1,2      
                              
   Continuous-time model.

Sugerencias

• lqg se puede utilizar tanto para plantas de tiempo continuo como discreto. En tiempo discreto, lqg utiliza x[n|n-1] como su estimación de estado de forma predeterminada. Para utilizar x[n|n] como la estimación de estado y calcular el controlador LQG óptimo, use el argumento de entrada 'current'. Para más información acerca de los estimadores de estado, consulte kalman.

• Para calcular el regulador LQG, lqg utiliza los comandos lqr y kalman. Para calcular el servocontrolador, lqg utiliza los comandos lqi y kalman.

• Cuando desee tener más flexibilidad para diseñar reguladores, puede utilizar los comandos lqr, kalman y lqgreg. Cuando desee tener más flexibilidad para diseñar servocontroladores, puede utilizar los comandos lqi, kalman y lqgtrack. Para más información sobre cómo usar estos comandos y cómo decidir cuándo usarlos, consulte Linear-Quadratic-Gaussian (LQG) Design for Regulation y Linear-Quadratic-Gaussian (LQG) Design of Servo Controller with Integral Action.

Algoritmos

Las ecuaciones de controlador son:

• Para tiempo continuo:

  $$\begin{array}{c}d{x}_e=A{x}_e+Bu+L\left(y-C{x}_e-Du\right)\\ u=-K_x{x}_e-K_i{x}_i\end{array}$$

• Para tiempo discreto:

  $$x\left[n+1|n\right]=Ax\left[n|n-1\right]+Bu\left[n\right]+L\left(y\left[n\right]-Cx\left[n|n-1\right]-Du\left[n\right]\right)$$

  • Estimador con retardo:

    $$u\left[n\right]=-K_{x}x\left[n|n-1\right]-K_i{x}_i\left[n\right]$$

  • Estimador actual:

    $$\begin{array}{c}u\left[n\right]=-K_{x}x\left[n|n\right]-K_i{x}_i\left[n\right]-K_{w}w\left[n|n\right]\\ =-K_{x}x\left[n|n-1\right]-K_i{x}_i\left[n\right]-\left(K_x{M}_x+K_w{M}_w\right)y_{inn}\left[n\right]\end{array}$$

    $$y_{inn}\left[n\right]=y\left[n\right]-Cx\left[n|n-1\right]-Du\left[n\right]$$

En este caso,

• A, B, C y D son las matrices de espacio de estados del regulador LQG, reg.

• x_i es la integral del error de seguimiento r - y.

• K_x, K_w, K_i, L, M_x y M_w son las matrices de ganancia del controlador y el estimador devueltas en info.

Historial de versiones

Introducido antes de R2006a

Consulte también

lqr | lqi | kalman | lqry | ss | care | dare