TcControl

TwinCAT library for PID control and signal filtering.

Examples

`Signal`

The basic unit of this library is the Signal function block. The most basic usage would be the following where a new value is added and can be retrieved.

PROGRAM MAIN
VAR
    signal : Signal;
    value : LREAL;
END_VAR

signal.Update(value:=5); // Add new value to signal
value := signal.Out; // Retrieve the current value, in this case it would be 5

The power of signal becomes clear when combined with .Differentiate

PROGRAM MAIN
VAR
    signal : Signal;
    value : LREAL;
END_VAR

signal.Update(value:=1).Differentiate(deltaTime:=1);
value := signal.Update(value:=2).Differentiate(deltaTime:=1).Out; // 1

Or .Iir

PROGRAM MAIN
VAR
    signal : Signal;
    value : LREAL;
END_VAR

signal.Update(value:=1.4).Iir(decay:=0.5);
value := signal.Update(value:=8.6).Iir(decay:=0.5).Out; // 4.65

Or combining both

PROGRAM MAIN
VAR
    signal : Signal;
END_VAR

signal.Update(value:=7).Differentiate(deltaTime:=1).Iir(decay:=0.5); // singal.Out = 0
signal.Update(value:=8).Differentiate(deltaTime:=1).Iir(decay:=0.5); // signal.Out = 0.5
signal.Update(value:=9).Differentiate(deltaTime:=1).Iir(decay:=0.5); // signal.Out = 0.75

Finally the differentiated/filtered signal can be put into a controller. Currently the library only contains the simple PidController

PROGRAM MAIN
VAR
    signal : Signal;
    parameters : PidParameters := (Kp:=2, Ki:=0.25, Kd:=0.5);
    pid : PidController;
END_VAR

pid(parameters:=parameters, cycleTime:=1);
signal.Controller := pid;
signal.Update(3).Control(setpoint:=4); // signal.Out = 2.75
signal.Update(3.5).Control(setpoint:=4); // signal.Out = 1.125

See the unit tests Singal_Tests for more examples.

Custom controller

You can define your own controller, as long as it implements the IController interface. Then you pass it to your signal instance via signal.Controller := customController;.

Other function blocks

The function blocks used in Signal can also be used as stand-alone function blocks. The following function blocks are defined.

Derivative: Take derivative of a value.
InfiniteImpulseResponse: Infinite impulse response (IIR) filter.
Pid: PID controller
- Pid.DifferentialPartLimit: Limit the differential part. Convenient when the output is calculated for the first time. The limit prevents it from having a very large value after the first call.
- Pid.PreviousIntegralPart: Set previous integral part on first call. Prevents integrator term for needing to build up.

`Derivative`

PROGRAM MAIN
VAR
    derivative : Derivative;
END_VAR

derivative(value:=1, deltatime:=1); // derivative.Out = 0 (derivative is always 0 on the initial call)
derivative(value:=2, deltatime:=1); // derivative.Out = 1

See Derivative_Tests for more examples.

`InfiniteImpulseResponse`

PROGRAM MAIN
VAR
    iir : InfiniteImpulseResponse;
END_VAR

iir(new:=5, decay:=0.95); // iir.Out = 0.25
iir(new:=5, decay:=0.95); // iir.Out = 0.4875
iir(new:=5, decay:=0.95); // iir.Out = 0.71313

See InfiniteImpulseResponse_Tests for more examples.

`PidController`

PROGRAM MAIN
VAR
    pid : PidController;
    parameters : PidParameters := (Kp:=0.1, Ki:=0, Kd:=0.01);
END_VAR

// limits the difference on the initial call
pid.DifferentialPartLimit := 3;
// pass the pid parameters (only need to be done once, unless you change them)
pid(parameters:=parameters, cycleTime:=1);
// Cyclicly call Update
pid.Update(setpoint:=10, actual:=6); // pid.Out = 0.4
pid.Update(setpoint:=10, actual:=8); // pid.Out = 0.18

rruiter87 / TcControl