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.

pid

Controlador PID de forma paralela

Descripción

Use pid para crear objetos de modelo de controlador proporcional, integral, derivativo (PID) de forma paralela, o bien para convertir modelos de sistemas dinámicos al formato de modelo de controlador PID paralelo.

El objeto de modelo de controlador pid puede representar controladores PID de forma paralela en tiempo continuo o tiempo discreto.

• Tiempo continuo: $$C=K_p+\frac{K_i}{s}+\frac{K_{d}s}{T_{f}s+1}$$

• Tiempo discreto: $$C=K_p+K_{i}IF\left(z\right)+\frac{K_d}{T_f+DF\left(z\right)}$$

En este caso:

• K_p es la ganancia proporcional.

• K_i es la ganancia integral.

• K_d es la ganancia derivativa.

• T_f es la constante de tiempo del filtro derivativo de primer orden.

• IF(z) es el método de integrador para el cálculo integral en un controlador de tiempo discreto.

• DF(z) es el método de integrador para el cálculo del filtro derivativo en un controlador de tiempo discreto.

Después, puede combinar este objeto con otros componentes de una arquitectura de control, tales como la planta, los actuadores y los sensores para representar un sistema de control. Para más información, consulte Modelado de sistemas de control con objetos de modelo.

Para crear un objeto de modelo de controlador PID, puede especificar directamente los parámetros del controlador o convertir un modelo de otro tipo (por ejemplo, un modelo de función de transferencia tf) al formato de controlador PID.

También puede usar pid para crear modelos generalizados de espacio de estados (genss) o modelos de espacio de estados con incertidumbre (uss (Robust Control Toolbox)).

Creación

Puede obtener modelos de controlador pid de una de las siguientes maneras.

• Cree un modelo utilizando la función pid.

• Utilice la función pidtune para ajustar controladores PID para un modelo de planta. Especifique un tipo de controlador PID 1-DOF en el argumento type de la función pidtune para obtener un controlador PID de forma paralela. Por ejemplo:

  sys = zpk([],[-1 -1 -1],1);
  C = pidtune(sys,'PID');

• Ajuste el controlador PID de manera interactiva para un modelo de planta utilizando:

  • La tarea de Live Editor Tune PID Controller.

  • La app PID Tuner.

Sintaxis

C = pid(Kp,Ki,Kd,Tf)

C = pid(Kp,Ki,Kd,Tf,Ts)

C = pid(Kp)

C = pid(Kp,Ki)

C = pid(Kp,Ki,Kd)

C = pid(___,Name,Value)

C = pid

C = pid(sys)

Descripción

C = pid(Kp,Ki,Kd,Tf) crea un modelo de controlador PID de forma paralela de tiempo continuo y establece las propiedades Kp, Ki, Kd y Tf. El resto de las propiedades tienen valores predeterminados.

C = pid(Kp,Ki,Kd,Tf,Ts) crea un modelo de controlador PID de tiempo discreto con tiempo de muestreo Ts.

C = pid(Kp) crea un controlador proporcional (P) de tiempo continuo.

C = pid(Kp,Ki) crea un controlador proporcional e integral (PI).

C = pid(Kp,Ki,Kd) crea un controlador proporcional, integral y derivativo (PID).

C = pid(___,Name,Value) establece las propiedades del objeto de controlador pid especificado usando uno o más argumentos Name,Value para cualquiera de las combinaciones de entrada-argumento anteriores.

C = pid crea un objeto de controlador con valores de propiedad predeterminados. Para modificar la propiedad del modelo de controlador, utilice notación de puntos.

C = pid(sys) convierte el modelo de sistema dinámico sys en un objeto de controlador pid de forma paralela.

Argumentos de entrada

Kp — Ganancia proporcional

1 (predeterminado) | escalar | vector | matriz | Objeto realp | Objeto genmat | Objeto tunableSurface

Ganancia proporcional, especificada como un valor real y finito o un objeto ajustable.

• Para crear un objeto de controlador pid, utilice un valor escalar real y finito.

