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.

ss

Modelo de espacio de estados

Descripción

Use ss para crear modelos de espacio de estados de valores reales o de valores complejos, o bien para convertir modelos de sistemas dinámicos al formato de modelo de espacio de estados.

Un modelo de espacio de estados es una representación matemática de un sistema físico como un conjunto de variables de entrada, salida y estado relacionadas mediante ecuaciones diferenciales de primer orden. Las variables de estado definen los valores de las variables de salida. El objeto de modelo ss puede representar modelos de espacio de estados SISO o MIMO en tiempo continuo o tiempo discreto.

En tiempo continuo, un modelo de espacio de estados tiene el siguiente formato:

$$\begin{array}{l}\dot{x}=Ax+Bu\\ y=Cx+Du\end{array}$$

En este caso, x, u e y representan los estados, las entradas y las salidas, respectivamente, mientras que A, B, C y D son las matrices de espacio de estados. El objeto ss representa un modelo de espacio de estados en MATLAB^® que almacena A, B, C y D junto con otra información, como tiempo de muestreo, nombres de las E/S, retardos y compensaciones.

Para crear un objeto de modelo de espacio de estados, puede especificar directamente las matrices de estado, entrada y salida o convertir un modelo de otro tipo (por ejemplo, un modelo de función de transferencia tf) al formato de espacio de estados. Para más información, consulte Modelos de espacio de estados. Puede utilizar un objeto de modelo ss para:

• Realizar análisis lineales

• Representar un modelo lineal de tiempo invariante (LTI) para realizar el diseño de control

• Combinarlo con otros modelos LTI y representar un sistema más complejo

Creación

Sintaxis

sys = ss(A,B,C,D)

sys = ss(A,B,C,D,ts)

sys = ss(A,B,C,D,ltiSys)

sys = ss(D)

sys = ss(___,Name,Value)

sys = ss(ltiSys)

sys = ss(ltiSys,component)

sys = ss(ssSys,'minimal')

sys = ss(ssSys,'explicit')

Descripción

sys = ss(A,B,C,D) crea un objeto de modelo de espacio de estados de tiempo continuo con el siguiente formato:

$$\begin{array}{l}\dot{x}=Ax+Bu\\ y=Cx+Du\end{array}$$

Por ejemplo, considere una planta con Nx estados, Ny salidas y Nu entradas. Las matrices de espacio de estados son:

• A es una matriz de Nx por Nx de valores reales o complejos.

• B es una matriz de Nx por Nu de valores reales o complejos.

• C es una matriz de Ny por Nx de valores reales o complejos.

• D es una matriz de Ny por Nu de valores reales o complejos.

sys = ss(A,B,C,D,ts) crea el objeto de modelo de espacio de estados de tiempo discreto con el siguiente formato y con un tiempo de muestreo ts (en segundos):

$$\begin{array}{l}x[n+1]=Ax[n]+Bu[n]\\ y[n]=Cx[n]+Du[n]\end{array}$$

Si no desea especificar el tiempo de muestreo, establezca ts en -1.

sys = ss(A,B,C,D,ltiSys) crea un modelo de espacio de estados con propiedades tales como nombres de entradas y salidas, retardos internos y valores de tiempo de muestreo que se heredan del modelo ltisys.

sys = ss(D) crea un modelo de espacio de estados que representa la ganancia estática D. El modelo de espacio de estados de salida es equivalente a ss([],[],[],D).

sys = ss(___,Name,Value) define las propiedades del modelo de espacio de estados usando uno o más argumentos de par Name,Value para cualquiera de las combinaciones de entrada/argumento anteriores.

sys = ss(ltiSys) convierte el modelo de sistema dinámico ltiSys en un modelo de espacio de estados. Si ltiSys contiene elementos ajustables o con incertidumbre, ss utiliza los valores actuales o nominales para estos elementos, respectivamente.

sys = ss(ltiSys,component) convierte al formato de objeto ss el componente medido, el componente de ruido o ambos del component especificado de un modelo identificado lineal de tiempo invariante (LTI) ltiSys. Use esta sintaxis solo si ltiSys es un modelo (LTI) identificado, como un objeto idtf (System Identification Toolbox), idss (System Identification Toolbox), idproc (System Identification Toolbox), idpoly (System Identification Toolbox) o idgrey (System Identification Toolbox).

sys = ss(ssSys,'minimal') devuelve la realización mínima de espacio de estados sin estados no controlables o no observables. Esta realización es equivalente a minreal(ss(sys)), donde la matriz A tiene la menor dimensión posible.

La conversión a formato de espacio de estados no se define exclusivamente en el caso SISO. Tampoco se garantiza que genere una realización mínima en el caso MIMO. Para más información, consulte Recommended Working Representation.

sys = ss(ssSys,'explicit') devuelve una realización explícita de espacio de estados (E = I) del modelo de espacio de estados del sistema dinámico ssSys. ss devuelve un error si ssSys es inadecuado. Para más información sobre la realización explícita de espacio de estados, consulte Modelos de espacio de estados.

Argumentos de entrada

A — Matriz de estado

Matriz de Nx por Nx

Matriz de estado, especificada como una matriz de Nx por Nx, donde Nx es el número de estados. Esta entrada establece el valor de la propiedad A.

B — Matriz de entrada a estado

Matriz de Nx por Nu

Matriz de entrada a estado, especificada como una matriz de Nx por Nu, donde Nx es el número de estados y Nu es el número de entradas. Esta entrada establece el valor de la propiedad B.

C — Matriz de estado a salida

Matriz de Ny por Nx

Matriz de estado a salida, especificada como una matriz de Ny por Nx, donde Nx es el número de estados y Ny es el número de salidas. Esta entrada establece el valor de la propiedad C.

D — Matriz de feedthrough

Matriz de Ny por Nu

Matriz de feedthrough, especificada como una matriz de Ny por Nu, donde Ny es el número de salidas y Nu es el número de entradas. Esta entrada establece el valor de la propiedad D.

ts — Tiempo de muestreo

escalar

Tiempo de muestreo, especificado como un escalar. Para más información, consulte la propiedad Ts.

ltiSys — Sistema dinámico para convertir al formato de espacio de estados

modelo de sistema dinámico | arreglo de modelos

Sistema dinámico para convertir al formato de espacio de estados, especificado como un modelo de sistema dinámico SISO o MIMO, o bien un arreglo de modelos de sistemas dinámicos. Se pueden convertir los siguientes tipos de sistemas dinámicos:

• Modelos LTI numéricos de tiempo continuo o de tiempo discreto, como modelos tf, zpk, ss o pid.

• Modelos LTI generalizados o con incertidumbre, como modelos genss o uss (Robust Control Toolbox). El uso de modelos con incertidumbre requiere Robust Control Toolbox™.

  El modelo de espacio de estados resultante asume

  • valores actuales de los componentes ajustables para los bloques de diseño de control ajustables.

  • valores nominales del modelo para los bloques de diseño de control con incertidumbre.

