There are two ways to write the same PID controller, and the choice shapes how it behaves at the edges. The position form computes the absolute output value each scan - a percentage from 0 to 100 that says exactly where the valve should sit. The velocity, or incremental, form computes only the change in output since the last scan - how much to nudge the valve, up or down, from wherever it already is. The math produces identical control in the middle of the range, but the two forms diverge on bumpless transfer, windup, and how naturally they drive integrating final elements. This page compares them and explains when each is preferred in DCS and PLC implementations.
Position vs Velocity PID in one line: The position (absolute) PID algorithm calculates the full controller output each scan, while the velocity (incremental) algorithm calculates only the change in output per scan and adds it to the previous value. They deliver the same control in normal operation, but the velocity form maintains the running output outside the algorithm, which makes bumpless transfer and windup handling simpler and suits stepper or up/down valve interfaces that integrate motion.
The position form is the textbook PID: output equals a proportional term, plus an integral term that sums error over time, plus a derivative term, producing an absolute output value on every execution. The controller owns and stores the accumulated integral, and it hands the process a complete number each scan. Because it computes where the output should be from scratch, the position form maps directly onto an analog signal that commands an absolute valve position through a positioner.
The velocity form rearranges the same equation into differences. Instead of the full output, it computes the increment - the change in output this scan versus last scan - typically expressed in terms of the change in error, the current error, and the change in the rate of error. That increment is then added to the previous output to get the new one. Crucially, the running total lives outside the algorithm, in the final element or in a downstream accumulator, rather than inside a controller-held integral. The controller only ever speaks in deltas.
In steady, well-behaved operation the two forms are indistinguishable: give them the same error history and they move the valve to the same place. The differences all live at transitions and limits, where the question of who holds the accumulated state - the controller or the world outside it - starts to matter. That single structural difference is the root of every practical trade-off between the two.
Bumpless transfer is where the velocity form shines. Because it outputs increments and the running total lives outside the controller, switching between manual and automatic requires no back-calculation of an internal integral. In manual, the operator moves the output; when auto takes over, the velocity algorithm simply starts adding increments to whatever value is already there. There is no stored integral to preload, so the handoff is naturally bumpless. A position-form controller, by contrast, must have its integral term forced to the value that reproduces the current output at the instant of transfer, or the output will jump.
Windup behaves differently too. In the velocity form there is no unbounded internal accumulator to run away, because the integration happens outside the algorithm. When the final element saturates - a valve fully open, a stepper at its travel limit - it simply stops accepting increments in that direction, and the algorithm's deltas have nowhere to go, so nothing winds up. The controller keeps proposing increments, the constrained element ignores the ones that would push past its limit, and the loop recovers cleanly when error reverses. Position-form controllers need explicit anti-windup logic to get the same result.
The velocity form also pairs beautifully with final elements that are themselves integrators. A stepper motor, or a motorized valve driven by raise and lower pulses, moves in response to increments and holds position on its own. Feeding it deltas is the natural language, whereas an absolute output would have to be converted back into motion commands. This is why the incremental algorithm is the traditional choice for direct digital drive of positioning elements without an analog positioner.
Neither form is universally better; the right choice follows the final element and the platform. Modern DCS PID blocks are usually position-form internally but wrap the anti-windup and bumpless-transfer machinery - including external reset feedback - around the algorithm so cleanly that the user never sees the difference. On these systems the position form's need for integral preloading is handled automatically, and the absolute output maps neatly to a 4 to 20 milliamp signal driving a valve positioner. For most analog loops, that is what runs.
The velocity form tends to appear where the final element wants deltas or where a positioner is absent: stepper-driven metering pumps, motor-operated valves and dampers commanded by raise/hold/lower pulses, and some PLC-based loops where storing the output in the element itself is convenient. In these cases the incremental algorithm removes a whole class of preloading and windup bookkeeping, because the physical device already holds the state the controller would otherwise have to track.
A subtle trade-off is worth noting: because the velocity form works entirely in changes, a corrupted or bad-quality measurement produces a bad increment that gets added to the output permanently, whereas a position-form controller recomputes from scratch each scan and can recover more gracefully once the signal returns. Good implementations of either form guard against bad input, but the failure modes differ, and that difference occasionally decides the choice on safety-relevant loops.
In normal, unsaturated operation, no - fed the same tuning and the same error history they command the same output and control identically. The differences appear at transitions and limits: bumpless transfer, windup handling, and how they drive integrating final elements. So the choice is about behavior at the edges and about matching the final control element, not about steady-state performance.
A stepper motor or a raise/hold/lower motorized valve is itself an integrator - it moves in response to increments and holds position on its own. The velocity algorithm outputs increments directly, which is exactly what those devices consume, so no conversion or external positioner is needed. The device holds the running output, which also means no controller-side integral to wind up or preload.
Most modern DCS PID function blocks are position-form internally, with anti-windup and bumpless-transfer logic built around them, so the practical drawbacks of the position form are handled for you. The velocity form is more common on PLC loops driving incremental final elements or where the output is stored in the device. In practice you often do not choose the internal form explicitly - you choose the block whose behavior fits your final element.
Merobix reads your field devices into a cloud SCADA - the real thing behind these terms, live in days from any browser.