Kp, Ki, Kd para el control PID del software

Todo el mérito de esto proviene del hilo Equilibrio de robots para maniquíes en el Foro de Arduino.

El controlador PID es el siguiente:

int
updatePID(int setPoint, int currentPoint)
{
    float error;
    static float last_error;
    static float integrated_error;

    float pTerm, iTerm, dTerm;

/*  Calculate error and proportional value.*/
    error = setPoint - currentPoint;
    pTerm = Kp * error;

/*  Calculate error and intergral value.*/
    integrated_error += error;
    iTerm = Ki * constrain(integrated_error, LOWER_LIMIT, UPPER_LIMIT);

/*  Calculate deriviative value and reset error.*/
    dTerm = Kd * (error - last_error);
    last_error = error;

/*  Return the PID controlled value.*/
    return constrain(i32K*(pTerm + iTerm + dTerm)), LOWER_LIMIT, UPPER_LIMIT);

}

Esta versión de 'software PID control' implementa el límite en el valor intergral (similar a su código) utilizando la constrain funciona desde la librería Arduino. La ventaja adicional de este código es que le permite elegir qué controlador desea cambiar al cambiar el valor de retorno. P.ej. un controlador de PD eliminaría el iTerm del valor de retorno.

En lo que respecta a la optimización, es similar a lo que dijo Inmigrante ilegal .

Set Ki, Kp, and Kd to 0.
Tune Kp until oscillation occurs.
Reduce oscillation and overshoot by tuning Kd.
Tune Ki to increase the speed of the system.

Esta es la primera vez que respondo, ¡espero que lo haya hecho correctamente y te haya ayudado un poco en el camino!

¿Qué tipo de integrador espera implementar? Al observar su código, tiene un simple acumulador, funcionará, pero existen mejores integradores que también facilitan la asignación al dominio s más fácil

fwdEuler? \ $ y (n) = y (n-1) + K \ times [t (n) -t (n-1)] \ times x (n-1) \ $

revEuler? \ $ y (n) = y (n-1) + K \ times [t (n) -t (n-1)] \ times x (n) \ $

¿Trampa? \ $ y (n) = y (n-1) + K \ veces [t (n) -t (n-1)] \ veces [x (n) + x (n-1)] / 2 \ $

Es bueno que esté considerando poner límites de suma en el PID. Le recomiendo que coloque un límite individual en el término \ $ K_i \ $ y un límite de suma global. Esto mitigará las preocupaciones de liquidación con el integrador.

$$ \ lim _ {- x \ to x} (K_p + \ lim _ {- x \ to x} K_i + K_d) $$

¿Cómo determinas el valor máximo para los límites? Depende de lo que el PID alimentará.

Digamos que es el controlador para un bucle de velocidad. La salida de la cual será una demanda actual. Si la corriente máxima que desea controlar es por ejemplo ... 100 amperios, no querría que el PID de velocidad produzca una demanda mayor que eso, tampoco querría que el \ $ K_i \ $ se acumule más alto (consulte la declaración anterior acerca de anti-windup)

¿Cómo elegir el número \ $ K_p \ $, \ $ K_i \ $, \ $ K_d \ $? Bienvenido a la teoría del control. Hay diferentes maneras. Normalmente se requiere un modelo de sistema y criterios de estabilidad.

Si puede tolerar el rebasamiento, intente leer el Método Ziegler-Nichols en wikipedia. Esto es agresivo a menudo encuentra la mejor velocidad de respuesta dentro de los límites del rendimiento de su actuador. Si necesita una amortiguación crítica (por ejemplo, máquinas herramientas) necesitará algo más. Mucho más en Métodos de optimización de bucles