Solución inicial

stalled_pwm_output = PWM / | ΔE |

PWM = Valor máximo de PWM
ΔE = last_error - new_error

La relación inicial aumenta con éxito la salida de PWM en función de la falta de cambio en el motor. Vea el gráfico a continuación para la salida de muestra.

Este enfoque lo hace desde entonces para la situación en la que el PID no agresivo se detuvo. Sin embargo, tiene el desafortunado (y obvio) problema de que cuando el PID no agresivo es capaz de alcanzar el punto de ajuste e intenta ralentizar, el stalled_pwm_output aumenta. Esta rampa hacia arriba provoca un gran rebasamiento cuando se viaja a una posición sin carga.

Soluciónactual

Teoría

stalled_pwm_output=(kE*PID_PWM)/|ΔE|

kE=Constantedeescalado
PID_PWM=SolicitudactualdePWMdelPIDnoagresivo
ΔE=last_error-new_error

Mirelaciónactualtodavíausaelconcepto1/ΔE,perousalasalidaPIDPWMnoagresivaparadeterminarelstall_pwm_output.EstopermitequeelPIDacelereelstall_pwm_outputcuandocomienzaaacercarsealpuntodeajusteobjetivo,peropermiteunasalidadel100%dePWMcuandoestábloqueado.LaconstantedeescalakEesnecesariaparagarantizarqueelPWMlleguealpuntodesaturación(másde10,000enlosgráficosacontinuación).

PseudoCódigo

Tengaencuentaqueelresultadodecal_stall_pwmseagregóalasalidaPIDPWMenmilógicadecontrolactual.

intcalc_stall_pwm(intpid_pwm,intnew_error){intret=0;intdE=0;staticintlast_error=0;constintkE=1;//Allowthestall_controluntilthesetpointisachivedif(FALSE==motor_has_reached_target()){//DeterminetheerrordeltadE=abs(last_error-new_error);last_error=new_error;//ProtectfromdividebyzerosdE=(dE==0)?1:dE;//Determinethestall_pwm_outputret=(kE*pid_pwm)/dE;}returnret;}

Datosdesalida

SalidadePWMbloqueada

Tenga en cuenta que en el gráfico de salida de PWM bloqueado, la caída repentina de PWM en ~ 3400 es una función de seguridad incorporada activada porque el motor no pudo alcanzar la posición dentro de un tiempo determinado.

Salida PWM no cargada

Su cálculo de error no parece acumularse cuando se trabaja con el término derivado, y es posible que desee modificarlo, ya que solo el término derivado puede reaccionar a los cambios rápidos en el proceso.

Si lo entendí bien, tu código

// Determine the error delta
dE = abs(last_error - new_error);
last_error = new_error;

siempre calculará el término de control en función del error actual, que es la forma tradicional en que se implementó el PID. Está bien, ya que se supone que el término I debe ocuparse del error acumulado de todos modos.

Sin embargo, tuve un cliente al que se le ocurrió la siguiente idea que tal vez quiera probar. Ya que tiene una parte de la curva de proceso donde se necesitan cambios más agresivos, puede dejar que incluso el error de la parte D se acumule:

if(TD)                                                 // Calculate D term
{  
   Last_C += (Error - Last_C) / TD;                    // D term simulates
   Dterm = (Error - Last_C) * KD;                      // capacitor discharging
}
else    
   Dterm = 0;                                          // D term is OFF (TD is 0)

Hay dos cosas interesantes a tener en cuenta aquí:

• El valor de TD no es la ganancia derivada (que es KD) sino la tiempo derivado, una constante de usuario que controla el tiempo de error para acumular. Si se estableció en cero, la parte D del PID está deshabilitada ignorando el valor de ganancia de KD establecido.

• Observe cómo se usó el error actual para "cargar" el valor de Last_C antes de pasarlo al cálculo de la parte D. los La variable Last_C está actuando como un condensador, se acumularía mientras El error fue grande, por lo que su parte derivada actuaría en base también en un 'historial' reciente del error, y después de eso (cuando error era más pequeño) esta 'historia' se descargará como un condensador.

Por supuesto, debes limitar la salida total de la manera que probablemente ya lo hagas (anti reinicio, autoajuste y transferencia manual, y otras cosas habituales).

Puedo publicar más detalles sobre otros términos de mi algoritmo PID si lo encuentras útil, pero es posible que desees probar esto y ver qué sucede. Sirvió bien a mi cliente durante años.

¿No dices qué es lo que estás controlando ... velocidad del motor? ¿posición? Bueno, sea lo que sea, el primer paso sería definir cuál sería un error aceptable. Por ejemplo, si el control es para la velocidad, se podría establecer un error máximo dentro del 1% del objetivo. Sin definir el error aceptable, no puede determinar cuánta resolución necesita para el conteo de ADC o PWM. Sin eso, la compensación PID podría ser perfecta, pero aún tendría oscilaciones de ciclo límite.

Entonces necesitas conocer la dinámica del sistema de bucle abierto. Sin eso, no puede saber qué ganancias se necesitan para las partes proporcionales (P), integrales (I) y derivadas (D) del bucle. Puede medir la dinámica con el paso de entrada (cambio de paso en el nivel de unidad o PWM) o cambios de paso en la carga (parece que esto sería relevante para usted).

El uso del cambio de error de ciclo a ciclo, en el denominador de su control algo, para modificar el valor de PWM garantiza que el bucle nunca se establezca. Esto asegura una oscilación del ciclo límite en el control. La mayoría de los clientes no tolerarían eso.

La parte P del bucle se encarga del error inmediato (responde a un error rápidamente). Pero tendrá una ganancia finita por lo que se dejará algún error. La parte I del bucle reacciona lentamente a lo largo del tiempo para aplicar una ganancia infinita (tiempo infinito para una ganancia infinita) para corregir el error que dejó la parte P.

Dado que la parte I es lenta, puede salir de la fase con la corrección necesaria para minimizar los errores, incluso si tiene la ganancia correcta configurada para ello. Por lo tanto, se endurece, tardando mucho tiempo en recuperarse. O bien, se deja en oposición a la parte P.

La mejor manera de manejar el enrollado es limitar el valor almacenado máximo en el integrador a solo un poco más de lo necesario para corregir el error proporcional en el peor de los casos. Si el integrador se sale de la fase y se opone al P aparte, lo mejor que puede hacer es establecer el valor del integrador en cero. El algo se puede diseñar para detectar esto y restablecer el integrador cuando sea necesario.