• Para crear un arreglo de objetos de controlador pid, utilice un arreglo de valores reales y finitos.

• Para crear un modelo de controlador ajustable, utilice un parámetro ajustable (realp) o una matriz generalizada (genmat).

• Para crear un modelo de controlador con planificación de ganancia ajustable, utilice una superficie ajustable creada con tunableSurface.

Ki — Ganancia integral

0 (predeterminado) | escalar | vector | matriz | Objeto realp | Objeto genmat | Objeto tunableSurface

Ganancia integral, especificada como un valor real y finito o un objeto ajustable.

• Para crear un objeto de controlador pid, utilice un valor escalar real y finito.

• Para crear un arreglo de objetos de controlador pid, utilice un arreglo de valores reales y finitos.

• Para crear un modelo de controlador ajustable, utilice un parámetro ajustable (realp) o una matriz generalizada (genmat).

• Para crear un modelo de controlador con planificación de ganancia ajustable, utilice una superficie ajustable creada con tunableSurface.

Kd — Ganancia derivativa

0 (predeterminado) | escalar | vector | matriz | Objeto realp | Objeto genmat | Objeto tunableSurface

Ganancia derivativa, especificada como un valor real y finito o un objeto ajustable.

• Para crear un objeto de controlador pid, utilice un valor escalar real y finito.

• Para crear un arreglo de objetos de controlador pid, utilice un arreglo de valores reales y finitos.

• Para crear un modelo de controlador ajustable, utilice un parámetro ajustable (realp) o una matriz generalizada (genmat).

• Para crear un modelo de controlador con planificación de ganancia ajustable, utilice una superficie ajustable creada con tunableSurface.

Tf — Constante de tiempo de filtro derivativo

0 (predeterminado) | escalar | vector | matriz | Objeto realp | Objeto genmat | Objeto tunableSurface

Constante de tiempo del filtro derivativo de primer orden, especificada como un valor real y finito o un objeto ajustable.

• Para crear un objeto de controlador pid, utilice un valor escalar real y finito.

• Para crear un arreglo de objetos de controlador pid, utilice un arreglo de valores reales y finitos.

• Para crear un modelo de controlador ajustable, utilice un parámetro ajustable (realp) o una matriz generalizada (genmat).

• Para crear un modelo de controlador con planificación de ganancia ajustable, utilice una superficie ajustable creada con tunableSurface.

Ts — Tiempo de muestreo

0 (predeterminado) | escalar positivo

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.

En un arreglo de controladores pid, el mismo Ts se aplica a todos los controladores.

Los modelos de controlador PID no admiten tiempo de muestreo sin especificar (Ts = -1).

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.

Las fórmulas del integrador discreto del controlador discretizado dependen del método de discretización c2d utilizado, como se muestra en esta tabla.

Método de discretización c2d	IFormula	DFormula
'zoh'	ForwardEuler	ForwardEuler
'foh'	Trapezoidal	Trapezoidal
'tustin'	Trapezoidal	Trapezoidal
'impulse'	ForwardEuler	ForwardEuler
'matched'	ForwardEuler	ForwardEuler

Para más información sobre los métodos de discretización c2d, consulte c2d.

Si necesita diferentes fórmulas del integrador discreto, puede discretizar el controlador estableciendo directamente Ts, IFormula y DFormula en los valores deseados. No obstante, este método no calcula los valores de constante de filtro ni las ganancias nuevas para el controlador discretizado. Por tanto, es posible que con este método se obtenga una peor coincidencia entre los controladores PID de tiempo continuo y tiempo discreto que con c2d.

sys — Sistema dinámico

modelo de sistema dinámico | arreglo de modelos

Sistema dinámico, especificado como un modelo de sistema dinámico SISO, o un arreglo de modelos de sistemas dinámicos SISO. Se admiten los siguientes tipos de sistemas dinámicos:

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

• Modelos LTI generalizados o con incertidumbre, como modelos genss o uss (Robust Control Toolbox).

  El controlador PID resultante asume que:

  • 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).