• Modelos LTI identificados, como modelos idtf (System Identification Toolbox), idss (System Identification Toolbox), idproc (System Identification Toolbox), idpoly (System Identification Toolbox) y idgrey (System Identification Toolbox). Para seleccionar el componente del modelo identificado que desea convertir, especifique component. Si no especifica component, el comportamiento predeterminado de ss es convertir el componente medido del modelo identificado. El uso de modelos identificados requiere System Identification Toolbox™.

component — Componente del modelo identificado

'measured' (predeterminado) | 'noise' | 'augmented'

Componente del modelo identificado que se desea convertir, especificado con una de las siguientes opciones:

• 'measured': convierte el componente medido de sys.

• 'noise': convierte el componente de ruido de sys

• 'augmented': convierte tanto el componente medido como el componente de ruido de sys.

component solo es válido cuando sys es un modelo LTI identificado.

Para más información acerca de los modelos LTI identificados y sus componentes medidos y de ruido, consulte Identified LTI Models.

ssSys — Modelo de sistema dinámico para convertir a realización mínima o formato explícito

Objeto de modelo ss

Modelo de sistema dinámico para convertir a realización mínima o formato explícito, especificado como un objeto de modelo ss.

Argumentos de salida

sys — Modelo de sistema de salida

Objeto de modelo ss | Objeto de modelo genss | Objeto de modelo uss

Modelo de sistema de salida, en uno de los siguientes formatos:

• Un objeto de modelo de espacio de estados (ss) cuando las entradas A, B, C y D son matrices numéricas o cuando se convierte desde otro tipo de objeto de modelo.

• Un objeto de modelo de espacio de estados generalizado (genss) cuando una o varias de las matrices A, B, C y D incluyen parámetros ajustables, como parámetros realp o matrices generalizadas (genmat). Para ver un ejemplo, consulte Crear un modelo de espacio de estados con parámetros tanto fijos como ajustables.

• Un objeto de modelo de espacio de estados con incertidumbre (uss) cuando una o varias de las entradas A, B, C y D incluyen matrices con incertidumbre. El uso de modelos con incertidumbre requiere Robust Control Toolbox.

Propiedades

A — Matriz de estado

Matriz de Nx por Nx

Matriz de estado, especificada como una matriz de Nx por Nx, donde Nx es el número de estados. La matriz de estado puede representarse de muchas formas en función de la realización del modelo de espacio de estados deseada, por ejemplo:

• Forma canónica modal

• Forma canónica compañera

• Forma canónica observable

• Forma canónica controlable

Para más información, consulte Realizaciones de espacio de estados.

B — Matriz de entrada a estado

Matriz de Nx por Nu

Matriz de entrada a estado, especificada como una matriz de Nx por Nu, donde Nx es el número de estados y Nu es el número de entradas.

C — Matriz de estado a salida

Matriz de Ny por Nx

Matriz de estado a salida, especificada como una matriz de Ny por Nx, donde Nx es el número de estados y Ny es el número de salidas.

D — Matriz de feedthrough

Matriz de Ny por Nu

Matriz de feedthrough, especificada como una matriz de Ny por Nu, donde Ny es el número de salidas y Nu es el número de entradas. D también recibe el nombre de matriz de ganancia estática, que representa la relación entre la salida y la entrada en condiciones de estado estacionario.

E — Matriz para modelos de espacio de estados implícitos

[] (predeterminado) | Matriz de Nx por Nx

Matriz para modelos de espacio de estados implícitos o de descriptor, especificada como una matriz de Nx por Nx. E está vacía de forma predeterminada, lo que significa que la ecuación de estados es explícita. Para especificar una ecuación de estados implícita E dx/dt = Ax + Bu, establezca esta propiedad en una matriz cuadrada del mismo tamaño que A. Consulte dss para más información sobre cómo crear modelos de espacio de estados de descriptor.

Offsets — Compensaciones de modelo

[] (predeterminado) | estructura

Desde R2024a

Compensaciones de modelo, especificadas como una estructura con estos campos.

Campo	Descripción
u	Compensaciones de entrada, especificados como un vector de longitud igual al número de entradas.
y	Compensaciones de salida, especificados como un vector de longitud igual al número de salidas.
x	Compensaciones de estado, especificados como un vector de longitud igual al número de estados.
dx	Compensaciones de derivada de estado, especificados como un vector de longitud igual al número de estados.

Para los arreglos de modelos de espacio de estados, establezca Offsets como un arreglo de estructuras con la misma dimensión que el arreglo de modelos.

Cuando se linealiza el modelo no lineal

$$\begin{array}{cc}\dot{x}=f(x,u),& y=g(x,u)\end{array}$$

en torno a un punto de funcionamiento (x₀,u₀), el modelo resultante es un modelo de espacio de estados con compensaciones:

$$\begin{array}{c}\dot{x}=\underset{{\delta }_0}{\underbrace{f(x_0,u_0)}}+A(x-x_0)+B(u-u_0)\\ y=\underset{y_0}{\underbrace{g(x_0,u_0)}}+C(x-x_0)+D(u-u_0),\end{array}$$

donde

$$\begin{array}{cccc}A=\frac{\partial f}{\partial x}(x_0,u_0),& B=\frac{\partial f}{\partial u}(x_0,u_0),& C=\frac{\partial g}{\partial x}(x_0,u_0),& D=\frac{\partial g}{\partial u}(x_0,u_0).\end{array}$$

Para que la linealización sea una buena aproximación de los mapas no lineales, debe incluir las compensaciones δ₀, x₀, u₀ y y₀. El comando linearize (Simulink Control Design) devuelve A, B, C, D y las compensaciones cuando se usa la opción StoreOffset.

Esta propiedad ayuda a gestionar las compensaciones de linealización y a usarlos en operaciones como simulación de respuesta, interconexiones de modelos y transformaciones de modelos.

Scaled — Valor lógico que indica si el escalado está activado o desactivado

0 (predeterminado) | 1

Valor lógico que indica si el escalado está activado o desactivado, especificado como 0 o 1.

Cuando Scaled está establecido en 0 (desactivado), la mayoría de los algoritmos numéricos que actúan sobre el modelo de espacio de estados sys vuelven a escalar automáticamente el vector de estado para mejorar la precisión numérica. Puede evitar este escalado automático estableciendo Scaled en 1 (activado).

Para más información sobre el escalado, consulte prescale.

StateName — Nombres de los estados

' ' (predeterminado) | vector de caracteres | arreglo de celdas de vectores de caracteres

Nombres de los estados, especificados como una de las siguientes opciones:

• Vector de caracteres: para modelos de primer orden, por ejemplo, 'velocity'

• Arreglo de celdas de vectores de caracteres: para modelos con dos o más estados

De forma predeterminada, StateName está vacío ' ' para todos los estados.

StatePath — Ruta de estado

' ' (predeterminado) | vector de caracteres | arreglo de celdas de vectores de caracteres

Ruta de estado para facilitar la gestión de la ruta del bloque de estado en la linealización, especificada como una de las siguientes opciones:

• Vector de caracteres: para modelos de primer orden

• Arreglo de celdas de vectores de caracteres: para modelos con dos o más estados

De forma predeterminada, StatePath está vacío ' ' para todos los estados.

StateUnit — Unidades de estado

' ' (predeterminado) | vector de caracteres | arreglo de celdas de vectores de caracteres

