Remember What the Actuator Could Actually Do

Integral Action Needs to Know About Saturation

BOTIE

Integral control remembers error over time. That memory helps a controller remove a persistent offset, but an actuator has a physical limit. If the motor is already at maximum output, accumulating more error cannot make it push harder. The stored correction can keep demanding too much even after the target is close.

Åström and Rundqwist's 1989 paper examined this windup problem and methods for avoiding it. Their account also noted that the issue had appeared in earlier controller designs and returned with digital implementations. Back-calculation uses the difference between the requested command and the command the actuator could apply to correct the integral state.

We will inspect one discrete update with an explicit actuator limit. Botie can then remember what the mechanism actually did, rather than assuming every requested action happened. The exercise isolates a proportional-integral controller; adding a learned perception model does not remove the actuator's limits.

Sources for this history

The Motor Is at Its Limit, but the Controller Keeps Asking for More

Proportional correction can leave a persistent offset under a steady disturbance. An integral term accumulates error to keep pushing against it. But if the actuator reaches its limit, the stored correction can keep growing even though the motor cannot follow.

When the target becomes reachable again, that stored demand can produce a large overshoot. We need the controller’s memory to account for the command that was actually applied.

One discrete PI back-calculation step; gains are teaching values and are not hardware tuning guidance.

Step 1 of 1

A bounded actuator cannot follow an unlimited request

Integral state J is measured in command units.

Requested command is 11; applied command is 3. Their difference feeds the memory correction.
Quantity	Value
Error	5
Proportional gain	2
Stored J	1
Actuator maximum	3

Error
Value
5
Proportional gain
Value
2
Stored J
Value
1
Actuator maximum
Value
3

Requested command is 11; applied command is 3. Their difference feeds the memory correction.

What the integral remembers

The actuator mismatch changes internal state instead of merely hiding an excessive request.

Limit the command and correct stored demand

Botie’s actuator saturates while the integral contribution keeps growing.

BOTIE

Botie’s actuator saturates while the integral contribution keeps growing.

Choose an example

Position error

Stored integral contribution

Proportional gain

Integral gain

Back-calculation gain

Timestep

Lower actuator bound

Upper actuator bound

Applied command and updated integral contribution

Follow the operations

1. Proportional gain
```
1
```
2. Position error
```
1
```
3. Multiply
```
1
```
4. Stored integral contribution
```
0
```
5. Add
```
1
```
6. Lower actuator bound
```
-3
```
7. Upper actuator bound
```
3
```
8. Limit a numerical range
```
1
```
9. Integral gain
```
1
```
10. Multiply
```
1
```
11. Back-calculation gain
```
0.5
```
12. Subtract
```
0
```
13. Multiply
```
0
```
14. Add
```
1
```
15. Timestep
```
1
```
16. Multiply
```
1
```
17. Add
```
1
```
18. Collect two results
1. 01
2. 11
19. Result
1. 01
2. 11

One discrete PI back-calculation step; gains are teaching values and are not hardware tuning guidance.

1. What the integral remembers

Proportional action reacts to the current error. Integral action accumulates error over time, helping oppose a persistent disturbance. Store J as the already gain-scaled contribution so it can be added directly to the proportional command.

A derivative term responds to rate of change. It can add damping, but measurement noise and sudden setpoint changes require careful filtering and formulation.

This lesson implements PI with anti-windup. It does not present a complete tuned PID controller.

2. Separate requested and applied commands

Calculate the request using the old integral contribution. Clip it to the actuator bounds. Keep both values because their difference tells us what the actuator could not do.

requested = kp × error + J = 2 × 5 + 1 = 11
applied = clip(11, -3, 3) = 3

Clipping the output alone does not stop the internal memory from growing.

Inspect what the actuator could not apply

Keep the mismatch as a signed value.

Python

requested = 11
applied = min(3,max(-3,requested))
print(applied-requested)

Output

-8

The negative mismatch should oppose growth in the positive requested command.

3. Feed the mismatch back into memory

Update J with ordinary integration plus a correction proportional to applied minus requested command. Here kaw has units of inverse time.

J_next = J + ki × error × dt + kaw × (applied - requested) × dt
J_next = 1 + 1 × 5 × 1 + 0.5 × (3 - 11) × 1 = 2

Without the mismatch correction J would become 6. Back-calculation reduces that growth; its gain and timestep still need validation.

4. Test leaving saturation, not only entering it

After a long saturation period, reduce the target and inspect recovery. Test both upper and lower bounds. A correct sign for positive saturation can still be wrong for negative saturation.

Anti-windup is not a general stability proof. Plant dynamics, delay and tuning remain part of the closed-loop assessment.

The coding exercise returns both applied command and next memory, making their different roles testable.

5. Derivative action needs a measurement model

In a full PID controller, a derivative contribution reacts to the rate of error change. A sudden target change can create a large derivative request, and differencing noisy measurements amplifies high-frequency noise. Implementations often use filtered measurement derivatives and explicit setpoint handling.

Adding a derivative term to this PI exercise would therefore require new state, a filter and a timing contract. It should be taught and tested as another design decision rather than inserted as one unexplained symbol.

The present construction intentionally remains PI. Its anti-windup logic can be inspected without implying that a full controller has been tuned.

Checking your account