PDF de programación - Arduino PID - Guía de uso de la librería

Arduino PID - Guía de

uso de la librería

Traducción del trabajo de Brett Beauregard:

http://brettbeauregard.com/blog/2011/04/improving-the-beginners-pid-introduction/

1

Licencia:

Moyano Jonathan Ezequiel [ [email protected]]

Obra liberada bajo licencia Creative Commons by-nc-sa.

Reconocimiento - NoComercial - CompartirIgual (by-nc-sa): No se permite el
uso comercial de la obra original ni de las posibles obras derivadas, la distribución
de las cuales se debe hacer con una licencia igual a la que regula la obra original.

Para más información: http://es.creativecommons.org/licencia/

2

PID para principiantes, primer acercamiento:

En esta introducción, veremos los parámetros básicos a tener en cuenta sobre el
control propocional, integral , derivativo (PID); el objetivo de este tutorial no es
introducirnos en los análisis teóricos del PID, sinó ver su aplicación en un sistema
real, utilizando un microcontrolador programado en un lenguaje de alto nivel,
como puede ser C.

La ecuación del PID:

De la documentación existente sobre sistemas de control, podemos destacar la
siguiente ecuación.

Para tener una idea más clara, recurrimos al siguiente diagrama

De la ecuación, podemos hacer las siguientes afirmaciones:

3

● e(t) es el error de la señal.
● u(t) salida del controlador y entrada de control al proceso.
● Kp es la ganancia proporcional.
● Ti es la constante de tiempo integral.
● Td es la constante de tiempo derivativa.

Del diagrama de flujo determinamos lo siguiente:

● El primer bloque de control (proporcional) consiste en el producto entre la

señal de error y la constante proporcional, quedando un error en estado
estacionario casi nulo.

● El segundo bloque de control (integral) tiene como propósito disminuir y

eliminar el error en estado estacionario, provocado por el modo
proporcional. El control integral actúa cuando hay una desviación entre la
variable y el punto de consigna, integrando esta desviación en el tiempo y
sumándola a la acción proporcional.

● El tercer bloque de control (Derivativo) considera la tendencia del error y
permite una repercusión rápida de la variable después de presentarse una
perturbación en el proceso.

Explicado lo anterior, tenemos el siguiente código:

/* Variables utilizadas en el controlador PID. */
unsigned long lastTime;
double Input, Output, Setpoint;
double errSum, lastErr;
double kp, ki, kd;

void Compute()
{
/* Cuanto tiempo pasó desde el último cálculo. */
unsigned long now = millis();
double timeChange = (double)(now - lastTime);

/* Calculamos todas las variables de error. */
double error = Setpoint - Input;
errSum += (error * timeChange);
double dErr = (error - lastErr) / timeChange;
/* Calculamos la función de salida del PID. */

4

Output = kp * error + ki * errSum + kd * dErr;

/* Guardamos el valor de algunas variables para el próximo ciclo de cálculo. */
lastErr = error;
lastTime = now;
}

/* Establecemos los valores de las constantes para la sintonización. */
void SetTunings(double Kp, double Ki, double Kd)
{
kp = Kp;
ki = Ki;
kd = Kd;
}

El programa anterior funciona correctamente, pero tiene limitaciones en cuanto a
su aplicación a un sistema real. Para que se comporte como un PID de nivel
industrial, hay que tener en cuenta otros parámetros; el algoritmo del PID funciona
mejor si se ejecuta a intervalos regulares, si se incorpora el concepto del tiempo
dentro del PID, se pueden llegar a simplificar los cálculos.

El problema:

Los PID principiantes, están diseñados para ejecutarse a periodos irregulares, esto
puede traer 2 problemas:

- Se tiene un comportamiento inconsistente del PID, debido a que en ocaciones se
lo ejecuta regularmente y a veces no.
- Hay que realizar operaciones matemáticas extras para calcular los términos
correspondientes a la parte derivada e integral del PID, ya que ambos son
dependientes del tiempo.

La solución:

Hay que asegurarse que la función que ejecuta el PID lo haga regularmente.
Basado en un tiempo de ejecución predeterminado, el PID decide si debe hacer
cálculos o retornar de la función. Una vez que nos aseguramos que el PID se
ejecuta a intervalos regulares, los cálculos correspondientes a la parte derivada e
integral se simplifican.

5

// Variables utilizadas en el controlador PID.
unsigned long lastTime;
double Input, Output, Setpoint;
double errSum, lastErr;
double kp, ki, kd;
int SampleTime = 1000; // Seteamos el tiempo de muestreo en 1 segundo.

void Compute()
{
unsigned long now = millis();
int timeChange = (now - lastTime);
// Determina si hay que ejecutar el PID o retornar de la función.
if(timeChange>=SampleTime)
{
// Calcula todas las variables de error.
double error = Setpoint - Input;
errSum += error;
double dErr = (error - lastErr);

// Calculamos la función de salida del PID.
Output = kp * error + ki * errSum + kd * dErr;

// Guardamos el valor de algunas variables para el próximo ciclo de cálculo.
lastErr = error;
lastTime = now;
}
}