Unidades de estado, especificadas como una de las siguientes opciones:

• Vector de caracteres: para modelos de primer orden, por ejemplo, 'm/s'

• Arreglo de celdas de vectores de caracteres: para modelos con dos o más estados

Utilice StateUnit para realizar un seguimiento de las unidades de cada estado. StateUnit no influye en el comportamiento del sistema. De forma predeterminada, StateUnit está vacío ' ' para todos los estados.

InternalDelay — Retardos internos en el modelo

vector

Retardos internos en el modelo, especificados como un vector. Los retardos internos aparecen, por ejemplo, al cerrar lazos de feedback de sistemas con retardo o al conectar sistemas con retardo en serie o en paralelo. Para más información sobre retardos internos, consulte Closing Feedback Loops with Time Delays.

En el caso de modelos de tiempo continuo, los retardos internos se expresan en la unidad de tiempo especificada por la propiedad TimeUnit del modelo. Si se trata de modelos de tiempo discreto, los retardos internos se expresan como múltiplos enteros del tiempo de muestreo Ts. Por ejemplo, InternalDelay = 3 indica un retardo de tres periodos de muestreo.

Puede modificar los valores de los retardos internos utilizando la propiedad InternalDelay. No obstante, el número de entradas de sys.InternalDelay no puede modificarse, ya que se trata de una propiedad estructural del modelo.

InputDelay — Retardo de entrada

0 (predeterminado) | escalar | Vector de Nu por 1

Retardo de entrada para cada canal de entrada, especificado como una de las siguientes opciones:

• Escalar: especifica el retardo de entrada de un sistema SISO, o bien un retardo común a todas las entradas de un sistema con varias entradas.

• Vector de Nu por 1: especifica retardos de entrada independientes para cada entrada de un sistema con varias entradas, donde Nu es el número de entradas.

Si se trata de un sistema de tiempo continuo, los retardos de entrada se deben especificar en las unidades dadas por la propiedad TimeUnit. Si se trata de un sistema de tiempo discreto, los retardos de entrada se deben especificar como múltiplos enteros del tiempo de muestreo, Ts.

Para más información, consulte Retardos de tiempo en sistemas lineales.

OutputDelay — Retardo de salida

0 (predeterminado) | escalar | Vector de Ny por 1

Retardo de salida para cada canal de salida, especificado como una de las siguientes opciones:

• Escalar: especifica el retardo de salida de un sistema SISO, o bien un retardo común a todas las salidas de un sistema con varias salidas.

• Vector de Ny por 1: especifica retardos de salida independientes para cada salida de un sistema con varias salidas, donde Ny es el número de salidas.

Si se trata de un sistema de tiempo continuo, los retardos de salida se deben especificar en las unidades de tiempo dadas por la propiedad TimeUnit. Si se trata de un sistema de tiempo discreto, los retardos de salida se deben especificar como múltiplos enteros del tiempo de muestreo, Ts.

Para más información, consulte Retardos de tiempo en sistemas lineales.

Ts — Tiempo de muestreo

0 (predeterminado) | escalar positivo | -1

Tiempo de muestreo, especificado como:

• 0 si se trata de un sistema de tiempo continuo.

• Un escalar positivo que representa el periodo de muestreo de un sistema de tiempo discreto. Ts se debe especificar en las unidades de tiempo dadas por la propiedad TimeUnit.

• -1 si se trata de un sistema de tiempo discreto con un tiempo de muestreo indefinido.

Nota

Cambiar Ts no discretiza ni remuestrea el modelo. Para la conversión entre representaciones de tiempo continuo y de tiempo discreto, use c2d y d2c. Para cambiar el tiempo de muestreo de un sistema de tiempo discreto use d2d.

TimeUnit — Unidades de la variable tiempo

'seconds' (predeterminado) | 'nanoseconds' | 'microseconds' | 'milliseconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years' | ...

Unidades de la variable tiempo, especificadas como una de las siguientes opciones:

• 'nanoseconds'

• 'microseconds'

• 'milliseconds'

• 'seconds'

• 'minutes'

• 'hours'

• 'days'

• 'weeks'

• 'months'

• 'years'

Cambiar TimeUnit no afecta a otras propiedades, pero sí cambia el comportamiento general del sistema. Use chgTimeUnit para la conversión entre distintas unidades de tiempo sin modificar el comportamiento del sistema.

InputName — Nombres de los canales de entrada

'' (predeterminado) | vector de caracteres | arreglo de celdas de vectores de caracteres

Nombres de los canales de entrada, especificados como una de las siguientes opciones:

• Un vector de caracteres, para un modelo con una sola entrada.

• Un arreglo de celdas de vectores de caracteres, para un modelo con varias entradas.

• '', para no especificar un nombre, para cualquier canal de entrada.

Como alternativa, se pueden asignar nombres a las entradas de un modelo de varias entradas mediante la expansión automática de vectores. Por ejemplo, si sys es un modelo de dos entradas, se puede introducir lo siguiente:

sys.InputName = 'controls';

En este caso, el valor se expandirá automáticamente y los nombres de las entradas serán {'controls(1)';'controls(2)'}.

Se puede usar la notación abreviada u para hacer referencia a la propiedad InputName. Por ejemplo, sys.u es equivalente a sys.InputName.

Utilice InputName para:

• Identificar los canales en la visualización y las gráficas del modelo.

• Extraer los subsistemas de un sistema MIMO.

• Especificar puntos de conexión a la hora de interconectar modelos.

InputUnit — Unidades de los canales de entrada

'' (predeterminado) | vector de caracteres | arreglo de celdas de vectores de caracteres

Unidades de los canales de entrada, especificadas como una de las siguientes opciones:

• Un vector de caracteres, para un modelo con una sola entrada.

• Un arreglo de celdas de vectores de caracteres, para un modelo con varias entradas.

• '' para no especificar una unidad, para cualquier canal de entrada.

Use InputUnit para especificar las unidades de las señales de entrada. InputUnit no afecta al comportamiento del sistema.

InputGroup — Grupos de canales de entrada

estructura

Grupos de canales de entrada, especificados como una estructura. Use InputGroup para asignar los canales de entrada de un sistema MIMO a grupos y poder referirse a cada uno de los grupos con un nombre. Los nombres de los campos de InputGroup son los nombres de los grupos y los valores de los campos son los canales de entrada de cada grupo. Por ejemplo, puede introducir lo siguiente para crear grupos de entradas llamados controls y noise que incluyan los canales de entrada 1 y 2, y los canales de entrada 3 y 5, respectivamente.

sys.InputGroup.controls = [1 2];
sys.InputGroup.noise = [3 5];

Luego, puede usar el siguiente comando para extraer el subsistema de las entradas del grupo controls a todas las salidas.

sys(:,'controls')

De forma predeterminada, InputGroup es una estructura sin campos.

OutputName — Nombres de los canales de salida

'' (predeterminado) | vector de caracteres | arreglo de celdas de vectores de caracteres

Nombres de los canales de salida, especificados como una de las siguientes opciones:

• Un vector de caracteres, para un modelo con una sola salida.

• Un arreglo de celdas de vectores de caracteres, para un modelo con varias salidas.