Argumentos de salida

C — Modelo de controlador PID de forma paralela

Objeto de modelo pid | Objeto de modelo genss | Objeto de modelo uss

Modelo de controlador PID, devuelto como:

• Un objeto de modelo de controlador PID (pid) de forma paralela, cuando todas las ganancias tienen valores numéricos. Cuando las ganancias son arreglos numéricos, C es un arreglo de objetos de controlador pid.

• Un objeto de modelo de espacio de estados generalizado (genss), si los argumentos de entrada numerator o denominator incluyen parámetros ajustables, como parámetros realp o matrices generalizadas (genmat).

• Un objeto de modelo de espacio de estados con incertidumbre (uss), si los argumentos de entrada numerator o denominator incluyen parámetros con incertidumbre. El uso de modelos con incertidumbre requiere Robust Control Toolbox™.

Propiedades

Kp, Ki, Kd, Tf — Coeficientes del controlador PID

escalares

Coeficientes del controlador PID, especificados como escalares. Cuando cree un objeto o un arreglo de objetos del controlador pid, especifique estos coeficientes en los argumentos de entrada Kp, Ki, Kd y Tf.

IFormula — Método para el cálculo integral en un controlador de tiempo discreto

'ForwardEuler' (predeterminado) | 'BackwardEuler' | 'Trapezoidal'

Fórmula del integrador discreto IF(z) para el integrador del controlador de tiempo discreto pid:

$$C=K_p+K_{i}IF\left(z\right)+\frac{K_d}{T_f+DF\left(z\right)}.$$

Especifique IFormula como una de las siguientes opciones:

• 'ForwardEuler' — IF(z) = $$\frac{T_s}{z-1}.$$

  Esta fórmula es la mejor para un tiempo de muestreo reducido, donde el límite de Nyquist es grande comparado con el ancho de banda del controlador. En el caso de un tiempo de muestreo mayor, la fórmula ForwardEuler puede generar inestabilidad, incluso al discretizar un sistema que es estable en tiempo continuo.

• 'BackwardEuler' — IF(z) = $$\frac{T_{s}z}{z-1}.$$

  Una ventaja de la fórmula BackwardEuler es que, cuando se discretiza un sistema de tiempo continuo estable con esta fórmula, siempre se obtiene un resultado de tiempo discreto estable.

• 'Trapezoidal' — IF(z) = $$\frac{T_s}{2}\frac{z+1}{z-1}.$$

  Una ventaja de la fórmula Trapezoidal es que, cuando se discretiza un sistema de tiempo continuo estable con esta fórmula, siempre se obtiene un resultado de tiempo discreto estable. De todas las fórmulas de integración disponibles, la fórmula Trapezoidal es la que obtiene la coincidencia más cercana entre las propiedades del dominio de la frecuencia del sistema discretizado y el correspondiente sistema de tiempo continuo.

Cuando C es un controlador de tiempo continuo, IFormula es ''.

DFormula — Método para el cálculo derivativo en un controlador de tiempo discreto

'ForwardEuler' (predeterminado) | 'BackwardEuler' | 'Trapezoidal'

Fórmula del integrador discreto DF(z) para el filtro derivativo del controlador de tiempo discreto pid:

$$C=K_p+K_{i}IF\left(z\right)+\frac{K_d}{T_f+DF\left(z\right)}.$$

Especifique DFormula como una de las siguientes opciones:

• 'ForwardEuler' — DF(z) = $$\frac{T_s}{z-1}.$$

  Esta fórmula es la mejor para un tiempo de muestreo reducido, donde el límite de Nyquist es grande comparado con el ancho de banda del controlador. En el caso de un tiempo de muestreo mayor, la fórmula ForwardEuler puede generar inestabilidad, incluso al discretizar un sistema que es estable en tiempo continuo.

• 'BackwardEuler' — DF(z) = $$\frac{T_{s}z}{z-1}.$$

  Una ventaja de la fórmula BackwardEuler es que, cuando se discretiza un sistema de tiempo continuo estable con esta fórmula, siempre se obtiene un resultado de tiempo discreto estable.

