Me he topado con un puñado de ejemplos de controladores PID donde la entrada del proceso es la salida PID acumulada , es decir, el bucle del controlador es u += pid(...) en lugar de u = pid(...) donde u es la entrada del proceso .
Por ejemplo, digamos que estamos usando PID para controlar la velocidad de un motor a través de PWM,
class PID:
def __init__(self, kp, ki, kd):
self.kp = kp
self.ki = ki
self.kd = kd
...
def pid(self, set_point, process_variable):
now = time()
dt = now - self.last_time
error = set_point - process_variable
p = self.kp * error
i = self.ki * error * dt + self.i_sum
d = self.kd * (error - self.last_error) / dt
output = p + i + d
self.i_sum = i
self.last_error = error
self.last_time = now
return output
Mi comprensión del PID es que deberíamos usar el controlador como
pid = PID(kp, ki, kd)
...
motor_pwm = pid.pid(target_speed, measured_speed)
Pero a menudo lo veo implementado como
pid = PID(kp, ki, kd)
...
motor_pwm += pid.pid(target_speed, measured_speed)
Ahora, para ki = kd = 0 , este último tiene algún sentido intuitivo para mí; de hecho, creo que en realidad te da un tipo de controlador PI con ki = kp , y dt = 1 aplicado. Sin embargo, una vez que introduzcas ki != 0 o kd != 0 , no puedo cuadrar esto con ninguna de las explicaciones de libros de texto de PID que he leído.
¿Este controlador 'acumulado' u += pid(...) simplemente es una implementación incorrecta de PID?