• '', para no especificar un nombre, para cualquier canal de salida.

Como alternativa, se pueden asignar nombres a las salidas de un modelo de varias salidas mediante la expansión automática de vectores. Por ejemplo, si sys es un modelo de dos salidas, se puede introducir lo siguiente:

sys.OutputName = 'measurements';

En este caso, el valor se expandirá automáticamente y los nombres de las salidas serán {'measurements(1)';'measurements(2)'}.

También se puede usar la notación abreviada y para hacer referencia a la propiedad OutputName. Por ejemplo, sys.y es equivalente a sys.OutputName.

Utilice OutputName para:

• Identificar los canales en la visualización y las gráficas del modelo.

• Extraer los subsistemas de un sistema MIMO.

• Especificar puntos de conexión a la hora de interconectar modelos.

OutputUnit — Unidades de los canales de salida

'' (predeterminado) | vector de caracteres | arreglo de celdas de vectores de caracteres

Unidades los canales de salida, especificadas como una de las siguientes opciones:

• Un vector de caracteres, para un modelo con una sola salida.

• Un arreglo de celdas de vectores de caracteres, para un modelo con varias salidas.

• '' para no especificar una unidad, para cualquier canal de salida.

Use OutputUnit para especificar las unidades de las señales de salida. OutputUnit no afecta al comportamiento del sistema.

OutputGroup — Grupos de canales de salida

estructura

Grupos de canales de salida, especificados como una estructura. Use OutputGroup para asignar los canales de salida de un sistema MIMO a grupos y poder referirse a cada uno de los grupos con un nombre. Los nombres de los campos de OutputGroup son los nombres de los grupos y los valores de los campos son los canales de salida de cada grupo. Por ejemplo, puede crear grupos de salidas llamados temperature y measurement que incluyan el canal de salida 1, 3 y los canales de salida 5, respectivamente.

sys.OutputGroup.temperature = [1];
sys.OutputGroup.measurement = [3 5];

Luego, puede usar el siguiente comando para extraer el subsistema de todas las entradas a las salidas del grupo measurement.

sys('measurement',:)

De forma predeterminada, OutputGroup es una estructura sin campos.

Name — Nombre del sistema

'' (predeterminado) | vector de caracteres

Nombre del sistema, especificado como un vector de caracteres. Por ejemplo, 'system_1'.

Notes — Texto especificado por el usuario

{} (predeterminado) | vector de caracteres | arreglo de celdas de vectores de caracteres

Texto especificado por el usuario que desee asociar con el sistema, especificado como un vector de caracteres, o bien un arreglo de celdas de vectores de caracteres. Por ejemplo, 'System is MIMO'.

UserData — Datos especificados por el usuario

[] (predeterminado) | cualquier tipo de dato de MATLAB

Datos especificados por el usuario que desee asociar con el sistema, especificado como cualquier tipo de dato de MATLAB.

SamplingGrid — Cuadrícula de muestreo para arreglos de modelos

arreglo de estructuras

Cuadrícula de muestreo para arreglos de modelos, especificada como un arreglo de estructuras.

Use SamplingGrid para hacer un seguimiento de los valores de las variables asociados con cada uno de los modelos de un arreglo de modelos, incluyendo arreglos de modelos identificados lineales de tiempo invariante (IDLTI).

Establezca los nombres de los campos de la estructura como nombres de las variables de muestreo. Establezca los valores de los campos como valores de las variables muestreadas asociadas con cada modelo del arreglo. Todas las variables de muestreo deben ser escalares numéricos y todos los arreglos de valores muestreados deben coincidir con las dimensiones del arreglo de modelos.

Por ejemplo, puede crear un arreglo de modelos lineales de 11 por 1, sysarr, tomando instantáneas de un sistema lineal de tiempo variante en la unidad de tiempo t = 0:10. El siguiente código almacena las muestras de tiempo junto con los modelos lineales.

 sysarr.SamplingGrid = struct('time',0:10)

Del mismo modo, puede crear un arreglo de modelos de 6 por 9, M, muestreando de forma independiente dos variables, zeta y w. El siguiente código aplica los valores de (zeta,w) a M.

[zeta,w] = ndgrid(<6 values of zeta>,<9 values of w>)
M.SamplingGrid = struct('zeta',zeta,'w',w)

Cuando se visualiza M, cada elemento del arreglo incluye los correspondientes valores zeta y w.

M

M(:,:,1,1) [zeta=0.3, w=5] =
 
        25
  --------------
  s^2 + 3 s + 25
 

M(:,:,2,1) [zeta=0.35, w=5] =
 
         25
  ----------------
  s^2 + 3.5 s + 25
 
...

En el caso de los arreglos de modelos obtenidos por linealización de un modelo de Simulink^® para distintos valores de los parámetros o distintos puntos de funcionamiento, el software rellena SamplingGrid automáticamente con los valores de las variables correspondientes a cada elemento del arreglo. Por ejemplo, los comandos de Simulink Control Design™ linearize (Simulink Control Design) y slLinearizer (Simulink Control Design) rellenan SamplingGrid automáticamente.

De forma predeterminada, SamplingGrid es una estructura sin campos.

Funciones del objeto

Las siguientes listas contienen una muestra representativa de las funciones que se pueden usar con objetos de modelo ss. En general, cualquier función que se pueda aplicar a Modelos de sistemas dinámicos se puede aplicar a un objeto del tipo ss.

Análisis lineales

step	Respuesta al escalón de un sistema dinámico
impulse	Gráfica de la respuesta al impulso del sistema dinámico; datos de la respuesta al impulso
lsim	Representar una respuesta en el tiempo simulada de un sistema dinámico para entradas arbitrarias; datos de respuesta simulada
bode	Diagrama de Bode de respuesta en frecuencia o datos de magnitud y fase
nyquist	Diagrama de Nyquist de la respuesta en frecuencia
nichols	Nichols response of dynamic system
bandwidth	Ancho de banda de respuestas en frecuencia

Análisis de estabilidad

pole	Polos del sistema dinámico
zero	Ceros y ganancia del sistema dinámico SISO
pzplot	Gráfica de polos y ceros de un modelo de sistema dinámico con opciones de personalización de gráficas adicionales
margin	Margen de ganancia, margen de fase y frecuencias de cruce

Transformación de modelos

zpk	Modelo de cero-polo-ganancia
tf	Modelo de función de transferencia
c2d	Conversión de modelos de tiempo continuo a discreto
d2c	Convertir modelos de tiempo discreto a tiempo continuo
d2d	Resample discrete-time model

Interconexión de modelos

feedback	Conexión de feedback de múltiples modelos
connect	Block diagram interconnections of dynamic systems
series	Conexión en serie de dos modelos
parallel	Conexión paralela de dos modelos

Diseño de controladores

pidtune	Algoritmo de ajuste de PID para un modelo de planta lineal
rlocus	Gráfica del lugar de las raíces del sistema dinámico
lqr	Diseño de un regulador lineal cuadrático (LQR)
lqg	Diseño lineal cuadrático gaussiano (LQG)
lqi	Control lineal cuadrático integral
kalman	Diseñar un filtro de Kalman para la estimación de estados

