When a servo axis is moving, its actual position almost never sits exactly on the commanded position; it lags behind by a small amount that changes as the move progresses. That instantaneous gap between where the axis is told to be and where it actually is, is the following error. A little following error is normal and expected during motion. A lot of it signals that the axis cannot keep up, or that something is wrong, which is why servo systems watch it closely and fault when it grows too large. This page defines following error, explains why it grows with speed and acceleration, describes the following-error limit as a fault trigger, and shows how velocity feedforward reduces it.
Following Error in one line: Following error is the instantaneous difference between an axis's commanded position and its actual measured position while it is moving. It is a normal, small lag during motion, but it grows with speed and acceleration, and if it exceeds the configured following-error limit the drive faults the axis. Velocity feedforward reduces following error by anticipating the commanded motion rather than only reacting to error.
A basic servo position loop generates its correcting command in proportion to the position error. That has a built-in consequence: to make the axis move at all, the loop needs some error to act on. During a constant-velocity move, the axis settles into a steady lag behind the command just large enough for the position loop to produce the velocity needed to keep up. The faster the commanded velocity, the larger that steady lag has to be, so following error rises with speed.
Acceleration adds to the error further. When the command is speeding up or slowing down, the axis must not only keep pace but change its pace, and the loop needs additional error to drive that change against the axis's inertia. So following error is largest during the acceleration and deceleration portions of a move and during high-speed cruising, and smallest when the axis is holding still, where it settles toward zero. This is why following error is a dynamic quantity, changing continuously throughout a move rather than a fixed offset.
Following error also reveals the physical state of the machine. If it suddenly grows larger than usual for the same commanded move, something has changed: added load, increased friction, a binding mechanism, a slipping coupling, or a drive that cannot deliver the needed torque. Because the error reflects the gap between what was asked and what happened, it is one of the most direct indicators that the mechanics or the drive are no longer performing as they did.
Servo drives and motion controllers let the user configure a following-error limit, a maximum tolerable gap between commanded and actual position. As long as the following error stays within this limit, the axis runs normally. If the error exceeds the limit, the drive declares a following-error fault and typically stops the axis. This is a fundamental safety and integrity check: it catches the axis losing track of its command before the situation gets worse.
The limit protects against real hazards. If a mechanism jams, the command keeps moving while the actual position stalls, so the following error shoots up; the limit trips before the drive keeps straining against an immovable obstruction. If a load is far heavier than expected or a drive is failing to deliver torque, the axis falls behind, and again the limit catches it. Without such a limit, an axis that cannot follow its command could damage the machine, the product, or itself while the controller obliviously keeps commanding motion.
Setting the limit is a balance. Too tight, and normal following error during fast or heavily accelerating moves trips nuisance faults that halt production for no real reason. Too loose, and a genuine problem, a jam or a failing drive, is allowed to develop further before the fault fires. A well-chosen limit sits comfortably above the largest following error the axis produces in normal operation but well below the level that indicates a real fault, so it ignores healthy motion and catches trouble.
Much of the following error during motion exists only because a proportional position loop reacts to error rather than anticipating the move. Velocity feedforward addresses this directly. Instead of waiting for position error to build up and then commanding velocity in response, feedforward supplies a velocity command derived from the known commanded trajectory, in effect telling the drive in advance how fast it should be going. The position loop then only has to correct the small remaining error rather than generate the whole velocity from lag.
The effect is a marked reduction in following error during motion, especially in the constant-velocity portions where the anticipated velocity closely matches what is needed. Feedforward makes the axis track its command more tightly, which improves accuracy on the fly and, in coordinated multi-axis moves, reduces the path deviation, sometimes called contour error, that arises when axes lag their commands by different amounts. It is one of the most effective tuning tools for improving tracking without simply cranking up position-loop gain and risking instability.
For monitoring, following error is a genuinely useful health signal, and it does not require the SCADA layer to close any control loop. Drives report following error and its fault events, and trends in that data tell a story: a slow, gradual increase in the following error needed to make the same move over weeks or months often signals wear, contamination, or a developing mechanical problem. A cloud SCADA platform such as Merobix can collect and trend following error and fault occurrences from positioning axes across a plant or across remote sites, so maintenance can act on a rising trend before it becomes a fault that stops the machine, especially valuable where equipment is not routinely watched in person.
Following error is the instantaneous difference between where a servo axis is commanded to be and where it actually is while moving. A small following error is normal during motion because a position loop needs some error to generate its correcting command. It grows with speed and acceleration and shrinks toward zero when the axis holds still.
Servo systems let you set a following-error limit, a maximum tolerable gap between commanded and actual position. If the error exceeds it, the drive declares a following-error fault and typically stops the axis. This catches problems like a jam, an overload, or a failing drive before the axis strains against an obstruction or loses track of its command entirely.
Velocity feedforward supplies a velocity command taken directly from the known commanded trajectory, telling the drive in advance how fast it should be moving instead of waiting for position error to build up. The position loop then only corrects the small residual error, so the axis tracks its command much more tightly and following error during motion drops significantly.
Merobix reads your field devices into a cloud SCADA - the real thing behind these terms, live in days from any browser.