Discrete PID Controller — Control Systems/Discrete

Discrete PID Controller

Control Systems / Discrete

A discrete-time PID controller with a filtered derivative. It takes the error signal e and produces the control signal u, updating once per sample:

Parallel:  u = P·e + I·F_i(z)·e + D·N/(1 + N·F_d(z))·e
Ideal:     u = P·( e + I·F_i(z)·e + D·N/(1 + N·F_d(z))·e )

F_i and F_d are the discrete accumulators chosen by the two method parameters. This is the sampled counterpart of the continuous PID Controller; the derivative is never taken bare, so the controller stays proper and has a two-state realization.

Ports

• Input – the error e, of any size [p,m].
• Output – the control signal u, of the same size.

The controller is SISO, but it is applied independently to every entry of the input signal, each entry carrying its own two states.

Parameters

• Proportional (P) – the proportional gain, a scalar.
• Integral (I) – the integral gain, a scalar. Zero removes the integral action.
• Derivative (D) – the derivative gain, a scalar. Zero removes the derivative action, whatever N is.
• Filter Coefficient (N) – the derivative filter bandwidth, a non-negative scalar. A large N tracks the ideal derivative closely and a small one smooths it heavily. Zero removes the derivative action outright.
• Controller Form – how P enters the sum:
  • Parallel – P, I and D are independent gains on the three branches.
  • Ideal – P multiplies the whole controller, so it scales the integral and derivative action too.
• Integrator Method – which accumulator realizes the integral branch:
  • Forward Euler – T_s/(z−1). The output does not depend on the current error, so the branch adds no direct feedthrough.
  • Backward Euler – T_s·z/(z−1).
  • Trapezoidal – (T_s/2)·(z+1)/(z−1), the most accurate of the three for a given rate.
• Filter Method – the same three choices for the derivative filter, picked independently of the integrator's.
• Initial Condition (Integrator) – the integrator accumulator at the start of the run, a scalar used for every entry. The I gain sits before the integrator, so this is the initial value of the integral term, not of the accumulated error.
• Initial Condition (Filter) – the derivative filter's accumulator at the start of the run, a scalar used for every entry. It is expressed exactly as Simulink expresses it, which for the Backward Euler and Trapezoidal filter methods is a differently scaled state than the one this block steps – the block converts it, so the same number means the same thing on both sides.
• Sampling Time (s) – zero or less inherits the solver's rate; a positive value runs the block at that period. It is not merely a schedule here: it is the T_s in both accumulators, so changing it changes the controller.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text. Unlike the continuous PID, nothing has to be discretized at export time – the block is already a difference equation, so the generated core runs the identical recursion the in-app simulation does.

P, I, D and N are not tunable on the generated core: the two method choices and the sampling period mix them into the A/B/C/D that is embedded, so retuning would mean re-deriving them on the target. Change them here and export again. The two initial conditions are baked in as the state seed for the same reason.

Simulink bridge

Import and export, mapped to simulink/Discrete/Discrete PID Controller. "Proportional (P)" to P, "Integral (I)" to I, "Derivative (D)" to D, "Filter Coefficient (N)" to N, "Controller Form" to Form, "Integrator Method" to IntegratorMethod, "Filter Method" to FilterMethod (all three are 1:1 and therefore lossless pairs), "Initial Condition (Integrator)" to InitialConditionForIntegrator, "Initial Condition (Filter)" to InitialConditionForFilter, and "Sampling Time (s)" to SampleTime, as on every block.

Three Simulink parameters are always implied rather than offered as a choice: Controller = PID, TimeDomain = Discrete-time and UseFilter = on. The full PID structure covers Simulink's PI, PD, P and I controllers numerically – set D to zero for PI, I to zero for PD – so nothing is lost by always emitting it.

What does not cross: output saturation with anti-windup (LimitOutput), external reset (ExternalReset), external initial conditions and tracking mode all add input ports in Simulink, and no config value here can add or remove a port. An unfiltered derivative (UseFilter = off) does not cross either: it is a bare difference, and Discrete Derivative is the block for that.

Notes

• Discrete only, and stateful: two accumulators per input entry.
• Being linear, the block is directly usable by the model reduction and linear-analysis commands.
• Integrator wind-up is not limited. With no output saturation to unwind against, a sustained error accumulates without bound – the same behaviour Simulink's block has with LimitOutput off.