Ejemplos

Modelos de espacio de estados SISO

Cree el modelo de espacio de estados SISO definido por las siguientes matrices de espacio de estados:

$$A=\left[\begin{array}{cc}-1.5& -2\\ 1& 0\end{array}\right]B=\left[\begin{array}{c}0.5\\ 0\end{array}\right]C=\left[\begin{array}{cc}0& 1\end{array}\right]D=0$$

Especifique las matrices A, B, C y D y cree el modelo de espacio de estados.

A = [-1.5,-2;1,0];
B = [0.5;0];
C = [0,1];
D = 0;
sys = ss(A,B,C,D)

sys =
 
  A = 
         x1    x2
   x1  -1.5    -2
   x2     1     0
 
  B = 
        u1
   x1  0.5
   x2    0
 
  C = 
       x1  x2
   y1   0   1
 
  D = 
       u1
   y1   0
 
Continuous-time state-space model.

Crear un modelo de espacio de estados de tiempo discreto

Cree un modelo de espacio de estados con un tiempo de muestreo de 0,25 segundos y las siguientes matrices de espacio de estados:

$$A=\left[\begin{array}{cc}0& 1\\ -5& -2\end{array}\right]B=\left[\begin{array}{c}0\\ 3\end{array}\right]C=[\begin{array}{cc}0& 1\end{array}]D=[0]$$

Especifique las matrices de espacio de estados.

A = [0 1;-5 -2];
B = [0;3];
C = [0 1];
D = 0;

Especifique el tiempo de muestreo.

Ts = 0.25;

Cree el modelo de espacio de estados.

sys = ss(A,B,C,D,Ts);

Modelo de espacio de estados MIMO de tiempo continuo

Para este ejemplo, considere un cubo que gira sobre su esquina con tensor de inercia J y una fuerza de amortiguación F de 0,2 de magnitud. La entrada del sistema es el par motor, mientras que las velocidades angulares son las salidas. Las matrices de espacio de estados para el cubo son:

$$\begin{array}{l}A=-J^{-1}F,B=J^{-1},C=I,D=0,\\ where,J=\left[\begin{array}{ccc}8& -3& -3\\ -3& 8& -3\\ -3& -3& 8\end{array}\right]andF=\left[\begin{array}{ccc}0.2& 0& 0\\ 0& 0.2& 0\\ 0& 0& 0.2\end{array}\right]\end{array}$$

Especifique las matrices A, B, C y D, y cree el modelo de espacio de estados de tiempo continuo.

J = [8 -3 -3; -3 8 -3; -3 -3 8];
F = 0.2*eye(3);
A = -J\F;
B = inv(J);
C = eye(3);
D = 0;
sys = ss(A,B,C,D)

sys =
 
  A = 
             x1        x2        x3
   x1  -0.04545  -0.02727  -0.02727
   x2  -0.02727  -0.04545  -0.02727
   x3  -0.02727  -0.02727  -0.04545
 
  B = 
           u1      u2      u3
   x1  0.2273  0.1364  0.1364
   x2  0.1364  0.2273  0.1364
   x3  0.1364  0.1364  0.2273
 
  C = 
       x1  x2  x3
   y1   1   0   0
   y2   0   1   0
   y3   0   0   1
 
  D = 
       u1  u2  u3
   y1   0   0   0
   y2   0   0   0
   y3   0   0   0
 
Continuous-time state-space model.

sys es MIMO, ya que el sistema contiene tres entradas y tres salidas observadas en las matrices C y D. Para más información sobre modelos de espacio de estados MIMO, consulte MIMO State-Space Models.

Modelo de espacio de estados MIMO de tiempo discreto

Cree un modelo de espacio de estados utilizando las siguientes matrices de estado de tiempo discreto, multientrada y multisalida con tiempo de muestreo de ts = 0.2 segundos:

$$A=\left[\begin{array}{cc}-7& 0\\ 0& -10\end{array}\right]B=\left[\begin{array}{cc}5& 0\\ 0& 2\end{array}\right]C=\left[\begin{array}{cc}1& -4\\ -4& 0.5\end{array}\right]D=\left[\begin{array}{cc}0& -2\\ 2& 0\end{array}\right]$$

Especifique las matrices de espacio de estados y cree el modelo de espacio de estados MIMO de tiempo discreto.

A = [-7,0;0,-10];
B = [5,0;0,2];
C = [1,-4;-4,0.5];
D = [0,-2;2,0];
ts = 0.2;
sys = ss(A,B,C,D,ts)

sys =
 
  A = 
        x1   x2
   x1   -7    0
   x2    0  -10
 
  B = 
       u1  u2
   x1   5   0
   x2   0   2
 
  C = 
        x1   x2
   y1    1   -4
   y2   -4  0.5
 
  D = 
       u1  u2
   y1   0  -2
   y2   2   0
 
Sample time: 0.2 seconds
Discrete-time state-space model.

Especificar nombres de estados y de entradas para un modelo de espacio de estados

Cree matrices de espacio de estados y especifique el tiempo de muestreo.

A = [-0.2516 -0.1684;2.784 0.3549];
B = [0;3];
C = [0 1];
D = 0;
Ts = 0.05;

Cree el modelo de espacio de estados y especifique los nombres de estados y entradas utilizando pares nombre-valor.

sys = ss(A,B,C,D,Ts,'StateName',{'Position' 'Velocity'},...
    'InputName','Force');

El número de nombres de estados y entradas debe ser congruente con las dimensiones de A, B, C y D.

Poner nombre a las entradas y salidas puede resultar útil cuando se trate de gráficas de respuesta para sistemas MIMO.

step(sys)

Observe el nombre de entrada Force en el título de la gráfica de respuesta al escalón.

Modelo de espacio de estados con propiedades heredadas

Para este ejemplo, cree un modelo de espacio de estados con las mismas propiedades de unidad de tiempo y unidad de entrada heredadas de otro modelo de espacio de estados. Considere los siguientes modelos de espacio de estados:

$$\begin{array}{l}{A}_1=\left[\begin{array}{cc}-1.5& -2\\ 1& 0\end{array}\right]B_1=\left[\begin{array}{c}0.5\\ 0\end{array}\right]C_1=\left[\begin{array}{cc}0& 1\end{array}\right]D_1=5\\ A_2=\left[\begin{array}{cc}7& -1\\ 0& 2\end{array}\right]B_2=\left[\begin{array}{c}0.85\\ 2\end{array}\right]C_2=\left[\begin{array}{cc}10& 14\end{array}\right]D_2=2\end{array}$$

Primero, cree un modelo de espacio de estados sys1 con las propiedades TimeUnit e InputUnit establecidas en "minutes".

A1 = [-1.5,-2;1,0];
B1 = [0.5;0];
C1 = [0,1];
D1 = 5;
sys1 = ss(A1,B1,C1,D1,'TimeUnit','minutes','InputUnit','minutes');

Compruebe que las propiedades de unidad de tiempo y unidad de entrada de sys1 estén establecidas en "minutes".

propValues1 = [sys1.TimeUnit,sys1.InputUnit]

propValues1 = 1x2 cell
    {'minutes'}    {'minutes'}

