Un ejemplo de segundo orden de control de retroceso BackStepping se deriva con la verificación del modelo de Simulink

Conceptos básicos de retroceso

En esta sección, le recomiendo encarecidamente que saque un borrador del documento y empuje el contenido de este blog: retroceder

La idea de retroceder es como su nombre. Inversamente, descompone un sistema de alto orden en innumerables sistemas de primer orden y utiliza la función de Lyapunov para encontrar una entrada de referencia para cada sistema de primer orden, y esta entrada es la variable de estado del siguiente sistema de primer orden, el siguiente sistema de primer orden tiene el valor de referencia de su variable de estado, y luego usa la función de Lyapunov para encontrar una entrada de referencia, y esta entrada es la variable de estado del siguiente primer orden system ... y así sucesivamente, iterar hasta la entrada u (El último sistema de primer orden). Combine el siguiente sistema SISO para comprender lo que dije anteriormente: Cuando lo

toque por primera vez, puede preguntar: El sistema de ecuaciones diferenciales anterior es demasiado especial. ¿Qué pasa si la primera derivada de x1 tiene la entrada u, o la derivada de x2 tiene x4? ? La respuesta es: tome el sistema LTI como ejemplo. Si el sistema es controlable, se puede cambiar a un tipo estándar controlable. Luego está la fórmula descrita anteriormente, y muchos sistemas no lineales también se pueden transformar en la forma anterior.

También podemos analizar la fórmula anterior de esta manera: la entrada u actúa sobre xn para cambiar xn, y xn es la entrada de xn-1, luego xn-1 se cambia, y la iteración continúa y finalmente empuja a x1. El análisis del pensamiento es positivo Sí, todo lo contrario de la idea de dar un paso atrás. Esto también confirma una verdad "Resolver el problema es pensar en el futuro, y diseñar el problema (aquí está el controlador de diseño) es pensar en reversa"

Introducción a una instancia de sistema de segundo orden Backstepping (derivación manual)

Escribí esta parte en el ipad, sigue este tutorial y deberías aprender las ideas básicas.

Simulación de Simulink

Construir un modelo

Use la función S para construir este sistema no lineal, el código está detrás, lo que desea modelar:
demostración de control no lineal retrocediendo (el modelo tiene comentarios)

resultado

Constante dada $X_{1de}$

Lo anterior es $X_1$Y dado (línea azul), lo siguiente es $X_2$curva.

Seguimiento de señales sinusoidales

Lo anterior es $X_1$Y dado (línea azul), lo siguiente es $X_2$curva.

Entrada de rampa

En resumen, ¡el efecto de seguimiento es bastante bueno!

Problemas con el retroceso

Una vez que el orden es demasiado alto, causará el problema de la "explosión de complejidad" , que es un gran defecto de retroceso, ya sea el cálculo de la función de Lyapunov u otro, ¡cada paso de retroceso inevitablemente traerá más cálculos!

apéndice

Código fuente de la función S

function [sys,x0,str,ts,simStateCompliance] = mysystem(t,x,u,flag)
%   FLAG   RESULT             DESCRIPTION
%   -----  ------             --------------------------------------------
%   0      [SIZES,X0,STR,TS]  Initialization, return system sizes in SYS,
%                             initial state in X0, state ordering strings
%                             in STR, and sample times in TS.
%   1      DX                 Return continuous state derivatives in SYS.
%   2      DS                 Update discrete states SYS = X(n+1)
%   3      Y                  Return outputs in SYS.
%   4      TNEXT              Return next time hit for variable step sample
%                             time in SYS.
%   5                         Reserved for future (root finding).
%   9      []                 Termination, perform any cleanup SYS=[].
switch flag

  %%%%%%%%%%%%%%%%%%
  % Initialization %
  %%%%%%%%%%%%%%%%%%
  case 0
    [sys,x0,str,ts,simStateCompliance]=mdlInitializeSizes;
 
  %%%%%%%%%%%%%%%
  % Derivatives %
  %%%%%%%%%%%%%%%
  case 1
    sys=mdlDerivatives(t,x,u);

  %%%%%%%%%%
  % Update %
  %%%%%%%%%%
  case 2
    sys=mdlUpdate(t,x,u);

  %%%%%%%%%%%
  % Outputs %
  %%%%%%%%%%%
  case 3
    sys=mdlOutputs(t,x,u);

  %%%%%%%%%%%%%%%%%%%%%%%
  % GetTimeOfNextVarHit %
  %%%%%%%%%%%%%%%%%%%%%%%
  case 4
    sys=mdlGetTimeOfNextVarHit(t,x,u);

  %%%%%%%%%%%%%
  % Terminate %
  %%%%%%%%%%%%%
  case 9
    sys=mdlTerminate(t,x,u);

  %%%%%%%%%%%%%%%%%%%%
  % Unexpected flags %
  %%%%%%%%%%%%%%%%%%%%
  otherwise
    DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag));

end


function [sys,x0,str,ts,simStateCompliance]=mdlInitializeSizes
sizes = simsizes;
sizes.NumContStates  = 2;
sizes.NumDiscStates  = 0;
sizes.NumOutputs     = 2;
sizes.NumInputs      = 1;
sizes.DirFeedthrough = 1;         %输出如果用到了u这里一定写1！虽然我这里输出没用到输入但是建议还是写1.
sizes.NumSampleTimes = 1;   % at least one sample time is needed
sys = simsizes(sizes);
%
% initialize the initial conditions
%
x0  = zeros(2,1);
%
% str is always an empty matrix
%
str = [];
%
% initialize the array of sample times
%
ts  = [0 0];
% Specify the block simStateCompliance. The allowed values are:
%    'UnknownSimState', < The default setting; warn and assume DefaultSimState
%    'DefaultSimState', < Same sim state as a built-in block
%    'HasNoSimState',   < No sim state
%    'DisallowSimState' < Error out when saving or restoring the model sim state
simStateCompliance = 'UnknownSimState';
% end mdlInitializeSizes

%
%=============================================================================
% mdlDerivatives
% Return the derivatives for the continuous states.
%=============================================================================
%
function sys=mdlDerivatives(t,x,u)

sys = [x(1)^2-x(1)^3+x(2);u];

% end mdlDerivatives

%
%=============================================================================
% mdlUpdate
% Handle discrete state updates, sample time hits, and major time step
% requirements.
%=============================================================================
%
function sys=mdlUpdate(t,x,u)
sys = [];

% end mdlUpdate

%
%=============================================================================
% mdlOutputs
% Return the block outputs.
%=============================================================================
%
function sys=mdlOutputs(t,x,u)         %这个flag编写输出

sys = x;


% end mdlOutputs

%
%=============================================================================
% mdlGetTimeOfNextVarHit
% Return the time of the next hit for this block.  Note that the result is
% absolute time.  Note that this function is only used when you specify a
% variable discrete-time sample time [-2 0] in the sample time array in
% mdlInitializeSizes.
%=============================================================================
%
function sys=mdlGetTimeOfNextVarHit(t,x,u)

sys = [];

% end mdlGetTimeOfNextVarHit

%
%=============================================================================
% mdlTerminate
% Perform any end of simulation tasks.
%=============================================================================
%
function sys=mdlTerminate(t,x,u)

sys = [];

% end mdlTerminate