Accumulate output from PID controller

Question

I have come across a handful of examples of PID controllers where the process input is the accumulated PID output, i.e. the controller loop is u += pid(...) rather than u = pid(...) where u is the process input.

For the sake of example, say we are using PID to control the speed of a motor via 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

My understanding of PID is that we should use the controller as

pid = PID(kp, ki, kd)
...
motor_pwm = pid.pid(target_speed, measured_speed)

But I often see it implemented as

pid = PID(kp, ki, kd)
...
motor_pwm += pid.pid(target_speed, measured_speed)

Now, for ki = kd = 0, the latter makes some intuitive sense to me; in fact, I think it actually gives you a kind of PI controller with ki = kp, and dt = 1 enforced. Once you introduce ki != 0 or kd != 0, however, I can't square this with any of the textbook explanations of PID I have read.

Is this 'accumulated' u += pid(...) controller simply an incorrect implementation of PID?

Answer 1

It is not necessarily an incorrect implementation, if the feedback signal that your PID loop is tracking and controlling is the first derivative of the control output you need to emit. The continual accumulation of the PID output is equivalent to integration.