Cree el segundo modelo de espacio de estados con propiedades heredadas de sys1.

A2 = [7,-1;0,2];
B2 = [0.85;2];
C2 = [10,14];
D2 = 2;
sys2 = ss(A2,B2,C2,D2,sys1);

Compruebe que las unidades de tiempo y de entrada de sys2 se hayan heredado de sys1.

propValues2 = [sys2.TimeUnit,sys2.InputUnit]

propValues2 = 1x2 cell
    {'minutes'}    {'minutes'}

Modelo de espacio de estados MIMO de ganancia estática

En este ejemplo, creará un modelo de espacio de estados MIMO de ganancia estática.

Considere la siguiente matriz de ganancia estática de dos entradas y dos salidas:

$$D=\left[\begin{array}{cc}2& 4\\ 3& 5\end{array}\right]$$

Especifique la matriz de ganancia y cree el modelo de espacio de estados de ganancia estática.

D = [2,4;3,5];
sys1 = ss(D)

sys1 =
 
  D = 
       u1  u2
   y1   2   4
   y2   3   5
 
Static gain.

Convertir una función de transferencia en un modelo de espacio de estados

Calcule el modelo de espacio de estados de la siguiente función de transferencia:

$$H\left(s\right)=\left[\begin{array}{c}\frac{s+1}{s^3+3s^2+3s+2}\\ \frac{s^2+3}{s^2+s+1}\end{array}\right]$$

Cree el modelo de función de transferencia.

H = [tf([1 1],[1 3 3 2]) ; tf([1 0 3],[1 1 1])];

Convierta este modelo en un modelo de espacio de estados.

sys = ss(H);

Examine el tamaño del modelo de espacio de estados.

size(sys)

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

El número de estados es igual al orden acumulativo de las entradas SISO en H(s).

Para obtener una realización mínima de H(s), introduzca

sys = ss(H,'minimal');
size(sys)

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

El modelo resultante tiene un orden de tres, que es el número mínimo de estados necesarios para representar H(s). Para ver este número de estados, vuelva a factorizar H(s) como el producto de multiplicar un sistema de primer orden por un sistema de segundo orden.

$$H(s)=\left[\begin{array}{cc}\frac{1}{s+2}& 0\\ 0& 1\end{array}\right]\left[\begin{array}{c}\frac{s+1}{s^2+s+1}\\ \frac{s^2+3}{s^2+s+1}\end{array}\right]$$

Extraer modelos de espacio de estados de un modelo identificado

Para este ejemplo, extraiga los componentes medidos y de ruido de un modelo polinomial identificado en dos modelos de espacio de estados independientes.

Cargue el modelo polinomial Box-Jenkins ltiSys en identifiedModel.mat.

load('identifiedModel.mat','ltiSys');

ltiSys es un modelo identificado de tiempo discreto con el formato: $$y(t)=\frac{B}{F}u(t)+\frac{C}{D}e(t)$$, donde $$\frac{B}{F}$$ representa el componente medido y $$\frac{C}{D}$$, el componente de ruido.

Extraiga los componentes medidos y de ruido como modelos de espacio de estados.

sysMeas = ss(ltiSys,'measured') 

sysMeas =
 
  A = 
            x1       x2
   x1    1.575  -0.6115
   x2        1        0
 
  B = 
        u1
   x1  0.5
   x2    0
 
  C = 
            x1       x2
   y1  -0.2851   0.3916
 
  D = 
       u1
   y1   0
 
  Input delays (sampling periods): 2 
 
Sample time: 0.04 seconds
Discrete-time state-space model.

sysNoise = ss(ltiSys,'noise')

sysNoise =
 
  A = 
           x1      x2      x3
   x1   1.026   -0.26  0.3899
   x2       1       0       0
   x3       0     0.5       0
 
  B = 
       v@y1
   x1  0.25
   x2     0
   x3     0
 
  C = 
             x1        x2        x3
   y1     0.319  -0.04738   0.07106
 
  D = 
          v@y1
   y1  0.04556
 
Input groups:        
    Name     Channels
    Noise       1    
                     
Sample time: 0.04 seconds
Discrete-time state-space model.

El componente medido puede servir como modelo de planta, mientras que el componente de ruido puede usarse como modelo de perturbaciones para el diseño de un sistema de control.

Realización explícita del modelo de espacio de estados de descriptor

Cree un modelo de espacio de estados de descriptor (E ≠ I).

a = [2 -4; 4 2];
b = [-1; 0.5];
c = [-0.5, -2];
d = [-1];
e = [1 0; -3 0.5];
sysd = dss(a,b,c,d,e);

Calcule una realización explícita del sistema (E = I).

syse = ss(sysd,'explicit')

syse =
 
  A = 
        x1   x2
   x1    2   -4
   x2   20  -20
 
  B = 
       u1
   x1  -1
   x2  -5
 
  C = 
         x1    x2
   y1  -0.5    -2
 
  D = 
       u1
   y1  -1
 
Continuous-time state-space model.

Confirme que el descriptor y las realizaciones explícitas tienen una dinámica equivalente.

bodeplot(sysd,syse,'g--')

Crear un modelo de espacio de estados con parámetros tanto fijos como ajustables

Este ejemplo muestra cómo crear un modelo de espacio de estados genss con parámetros tanto fijos como ajustables.

$$A=\left[\begin{array}{cc}1& a+b\\ 0& ab\end{array}\right],B=\left[\begin{array}{c}-3.0\\ 1.5\end{array}\right],C=\left[\begin{array}{cc}0.3& 0\end{array}\right],D=0,$$

donde a y b son parámetros ajustables cuyos valores iniciales son -1 y 3, respectivamente.

Cree los parámetros ajustables utilizando realp.

a = realp('a',-1);
b = realp('b',3);

Defina una matriz generalizada utilizando expresiones algebraicas de a y b.

A = [1 a+b;0 a*b];

A es una matriz generalizada cuya propiedad Blocks contiene a y b. El valor inicial de A es [1 2;0 -3], a partir de los valores iniciales de a y b.

Cree las matrices de espacio de estados de valor fijo.

B = [-3.0;1.5];
C = [0.3 0];
D = 0;

Utilice ss para crear el modelo de espacio de estados.

sys = ss(A,B,C,D)

Generalized continuous-time state-space model with 1 outputs, 1 inputs, 2 states, and the following blocks:
  a: Scalar parameter, 2 occurrences.
  b: Scalar parameter, 2 occurrences.

Type "ss(sys)" to see the current value and "sys.Blocks" to interact with the blocks.

sys es un modelo LTI generalizado (genss) con parámetros ajustables a y b.

Modelo de espacio de estados con retardo de entrada y de salida

Para este ejemplo, considere un modelo de espacio de estados SISO definido por las siguientes matrices de espacio de estados:

$$A=\left[\begin{array}{cc}-1.5& -2\\ 1& 0\end{array}\right]B=\left[\begin{array}{c}0.5\\ 0\end{array}\right]C=\left[\begin{array}{cc}0& 1\end{array}\right]D=0$$

Considerando un retardo de entrada de 0,5 segundos y un retardo de salida de 2,5 segundos, cree un objeto de modelo de espacio de estados para representar las matrices A, B, C y D.

