Main Content

pid

Controlador PID de forma paralela

    Descripción

    Use pid para crear objetos de modelo de controlador proporcional, integral y 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=Kp+Kis+KdsTfs+1

    • Tiempo discreto: C=Kp+KiIF(z)+KdTf+DF(z)

    En este caso:

    • Kp es la ganancia proporcional.

    • Ki es la ganancia integral.

    • Kd es la ganancia derivativa.

    • Tf 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 obtener 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:

    Descripción

    ejemplo

    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.

    ejemplo

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

    ejemplo

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

    ejemplo

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

    ejemplo

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

    ejemplo

    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.

    ejemplo

    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.

    ejemplo

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

    Argumentos de entrada

    expandir todo

    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 uso de modelos con incertidumbre requiere el software Robust Control Toolbox™.

      El controlador PID resultante asume que

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

      • los 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). El uso de modelos identificados requiere el software System Identification Toolbox™.

    Argumentos de salida

    expandir todo

    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 el software Robust Control Toolbox.

    Propiedades

    expandir todo

    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.

    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.

    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.

    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.

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

    C=Kp+KiIF(z)+KdTf+DF(z).

    Especifique IFormula como una de las siguientes opciones:

    • 'ForwardEuler'IF(z) = Tsz1.

      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) = Tszz1.

      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) = Ts2z+1z1.

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

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

    C=Kp+KiIF(z)+KdTf+DF(z).

    Especifique DFormula como una de las siguientes opciones:

    • 'ForwardEuler'DF(z) = Tsz1.

      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) = Tszz1.

      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) = Ts2z+1z1.

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

    Esta propiedad es de solo lectura.

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

    Esta propiedad es de solo lectura.

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

    Tiempo de muestreo, especificado como:

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

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

    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 c2dIFormulaDFormula
    'zoh'ForwardEulerForwardEuler
    'foh'TrapezoidalTrapezoidal
    'tustin'TrapezoidalTrapezoidal
    'impulse'ForwardEulerForwardEuler
    'matched'ForwardEulerForwardEuler

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

    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.

    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.

    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';

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

    De forma predeterminada, InputGroup es una estructura sin campos.

    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.

    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';

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

    De forma predeterminada, OutputGroup es una estructura sin campos.

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

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

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

    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 lineales invariantes en el tiempo identificados (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 los instantes 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 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.

    expandir todo

    stepGráfica de respuesta al escalón del sistema dinámico; datos de respuesta al escalón
    impulseGráfica de la respuesta al impulso del sistema dinámico; datos de la respuesta al impulso
    lsimRepresentar una respuesta en el tiempo simulada de un sistema dinámico para entradas arbitrarias; datos de respuesta simulada
    bodeDiagrama de Bode de respuesta en frecuencia o datos de magnitud y fase
    nyquistDiagrama de Nyquist de la respuesta en frecuencia
    nicholsNichols chart of frequency response
    bandwidthAncho de banda de respuestas en frecuencia
    polePolos del sistema dinámico
    zeroCeros y ganancia del sistema dinámico SISO
    pzplotGráfica de polos y ceros de un modelo de sistema dinámico con opciones de personalización de gráficas adicionales
    marginMargen de ganancia, margen de fase y frecuencias de cruce
    zpkModelo de cero-polo-ganancia
    ssModelo de espacio de estados
    c2dConversión de modelos de tiempo continuo a discreto
    d2cConvertir modelos de tiempo discreto a tiempo continuo
    d2dResample discrete-time model
    feedbackConexión de feedback de múltiples modelos
    connectBlock diagram interconnections of dynamic systems
    seriesConexión en serie de dos modelos
    parallelConexión paralela de dos modelos
    pidtunePID tuning algorithm for linear plant model
    rlocusGráfica del lugar de las raíces del sistema dinámico
    piddataAccess coefficients of parallel-form PID controller
    make2DOFConvert 1-DOF PID controller to 2-DOF controller
    pidTunerOpen PID Tuner for PID tuning
    tunablePIDTunable PID controller

    Ejemplos

    contraer todo

    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.

    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.

    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'}
    
    

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

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

    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.

    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.
    

    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.
    

    Historial de versiones

    Introducido en R2010b