/* Establecemos los valores de las constantes para la sintonización.
Debido a que ahora sabemos que el tiempo entre muestras es constante,
no hace falta multiplicar una y otra vez por el cambio de tiempo; podemos
ajustar las constantes Ki y Kd, obteniendose un resultado matemático equivalente
pero más eficiente que en la primera versión de la función. */

void SetTunings(double Kp, double Ki, double Kd)
{
double SampleTimeInSec = ((double)SampleTime)/1000;
kp = Kp;
ki = Ki * SampleTimeInSec;
kd = Kd / SampleTimeInSec;
}

void SetSampleTime(int NewSampleTime)
{
if (NewSampleTime > 0)
{

/* si el usuario decide cambiar el tiempo de muestreo durante el funcionamiento, Ki y Kd tendrán
que ajustarse para reflejar este cambio. */

double ratio = (double)NewSampleTime / (double)SampleTime;
ki *= ratio;

6

kd /= ratio;
SampleTime = (unsigned long)NewSampleTime; }}

Los resultados:

- Independientemente de cuán frecuente es llamada la función para calcular el PID,
el algoritmo de control será evaluado a tiempos regulares.
- Debido la expresión (int timeChange = (now - lastTime);) no importa cuado millis() se
hace cero nuevamente, ya que al tiempo actual, se le resta el tiempo transcurrido
con anterioridad.
- Como el tiempo de muestreo ahora es constante, no necesitamos calcular
permanentemente las constantes de sintonización. Con lo cuál nos ahorramos
cálculos cada vez que procesamos el PID.
- Tener en cuenta que es posible mejorar la gestión de los tiempos de muestreos
mediante interrupciones, pero queda a cargo del diseñador la implementación y
prueba de este concepto.

Derivative Kick

Esta modificación que presentaremos a continuación, cambiará levemente el
termino derivativo con el objetivo de eliminar el fenómeno “Derivative Kick”.
Este fenómeno, se produce por variaciones rápidas en la señal de referencia r(t),
que se magnifican por la acción derivativa y se transforman en componentes
transitorios de gran amplitud en la señal de control.

7

La imagen de arriba ilustra el problema. Siendo el error = setpoint - entrada,
cualquier cambio en la consigna, causa un cambio instantáneo en el error; la
derivada de este cambio es infinito (en la práctica, dt no es cero, igualmente, el
valor termina siendo muy grande). Esto produce un sobrepico muy alto en la
salida, que podemos corregir de una manera muy sencilla.

La solución:

Resulta que la derivada del error es igual a la derivada negativa de la entrada, salvo
cuando el setpoint está cambiando, esto acaba siendo una solución perfecta. En
lugar de añadir (Kd * error derivado), restamos (Kd * valor de entrada
derivado). Esto se conoce como el uso de "Derivada de la medición".

El código:

// Variables utilizadas en el controlador PID.

unsigned long lastTime;
double Input, Output, Setpoint;
double errSum, lastInput;
double kp, ki, kd;
int SampleTime = 1000; // Tiempo de muestreo de 1 segundo.

void Compute()
{
unsigned long now = millis();
int timeChange = (now - lastTime);
if(timeChange>=SampleTime)
{
// Calcula todas las variables de errores.
double error = Setpoint - Input;
errSum += error;
double dInput = (Input - lastInput);

8

// Calculamos la función de salida del PID.
Output = kp * error + ki * errSum - kd * dInput;

// Guardamos el valor de algunas variables para el próximo ciclo de cálculo.
lastInput = Input;
lastTime = now;
}
}

void SetTunings(double Kp, double Ki, double Kd)
{
double SampleTimeInSec = ((double)SampleTime)/1000;
kp = Kp;
ki = Ki * SampleTimeInSec;
kd = Kd / SampleTimeInSec;
}

void SetSampleTime(int NewSampleTime)
{
if (NewSampleTime > 0)
{
double ratio = (double)NewSampleTime / (double)SampleTime;
ki *= ratio;
kd /= ratio;
SampleTime = (unsigned long)NewSampleTime;
}
}

Las modificaciones son bastante sencillas, estamos reemplazando la derivada
positiva del error con la derivada negativa de la entrada. En vez de recordar el
último valor del error, ahora recordamos el último valor que tomó la entrada.

El resultado:

9

Podemos ver como los picos en la salida han sido eliminados. Este factor de
corrección se aplica a sistemas muy sensibles a dichas variaciones; en un horno por
ejemplo, donde la inercia térmica es muy grande, no le afectan en lo más mínimo
dichos picos. Por lo tanto no sería necesario tener en cuenta esta corrección.

Cambios en la sintonización

El problema:

La posibilidad de cambiar la sintonización del PID, mientras el sistema está
corriendo, es la característica más respetable del algoritmo del sistema de control.

Los PID principiantes, de hecho, actúan de manera errática si queremos setear los
valores de la sintonización, mientras el sistema está corriendo. Veamos por que.
Aquí se muetra el estado del PID antes y después de que los parámetros han
cambiado.

10

De