A = [-1.5,-2;1,0];
B = [0.5;0];
C = [0,1];
D = 0;
sys = ss(A,B,C,D,'InputDelay',0.5,'OutputDelay',2.5)

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

También puede utilizar el comando get para mostrar todas las propiedades de un objeto de MATLAB.

get(sys)

                A: [2x2 double]
                B: [2x1 double]
                C: [0 1]
                D: 0
                E: []
          Offsets: []
           Scaled: 0
        StateName: {2x1 cell}
        StatePath: {2x1 cell}
        StateUnit: {2x1 cell}
    InternalDelay: [0x1 double]
       InputDelay: 0.5000
      OutputDelay: 2.5000
        InputName: {''}
        InputUnit: {''}
       InputGroup: [1x1 struct]
       OutputName: {''}
       OutputUnit: {''}
      OutputGroup: [1x1 struct]
            Notes: [0x1 string]
         UserData: []
             Name: ''
               Ts: 0
         TimeUnit: 'seconds'
     SamplingGrid: [1x1 struct]

Para más información sobre cómo especificar el retardo de tiempo para un modelo LTI, consulte Specifying Time Delays.

Análisis de estabilidad de sistemas de espacio de estados

Para este ejemplo, considere un System object™ de espacio de estados que represente las siguientes matrices de estado:

$$A=\left[\begin{array}{ccc}-1.2& -1.6& 0\\ 1& 0& 0\\ 0& 1& 0\end{array}\right],B=\left[\begin{array}{c}1\\ 0\\ 0\end{array}\right],C=\left[\begin{array}{ccc}0& 0.5& 1.3\end{array}\right],D=0,$$

Cree un objeto de espacio de estados sys utilizando el comando ss.

A = [-1.2,-1.6,0;1,0,0;0,1,0];
B = [1;0;0];
C = [0,0.5,1.3];
D = 0;
sys = ss(A,B,C,D);

Después, calcule el modelo de espacio de estados de lazo cerrado para una ganancia de unidad negativa y busque los polos del System object de espacio de estados de lazo cerrado sysFeedback.

sysFeedback = feedback(sys,1);
P = pole(sysFeedback)

P = 3×1 complex

  -0.2305 + 1.3062i
  -0.2305 - 1.3062i
  -0.7389 + 0.0000i

El lazo de feedback para la ganancia de unidad es estable, ya que todos los polos tienen partes reales negativas. Al comprobar los polos de lazo cerrado se obtiene una evaluación binaria de la estabilidad. En la práctica, resulta más útil saber cuán robusta (o frágil) es la estabilidad. Una indicación de robustez es cuánto puede cambiar la ganancia de lazo antes de que se pierda la estabilidad. Puede utilizar el diagrama del lugar de las raíces para estimar el rango de k valores para los que el lazo es estable.

rlocus(sys)

Los cambios en la ganancia de lazo suponen solo un aspecto de la estabilidad robusta. En general, el modelado imperfecto de plantas implica que ni la ganancia ni la fase se conocen con exactitud. Dado que los errores de modelización tienen su efecto más perjudicial cerca de la frecuencia de cruce de ganancias (frecuencia en la que la ganancia de lazo abierto es 0 dB), también es importante cuánta variación de fase puede tolerarse en esta frecuencia.

Puede mostrar los márgenes de ganancia y de fase en un diagrama de Bode de la siguiente forma.

bode(sys)
grid

Para ver un ejemplo más detallado, consulte Evaluar los márgenes de ganancia y fase.

Diseño de control utilizando modelos de espacio de estados

Para este ejemplo, diseñe un controlador PID de 2-DOF con un ancho de banda objetivo de 0,75 rad/s para un sistema representado por las siguientes matrices:

$$A=\left[\begin{array}{cc}-0.5& -0.1\\ 1& 0\end{array}\right],B=\left[\begin{array}{c}1\\ 0\end{array}\right],C=\left[\begin{array}{cc}0& 1\end{array}\right],D=0.$$

Cree un objeto de espacio de estados sys utilizando el comando ss.

A = [-0.5,-0.1;1,0];
B = [1;0];
C = [0,1];
D = 0;
sys = ss(A,B,C,D)

sys =
 
  A = 
         x1    x2
   x1  -0.5  -0.1
   x2     1     0
 
  B = 
       u1
   x1   1
   x2   0
 
  C = 
       x1  x2
   y1   0   1
 
  D = 
       u1
   y1   0
 
Continuous-time state-space model.

Utilizando el ancho de banda objetivo, use pidtune para generar un controlador de 2-DOF.

wc = 0.75;
C2 = pidtune(sys,'PID2',wc)

C2 =
 
                       1              
  u = Kp (b*r-y) + Ki --- (r-y) + Kd*s (c*r-y)
                       s              

  with Kp = 0.513, Ki = 0.0975, Kd = 0.577, b = 0.344, c = 0
 
Continuous-time 2-DOF PID controller in parallel form.

Utilizar el tipo 'PID2', pidtune genera un controlador de 2-DOF, representado como un objeto pid2. La ventana confirma este resultado. La ventana también muestra que pidtune ajusta todos los coeficientes del controlador, incluyendo las ponderaciones de valores de consigna b y c, para equilibrar el rendimiento y la robustez.

Para un ajuste interactivo del PID en Live Editor, consulte la tarea Tune PID Controller de Live Editor. Esta tarea permite diseñar un controlador PID de forma interactiva y genera automáticamente código de MATLAB para un script en vivo.

Para un ajuste interactivo del PID en una app independiente, utilice PID Tuner. Consulte PID Controller Design for Fast Reference Tracking para ver un ejemplo de cómo diseñar un controlador con la app.

Conectar entradas y salidas específicas de modelos de espacio de estados en un lazo de feedback

Considere una planta de espacio de estados G con cinco entradas y cuatro salidas, y un controlador de feedback de espacio de estados K con tres entradas y dos salidas. Las salidas 1, 3 y 4 de la planta G deben estar conectadas a las entradas del controlador K, y las salidas del controlador, a las entradas 4 y 2 de la planta.

Para este ejemplo, considere dos modelos de espacio de estados de tiempo continuo para G y K, representados por el siguiente conjunto de matrices:

$$A_G=\left[\begin{array}{ccc}-3& 0.4& 0.3\\ -0.5& -2.8& -0.8\\ 0.2& 0.8& -3\end{array}\right],B_G=\left[\begin{array}{ccccc}0.4& 0& 0.3& 0.2& 0\\ -0.2& -1& 0.1& -0.9& -0.5\\ 0.6& 0.9& 0.5& 0.2& 0\end{array}\right],C_G=\left[\begin{array}{ccc}0& -0.1& -1\\ 0& -0.2& 1.6\\ -0.7& 1.5& 1.2\\ -1.4& -0.2& 0\end{array}\right],D_G=\left[\begin{array}{ccccc}0& 0& 0& 0& -1\\ 0& 0.4& -0.7& 0& 0.9\\ 0& 0.3& 0& 0& 0\\ 0.2& 0& 0& 0& 0\end{array}\right]$$