• 'Trapezoidal' — DF(z) = $$\frac{T_s}{2}\frac{z+1}{z-1}.$$

  Una ventaja de la fórmula Trapezoidal es que, cuando se discretiza un sistema de tiempo continuo estable con esta fórmula, siempre se obtiene un resultado de tiempo discreto estable. De todas las fórmulas de integración disponibles, la fórmula Trapezoidal es la que obtiene la coincidencia más cercana entre las propiedades del dominio de la frecuencia del sistema discretizado y el correspondiente sistema de tiempo continuo.

El valor Trapezoidal para DFormula no está disponible para un controlador pid sin filtro derivativo (Tf = 0).

Cuando C es un controlador de tiempo continuo, DFormula es ''.

InputDelay — Retardo de entrada

Solo lectura: 0 (predeterminado)

Esta propiedad o parámetro es de solo lectura.

Retardo de tiempo en la entrada del sistema. InputDelay siempre es 0 para un objeto de controlador pid.

OutputDelay — Retardo de salida

Solo lectura: 0 (predeterminado)

Esta propiedad o parámetro es de solo lectura.

Retardo de tiempo en la salida del sistema. OutputDelay siempre es 0 para un objeto de controlador pid.

Ts — Tiempo de muestreo

0 (predeterminado) | escalar positivo

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 especifica en la unidad de tiempo especificada por la propiedad TimeUnit.

Si pid es un arreglo de controladores PID, el mismo Ts se aplica a todos los controladores.

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 — Nombre del canal de entrada

'' (predeterminado) | vector de caracteres

Nombre del canal de entrada, especificado como una de las siguientes opciones:

• Vector de caracteres

• '' (para no especificar un nombre)

De forma alternativa, asigne el nombre error a la entrada de un modelo de controlador C de la siguiente forma.

C.InputName = 'error';

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

Utilice InputName para:

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

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

InputUnit — Unidades de los canales de entrada

'' (predeterminado) | vector de caracteres

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

• Vector de caracteres.

• '', para no especificar una unidad.

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

Por ejemplo, asigne las unidades de concentración 'mol/m^3' a la entrada de un modelo de controlador C de la siguiente forma.

C.InputUnit = 'mol/m^3';

InputGroup — Grupos de canales de entrada

estructura

Grupos de canales de entrada. Esta propiedad no es necesaria para modelos de controlador PID.

De forma predeterminada, InputGroup es una estructura sin campos.

OutputName — Nombres de los canales de salida

'' (predeterminado) | vector de caracteres

Nombre del canal de salida, especificado como una de las siguientes opciones:

• Vector de caracteres.

• '', para no especificar un nombre.

Por ejemplo, asigne el nombre 'control' a la salida de un modelo de controlador C de la siguiente forma.

C.OutputName = 'control';

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

Utilice OutputName para:

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

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

OutputUnit — Unidades de los canales de salida

'' (predeterminado) | vector de caracteres

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

• Vector de caracteres.

• '', para no especificar una unidad.

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

Por ejemplo, asigne la unidad 'volts' a la salida de un modelo de controlador C de la siguiente forma.

C.OutputUnit = 'volts';

OutputGroup — Grupos de canales de salida

estructura

Grupos de canales de salida. Esta propiedad no es necesaria para modelos de controlador PID.

De forma predeterminada, OutputGroup es una estructura sin campos.

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.

Name — Nombre del sistema

