Here's a situation that neither proportional nor integral control really deal with. It's rapid changes to the system that come from an external source. Keeping the system steady when outside influences are making it change abruptly is the job of derivative control. In calculus, derivative is an operation that measures the rate of change of a curve, such as the error curve shown in Figure 11. By taking action based on the rate the error is changing, the output drive can respond rapidly to disturbances to the system.

Like the samples in Figure 11, calculus can be used to examine any point on the curve and give you an exact slope. Circuits that involve operational amplifiers do these continuous calculations for continuous time control systems. When a signal is digitally sampled periodically, the derivative can be an algebraic slope calculation. The BASIC Stamp can then take the difference between two sampled points on a curve, and divide by the distance (time) between those two points.

In the case of the error vs. time graph, derivative would be the change in error divided by the change in time. That's ∆e/∆t. As with integration, numerical differentiation (calculating the derivative) can be simplified for control purposes by always considering the time between samples to be a value of 1. Then, numerical differentiation can be accomplished by subtracting the value of the previous error measurement from the current error measurement. In other words, derivative control can be accomplished with simple subtraction:

' Calculate derivative term. error(Delta) = error(Current) - error(Previous) d = Kd * error(delta)

Although ∆t might be a small or a large value, so long as it's always the same interval, the derivative constant, Kd can be scaled to compensate for the fact that we made ∆t equal to 1. Keep in mind that the rate that the errors are sampled also has to be faster than the error signal's tendency to change.

The job of derivative control is to react to changes in the system. For example, a constant error of -3 will be dealt with by proportional and integral control, but derivative won't touch it. Why? Because derivative only reacts to changes. With a series of errors of the same value, there's no change. However, any kind of change, such as the error going from -3 to 4, will cause derivative control to resist. Let's try an example program and observe how this works.

Figure 13 shows a block diagram for the derivative control loop the next example program will emulate. As with the other examples, Kd will be 10. This program will measure the rate of change of the error measurement (de/dt) and multiply by Kp = 10. This result will go to your Debug Terminal (actuator output).

**Example Program - DerivativeAlgorithm.bs2**

Try entering a series of sensor inputs that don't change, like 3 3 3 3 3 3 3 -4. Derivative will resist the first 3 because that's a change from 0 to 3, but all the rest of the threes will result in no correction from the derivative calculation. Then, with the big change from 3 to -4, the derivative will drive hard to correct this abrupt change.

- Enter, save, and run DerivativeAlgorithm.bs2.
- Try 3 3 3 3 3 3 3 -4. Verify that derivative resisted the first 3 but made no attempt to correct the others.
- Also verify that the the big change from 3 to -4 resulted in a large output to correct the change in error.

' DerivativeAlgorithm.bs2 ' Demonstrates how derivative influences error correction ' in a feedback loop. ' {$STAMP BS2} ' {$PBASIC 2.5} SetPoint CON 0 ' Set point Kd CON 10 ' Derivative constant Current CON 0 ' Current error Previous CON 2 ' Previous error Delta CON 3 ' Accumulated error sensorInput VAR Word ' Input error VAR Word(4) ' Different types of errors d VAR Word ' Derivative term drive VAR Word ' Output DO DEBUG "Enter sensor input value: " DEBUGIN SDEC sensorInput ' Calculate error. error(Current) = SetPoint - sensorInput ' Calculate derivative term. error(Delta) = error(Current) - error(Previous) d = Kd * error(delta) ' Calculate output. drive = d ' Display values. DEBUG CR, CR, "ERROR", CR, SDEC ? SetPoint, SDEC ? sensorInput, SDEC ? error(Current), CR, "DERIVATIVE", CR, SDEC ? Kd, SDEC ? error(Delta), SDEC ? d, CR, "OUTPUT", CR, SDEC ? d, SDEC ? drive, CR, CR ' Save current error to previous error before next iteration. error(Previous) = error(Current) LOOP

**How DerivativeAlgorithm.bs2 Works**

The error array variable now has four elements. Element 0 is still the current error, element 1 is the accumulator, which is unused at present since there are not integral calculations in this program. Element 2 is used to store the previous error measurement, and element 3 is used to store the difference between the previous and current measurements. The constant for element 2 is **Previous**, and the constant for element 3 is **Delta**. That makes the derivative calculation much easier to read.

' Calculate derivative term. error(Delta) = error(Current) - error(Previous) d = Kd * error(delta)

At the end of each pass through the loop, the current measurement has to be saved as the previous measurement. There will be a new **error(current)** the next time through the loop, and a new **error(delta)** will be made with the updated **error(Previous)** value.

' Save current error to previous error before next iteration. error(Previous) = error(Current)

**Your Turn - Increasing the Reaction to Abrupt Changes**

- Try changing the derivative constant (Kd) from 10 to 20.· It should react twice as strongly as before to abrupt changes in the error.