pid

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 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} I F (z) + \frac{K_{d}}{T_{f} + D F (z)} .$

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} I F (z) + \frac{K_{d}}{T_{f} + D F (z)} .$

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
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
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 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(:,:,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`	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 chart of frequency response
`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
`ss`	Modelo de espacio de estados
`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
`piddata`	Access coefficients of parallel-form PID controller
`make2DOF`	Convert 1-DOF PID controller to 2-DOF controller
`pidTuner`	Open PID Tuner for PID tuning
`tunablePID`	Tunable PID controller

Ejemplos

contraer todo

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.

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.

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.

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.

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 = 1x1 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.

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.

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

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.

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 (s) = \frac{3 (s + 1) (s + 2)}{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.

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

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.

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