Positional and incremental (velocity) algorithms
Two ways to compute a PID output in a PLC: the full output value every sample or its increment. Equations, how they differ under saturation and mode switching, where an incremental output is needed (pulse-driven actuators).
In short. The positional algorithm computes the whole output u[k] every sample and stores the integral. The incremental one computes only the increment Δu[k] and adds it to the previous output. With the same settings and no limits they give the same output. The difference is in saturation, mode switching and actuators that need a "more/less" signal.
Equations
Parallel form, backward Euler (discretisation), without D for simplicity.
Positional:
i[k] = i[k−1] + Ki·Ts·e[k]
u[k] = sat( Kp·e[k] + i[k] )
Incremental:
Δu[k] = Kp·(e[k] − e[k−1]) + Ki·Ts·e[k]
u[k] = sat( u[k−1] + Δu[k] )
sat — limiting the output to [uMin, uMax].
Example without limits
Kc = 2.5 %/%, Ti = 40 s (Ki = 0.0625 1/s), Ts = 1 s; from sample 1 the error steps to 2 % and stays constant.
| Sample | Positional: Kp·e + i | Incremental: u[k−1] + Δu |
|---|---|---|
| 1 | 2.5·2 + 0.125 = 5.125 | 0 + (5 + 0.125) = 5.125 |
| 2 | 5 + 0.25 = 5.25 | 5.125 + (0 + 0.125) = 5.25 |
| 3 | 5 + 0.375 = 5.375 | 5.25 + 0.125 = 5.375 |
The result is identical: the incremental algorithm is the same formula written in differences.
How they differ
| Positional | Incremental | |
|---|---|---|
| State | integral i[k] | previous output u[k−1] |
| Saturation | the integral keeps growing — anti-windup is needed | the output sits at the limit, there is "nowhere" to integrate: protection is built in |
| Manual → auto | the integral must be aligned with the manual output | bumpless by construction: starts from the current output (bumpless transfer) |
| Controller without I (P, PD) | works | P without I is not possible: the output bias is undefined, the output drifts |
| "More/less" output | must be differentiated | natural: Δu → pulse duration |
Pulse output
Motorised actuators without a position feedback (three-point drives) are commanded "open" and "close". The incremental algorithm fits here: Δu is converted to a pulse duration through the full-stroke time.
pulse duration = |Δu| / 100 % · full-stroke time
Example: Δu = 0.5 %, full-stroke time 60 s → a 0.3 s pulse. Pulses shorter than the minimum actuator on-time are accumulated or dropped — this adds a dead band (dead band).
Typical mistakes
- An incremental P controller without an integral — the output drifts with noise.
- A positional controller without anti-windup on a process where the output often hits a limit.
- Limiting the wrong signal: in the incremental algorithm the output u[k] has to be limited, not Δu; a rate limit on Δu is a separate function.
- Lost position: with pulse control and no feedback the computed and real actuator positions drift apart; periodic synchronisation at the end stops is needed.
Limits
Real PLC blocks may combine the approaches: a positional PID with output tracking, a "step" controller with an actuator position model. Check the algorithm and the meaning of the parameters in the documentation of the block version.
Connections
Open in Knowledge Graph →Loading the map…
Sources
Updated 2026-10-12