Change a setpoint on a plainly built PID controller and you often see the output leap violently for an instant before settling. That leap is called kick, and it comes from the proportional and derivative terms reacting to the sudden jump in error that a setpoint step creates. This guide isolates the kick phenomenon: what causes it, why the derivative kick in particular can be so severe, and how the simple change of computing the PID terms on the measurement rather than on the error makes the kick disappear.
Proportional / derivative kick in one line: Proportional and derivative kick are sharp, transient spikes in a controller's output that occur when the setpoint is stepped, because the proportional and especially the derivative terms react to the instantaneous jump in error. Computing those terms on the process variable instead of on the error eliminates the kick, since a setpoint step no longer produces a sudden change in what those terms see.
In a basic PID controller all three terms act on the error, which is setpoint minus process variable. When an operator steps the setpoint, the error jumps instantly by the size of that step, even though the process variable has not moved at all. The proportional term responds immediately to error, so it jumps by its gain times the step, throwing a sudden increment onto the output. This is proportional kick: a one-off jump in the output caused purely by the setpoint change, not by any real movement of the process. It stresses the valve and gives the process an initial shove larger than a gentle approach would need.
The derivative term reacts far more violently, and this is derivative kick. Derivative action responds to the rate of change of error, and a setpoint step is, mathematically, an almost instantaneous change, so its derivative is enormous. For the brief moment of the step the derivative term computes a huge value and hurls a large, sharp spike onto the output. Where proportional kick is a jump, derivative kick is a spike, often much bigger, and it is the more damaging of the two, capable of momentarily slamming a valve nearly full travel in response to nothing more than an operator typing a new number.
Both kicks share the same root cause: the controller is reacting to a change in the setpoint as though it were a change in the process, because it only sees the error and cannot tell which side moved. A disturbance and a setpoint step both change the error, but they are not the same event. A disturbance is a real process movement the controller should fight hard; a setpoint step is a deliberate change of target that the process should be walked toward, not shocked toward. Treating the setpoint step with the same instantaneous violence as a disturbance is precisely what produces the kick.
The cure follows directly from the cause. If the kick comes from the proportional and derivative terms reacting to the setpoint's sudden jump, then have those terms act on the process variable instead of on the error. The process variable does not step when the operator changes the setpoint; it only moves as the process actually responds. So a proportional or derivative term computed on the measurement sees no sudden jump at the moment of a setpoint change, and therefore produces no kick. The output changes only in response to real movement of the process, which is smooth.
Derivative on measurement is the most common and important version of this fix, and it is nearly universal in industrial controllers for exactly this reason. Because the derivative term is the source of the worst spike, computing it on the process variable rather than the error removes the large derivative kick entirely, while still giving the full benefit of derivative action against real process movements and disturbances. Many controllers extend the same idea to the proportional term, acting on the measurement to remove proportional kick as well, so that a setpoint step produces a clean output move rather than a jump.
The integral term is kept acting on the full error, and this is essential. Integral action is what drives the process to the setpoint and removes offset, so it must see the true difference between where the process is and where it is meant to be. Moving the proportional and derivative terms onto the measurement while leaving integral on the error gives a controller that still reaches setpoint accurately but no longer kicks when the setpoint changes. The setpoint step then flows into the loop through the integral term, which moves the output gradually, exactly the gentle behaviour wanted.
It is worth placing the kick fix among its relatives so it is not confused with them. Computing the proportional and derivative terms on the measurement is the same underlying idea that appears in the position-versus-velocity form discussion and in setpoint weighting, but the kick phenomenon itself is narrower than either. Setpoint weighting generalises the fix by making the weight on the setpoint an adjustable factor rather than simply on or off; derivative on measurement is the special case of that weight being zero for the derivative term. The kick is the specific problem those techniques exist to solve, and it can be understood on its own before reaching for the more general machinery.
The practical stakes are highest exactly where operators change setpoints frequently and where actuators are large or processes are sensitive. Every uncorrected setpoint step delivers a mechanical jolt to the final element and a shove to the process, so on a plant where targets are adjusted often, kick means accumulated valve wear and repeated small upsets. Eliminating it by acting on the measurement means operators can retarget loops freely without each change costing a spike, which is why the fix is regarded as standard good practice rather than an optional refinement.
In a cloud SCADA environment the presence or absence of kick is obvious on the output trend, which makes it easy to catch and confirm the fix. Step a setpoint and if you see a sharp momentary spike in the output that then settles, the controller is kicking and is almost certainly acting on error rather than measurement. After the fix, the same setpoint change shows a smooth output move with no spike. Across distributed field assets, being able to review these setpoint-change responses remotely lets an engineer identify any legacy loops still configured to kick and confirm that corrected loops behave cleanly, without having to stand at each site and watch the valve.
Both are output disturbances caused by a setpoint step, but they differ in size and shape. Proportional kick is a one-off jump in the output equal to the gain times the step. Derivative kick is a sharp spike, usually much larger, because the derivative term reacts to the near-instantaneous rate of change of a step. Derivative kick is the more damaging of the two.
Compute the derivative term on the process variable instead of on the error. Because the process variable does not jump when the setpoint changes, the derivative term sees no sudden change and produces no spike. This derivative-on-measurement configuration is standard in industrial controllers and removes the kick while preserving full derivative action against real process movements.
No. Acting on the measurement removes only the artificial reaction to the setpoint step, not the useful reaction to real process movement. Disturbance rejection is unaffected because a disturbance moves the process variable, which the terms still respond to fully. The setpoint change still reaches setpoint through the integral term, just smoothly instead of with a jolt, so you lose nothing but the damaging spike.
Merobix reads your field devices into a cloud SCADA - the real thing behind these terms, live in days from any browser.