'' (predeterminado) | vector de caracteres

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

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 invariantes en el tiempo (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 variante en el tiempo 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 mapea 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 los modelos del tipo pid. En general, cualquier función que se pueda aplicar a modelos de sistemas dinámicos se puede aplicar a un objeto del tipo pid.

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	Calcular datos de simulación de respuesta en el tiempo de un sistema dinámico para entradas arbitrarias
bode	Respuesta en frecuencia de Bode de un sistema dinámico
nyquist	Respuesta de Nyquist de un sistema dinámico
nichols	Respuesta de Nichols de un sistema dinámico
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	Representar un mapa de polos y ceros del sistema dinámico
margin	Margen de ganancia, margen de fase y frecuencias de cruce

Transformación de modelos

zpk	Modelo de cero-polo-ganancia
ss	Modelo en espacio de estados
c2d	Conversión de modelos de tiempo continuo a discreto
d2c	Convertir modelos en tiempo discreto a tiempo continuo
d2d	Remuestreo de modelos de tiempo discreto

Interconexión de modelos

feedback	Conexión de feedback de múltiples modelos
connect	Interconexiones del diagrama de bloques de sistemas dinámicos
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	Lugar de las raíces de un sistema dinámico
piddata	Access coefficients of parallel-form PID controller
make2DOF	Convert 1-DOF PID controller to 2-DOF controller
pidTuner	Abra PID Tuner para ajustar los PID
tunablePID	Tunable PID controller

Ejemplos

Controlador PID

Cree un controlador de tiempo continuo con ganancia proporcional y derivativa y un filtro en el término derivativo. Para ello, establezca la ganancia integral en cero. Establezca las otras ganancias y la constante de tiempo del filtro en los valores deseados.

Kp = 1;
Ki = 0;   % No integrator
Kd = 3;
Tf = 0.5;
C = pid(Kp,Ki,Kd,Tf)

C =
 
               s    
  Kp + Kd * --------
             Tf*s+1 

  with Kp = 1, Kd = 3, Tf = 0.5
 
Continuous-time PDF controller in parallel form.
Model Properties

La pantalla muestra el tipo de controlador, la fórmula y los valores de los parámetros, y verifica que el controlador no tenga término de integrador.

Controlador PI de tiempo discreto

Cree un controlador PI de tiempo discreto con fórmula de discretización trapezoidal.

Para crear el controlador PI de tiempo discreto, establezca el valor de Ts y la fórmula de discretización con la sintaxis Name,Value.

C1 = pid(5,2.4,'Ts',0.1,'IFormula','Trapezoidal')    % Ts = 0.1s

C1 =
 
            Ts*(z+1)
  Kp + Ki * --------
            2*(z-1) 

  with Kp = 5, Ki = 2.4, Ts = 0.1
 
Sample time: 0.1 seconds
Discrete-time PI controller in parallel form.
Model Properties

De forma alternativa, puede crear el mismo controlador de tiempo discreto proporcionando Ts como el quinto argumento de entrada tras los cuatro parámetros PID, Kp, Ki, Kd y Tf. Dado que solo desea un controlador PI, establezca Kd y Tf en cero.

C2 = pid(5,2.4,0,0,0.1,'IFormula','Trapezoidal')

C2 =
 
            Ts*(z+1)
  Kp + Ki * --------
            2*(z-1) 

  with Kp = 5, Ki = 2.4, Ts = 0.1
 
Sample time: 0.1 seconds
Discrete-time PI controller in parallel form.
Model Properties

La pantalla muestra que C1 y C2 son iguales.

Controlador PID con entrada y salida con nombre

Cuando cree un controlador PID, establezca las propiedades del sistema dinámico InputName y OutputName. Esto resulta útil, por ejemplo, cuando interconecta el controlador PID con otros modelos de sistemas dinámicos mediante el comando connect.

C = pid(1,2,3,'InputName','e','OutputName','u')

C =
 
             1          
  Kp + Ki * --- + Kd * s
             s          

  with Kp = 1, Ki = 2, Kd = 3
 
Continuous-time PID controller in parallel form.
Model Properties

La pantalla no muestra los nombres de las entradas y las salidas para el controlador PID, pero puede examinar los valores de propiedad. Por ejemplo, verifique el nombre de entrada del controlador.

C.InputName

ans = 1×1 cell array
    {'e'}

Arreglo de controladores PID

Cree una cuadrícula de controladores PI de 2 por 3 con ganancia proporcional de entre 1 y 2 en las filas del arreglo y una ganancia integral de entre 5 y 9 en las columnas.

Para crear el arreglo de controladores PID, comience con arreglos que representen las ganancias.

Kp = [1 1 1;2 2 2];
Ki = [5:2:9;5:2:9];

Cuando pasa estos arreglos al comando pid, el comando devuelve el arreglo.

pi_array = pid(Kp,Ki,'Ts',0.1,'IFormula','BackwardEuler');
size(pi_array)

2x3 array of PID controller.
Each PID has 1 output and 1 input.

De forma alternativa, utilice el comando stack para crear un arreglo de controladores PID.

C = pid(1,5,0.1)           % PID controller

C =
 
             1          
  Kp + Ki * --- + Kd * s
             s          

  with Kp = 1, Ki = 5, Kd = 0.1
 
Continuous-time PID controller in parallel form.
Model Properties

Cf = pid(1,5,0.1,0.5)      % PID controller with filter

Cf =
 
             1            s    
  Kp + Ki * --- + Kd * --------
             s          Tf*s+1 

  with Kp = 1, Ki = 5, Kd = 0.1, Tf = 0.5
 
Continuous-time PIDF controller in parallel form.
Model Properties

pid_array = stack(2,C,Cf); % stack along 2nd array dimension

Estos comandos devuelven un arreglo de controladores de 1 por 2.

size(pid_array)

1x2 array of PID controller.
Each PID has 1 output and 1 input.

Todos los controladores PID de un arreglo deben tener el mismo tiempo de muestreo, las mismas fórmulas del integrador discreto y las mismas propiedades de sistemas dinámicos que InputName y OutputName.

Convertir un controlador PID de forma estándar a forma paralela

Convertir un controlador pidstd de forma estándar a forma paralela.

La forma PID estándar expresa las acciones del controlador en cuanto a una ganancia proporcional total Kp, constantes de tiempo integrales y derivativas Ti y Td, y divisor del filtro N. Puede convertir cualquier controlador de forma estándar a forma paralela mediante el comando pid. Por ejemplo, considere el siguiente controlador de forma estándar.

Kp = 2;
Ti = 3;
Td = 4;
N = 50;
C_std = pidstd(Kp,Ti,Td,N)

C_std =
 
             1      1              s      
  Kp * (1 + ---- * --- + Td * ------------)
             Ti     s          (Td/N)*s+1 

  with Kp = 2, Ti = 3, Td = 4, N = 50
 
Continuous-time PIDF controller in standard form
Model Properties

Convierta este controlador a forma paralela utilizando pid.

C_par = pid(C_std)

C_par =
 
             1            s    
  Kp + Ki * --- + Kd * --------
             s          Tf*s+1 

  with Kp = 2, Ki = 0.667, Kd = 8, Tf = 0.08
 
Continuous-time PIDF controller in parallel form.
Model Properties

Convertir un sistema dinámico en un controlador PID de forma paralela

Convierta un sistema dinámico de tiempo continuo que representa un controlador PID a forma pid paralela.

El siguiente sistema dinámico, con un integrador y dos ceros, es equivalente a un controlador PID.

$$H\left(s\right)=\frac{3\left(s+1\right)\left(s+2\right)}{s}.$$

Cree un modelo zpk de H. Después, utilice el comando pid para obtener H en cuanto a ganancias PID Kp, Ki y Kd.

H = zpk([-1,-2],0,3);
C = pid(H)

C =
 
             1          
  Kp + Ki * --- + Kd * s
             s          

  with Kp = 9, Ki = 6, Kd = 3
 
Continuous-time PID controller in parallel form.
Model Properties

Convertir un sistema dinámico de tiempo discreto en un controlador PID de forma paralela

Convierta un sistema dinámico de tiempo discreto que representa un controlador PID con filtro derivativo a forma pid paralela.

Cree un modelo de ZPK de tiempo discreto que represente un controlador PIDF (dos ceros y dos polos, incluyendo el polo del integrador en z = 1).

sys = zpk([-0.5,-0.6],[1 -0.2],3,'Ts',0.1);

Cuando convierte sys a forma PID, el resultado depende de qué fórmulas del integrador discreto especifique para la conversión. Por ejemplo, use el valor predeterminado, ForwardEuler, tanto para el integrador como para la derivada.

Cfe = pid(sys)

Cfe =
 
              Ts               1     
  Kp + Ki * ------ + Kd * -----------
              z-1         Tf+Ts/(z-1)

  with Kp = 2.75, Ki = 60, Kd = 0.0208, Tf = 0.0833, Ts = 0.1
 
Sample time: 0.1 seconds
Discrete-time PIDF controller in parallel form.
Model Properties

Ahora realice la conversión con la fórmula Trapezoidal.

Ctrap = pid(sys,'IFormula','Trapezoidal','DFormula','Trapezoidal')

Ctrap =
 
            Ts*(z+1)                 1         
  Kp + Ki * -------- + Kd * -------------------
            2*(z-1)         Tf+Ts/2*(z+1)/(z-1)

  with Kp = -0.25, Ki = 60, Kd = 0.0208, Tf = 0.0333, Ts = 0.1
 
Sample time: 0.1 seconds
Discrete-time PIDF controller in parallel form.
Model Properties

Las visualizaciones muestran la diferencia en los valores de coeficiente resultantes y la forma funcional.

En este sistema dinámico en particular, no puede escribir sys de forma PID paralela con la fórmula BackwardEuler para el filtro derivativo. De lo contrario se obtendría Tf < 0, que no está permitido. En tal caso, pid devuelve un error.

Discretizar un controlador PID de tiempo continuo

Discretice un controlador PID de tiempo continuo y establezca fórmulas de filtro integral y derivativo.

Cree un controlador de tiempo continuo y discretícelo utilizando el método de retención de orden cero del comando c2d.

Ccon = pid(1,2,3,4);  % continuous-time PIDF controller
Cdis1 = c2d(Ccon,0.1,'zoh')

Cdis1 =
 
              Ts               1     
  Kp + Ki * ------ + Kd * -----------
              z-1         Tf+Ts/(z-1)

  with Kp = 1, Ki = 2, Kd = 3.04, Tf = 4.05, Ts = 0.1
 
Sample time: 0.1 seconds
Discrete-time PIDF controller in parallel form.
Model Properties

La pantalla muestra que c2d calcula nuevas ganancias PID para el controlador de tiempo discreto.

Las fórmulas del integrador discreto del controlador discretizado dependen del método de discretización c2d. En el método zoh, tanto IFormula como DFormula son ForwardEuler.

Cdis1.IFormula

ans = 
'ForwardEuler'

Cdis1.DFormula

ans = 
'ForwardEuler'

Si desea utilizar fórmulas diferentes a las devueltas por c2d, puede establecer directamente las propiedades Ts, IFormula y DFormula del controlador en los valores deseados.

Cdis2 = Ccon;
Cdis2.Ts = 0.1; 
Cdis2.IFormula = 'BackwardEuler';
Cdis2.DFormula = 'BackwardEuler';

No obstante, estos comandos no calculan nuevas ganancias PID para el controlador discretizado. Para verlo, examine Cdis2 y compare los coeficientes con Ccon y Cdis1.

Cdis2

Cdis2 =
 
             Ts*z               1      
  Kp + Ki * ------ + Kd * -------------
              z-1         Tf+Ts*z/(z-1)

  with Kp = 1, Ki = 2, Kd = 3, Tf = 4, Ts = 0.1
 
Sample time: 0.1 seconds
Discrete-time PIDF controller in parallel form.
Model Properties

Historial de versiones

Introducido en R2010b

Consulte también

pidstd | pid2 | piddata | make2DOF | pidtune | pidTuner | tunablePID | genss | realp

Temas

• Controladores PID (proporcional, integral, derivativo)
• Controladores proporcionales, integrales y derivativos (PID) de tiempo discreto
• What Are Model Objects?