$$A_K=\left[\begin{array}{ccc}-0.2& 2.1& 0.7\\ -2.2& -0.1& -2.2\\ -0.4& 2.3& -0.2\end{array}\right],B_K=\left[\begin{array}{ccc}-0.1& -2.1& -0.3\\ -0.1& 0& 0.6\\ 1& 0& 0.8\end{array}\right],C_K=\left[\begin{array}{ccc}-1& 0& 0\\ -0.4& -0.2& 0.3\end{array}\right],D_K=\left[\begin{array}{ccc}0& 0& 0\\ 0& 0& -1.2\end{array}\right]$$

AG = [-3,0.4,0.3;-0.5,-2.8,-0.8;0.2,0.8,-3];
BG = [0.4,0,0.3,0.2,0;-0.2,-1,0.1,-0.9,-0.5;0.6,0.9,0.5,0.2,0];
CG = [0,-0.1,-1;0,-0.2,1.6;-0.7,1.5,1.2;-1.4,-0.2,0];
DG = [0,0,0,0,-1;0,0.4,-0.7,0,0.9;0,0.3,0,0,0;0.2,0,0,0,0];
sysG = ss(AG,BG,CG,DG)

sysG =
 
  A = 
         x1    x2    x3
   x1    -3   0.4   0.3
   x2  -0.5  -2.8  -0.8
   x3   0.2   0.8    -3
 
  B = 
         u1    u2    u3    u4    u5
   x1   0.4     0   0.3   0.2     0
   x2  -0.2    -1   0.1  -0.9  -0.5
   x3   0.6   0.9   0.5   0.2     0
 
  C = 
         x1    x2    x3
   y1     0  -0.1    -1
   y2     0  -0.2   1.6
   y3  -0.7   1.5   1.2
   y4  -1.4  -0.2     0
 
  D = 
         u1    u2    u3    u4    u5
   y1     0     0     0     0    -1
   y2     0   0.4  -0.7     0   0.9
   y3     0   0.3     0     0     0
   y4   0.2     0     0     0     0
 
Continuous-time state-space model.

AK = [-0.2,2.1,0.7;-2.2,-0.1,-2.2;-0.4,2.3,-0.2];
BK = [-0.1,-2.1,-0.3;-0.1,0,0.6;1,0,0.8];
CK = [-1,0,0;-0.4,-0.2,0.3];
DK = [0,0,0;0,0,-1.2];
sysK = ss(AK,BK,CK,DK)

sysK =
 
  A = 
         x1    x2    x3
   x1  -0.2   2.1   0.7
   x2  -2.2  -0.1  -2.2
   x3  -0.4   2.3  -0.2
 
  B = 
         u1    u2    u3
   x1  -0.1  -2.1  -0.3
   x2  -0.1     0   0.6
   x3     1     0   0.8
 
  C = 
         x1    x2    x3
   y1    -1     0     0
   y2  -0.4  -0.2   0.3
 
  D = 
         u1    u2    u3
   y1     0     0     0
   y2     0     0  -1.2
 
Continuous-time state-space model.

Defina los vectores feedout y feedin en función de las entradas y salidas que se van a conectar en un lazo de feedback.

feedin = [4 2];
feedout = [1 3 4];
sys = feedback(sysG,sysK,feedin,feedout,-1)

sys =
 
  A = 
           x1      x2      x3      x4      x5      x6
   x1      -3     0.4     0.3     0.2       0       0
   x2    1.18   -2.56    -0.8    -1.3    -0.2     0.3
   x3  -1.312   0.584      -3    0.56    0.18   -0.27
   x4   2.948  -2.929   -2.42  -0.452   1.974   0.889
   x5   -0.84   -0.11     0.1    -2.2    -0.1    -2.2
   x6   -1.12   -0.26      -1    -0.4     2.3    -0.2
 
  B = 
            u1       u2       u3       u4       u5
   x1      0.4        0      0.3      0.2        0
   x2    -0.44       -1      0.1     -0.9     -0.5
   x3    0.816      0.9      0.5      0.2        0
   x4  -0.2112    -0.63        0        0      0.1
   x5     0.12        0        0        0      0.1
   x6     0.16        0        0        0       -1
 
  C = 
           x1      x2      x3      x4      x5      x6
   y1       0    -0.1      -1       0       0       0
   y2  -0.672  -0.296     1.6    0.16    0.08   -0.12
   y3  -1.204   1.428     1.2    0.12    0.06   -0.09
   y4    -1.4    -0.2       0       0       0       0
 
  D = 
          u1     u2     u3     u4     u5
   y1      0      0      0      0     -1
   y2  0.096    0.4   -0.7      0    0.9
   y3  0.072    0.3      0      0      0
   y4    0.2      0      0      0      0
 
Continuous-time state-space model.

size(sys)

State-space model with 4 outputs, 5 inputs, and 6 states.

sys es el modelo de espacio de estados de lazo cerrado resultante que se obtiene conectando las entradas y salidas especificadas de G y K.

Crear un modelo de espacio de estados con compensaciones

Desde R2024a

Este ejemplo muestra cómo linealizar un modelo de Simulink® y guardar la compensación de linealización en la propiedad Offsets del objeto de modelo ss.

Abra el modelo de Simulink.

mdl = 'watertankNLModel';
open_system(mdl)

Especifique la condición inicial para la altura del agua.

h0 = 10;

Especifique los puntos de análisis lineales del modelo.

io(1) = linio('watertankNLModel/Step',1,'input');
io(2) = linio('watertankNLModel/H',1,'output');

Simule el modelo y extraiga los puntos de funcionamiento en las instantáneas de tiempo.

tlin = [0 15 30];
op = findop(mdl,tlin);

Calcule el resultado de la linealización junto con las compensaciones.

options = linearizeOptions('StoreOffsets',true);
[linsys,~,info] = linearize(mdl,io,op,options);

La función devuelve un arreglo de modelos de espacio de estados linsys y sus compensaciones de linealización correspondientes en info.Offsets.

La propiedad Offsets del objeto de modelo ss requiere una estructura con los campos u, y, x y dx. Puede utilizar la salida info.Offsets de linearize para establecer estas compensaciones directamente.

linsys.Offsets = info.Offsets;
linsys.Offsets

ans=3×1 struct array with fields:
    dx
    x
    u
    y

Historial de versiones

Introducido antes de R2006a

R2024a: Crear modelos de espacio de estados con compensaciones

Utilice la nueva propiedad Offsets para guardar compensaciones de modelo. Las compensaciones suelen surgir al linealizar dinámicas no lineales en determinadas condiciones de funcionamiento. Esta propiedad ayuda a gestionar las compensaciones de linealización y a usarlos en operaciones como simulación de respuesta, interconexiones de modelos y transformaciones de modelos.

Consulte también

dss | frd | get | set | ssdata | tf | zpk | genss | uss (Robust Control Toolbox) | mechss | sparss | ltvss | lpvss

Temas

• Modelos de sistemas dinámicos
• What Are Model Objects?
• Modelos de espacio de estados
• MIMO State-Space Models
• Realizaciones de espacio de estados
• Recommended Working Representation
• Retardos de tiempo en sistemas lineales
• Specifying Time Delays