Discrete PID Controller 2DOF — Control Systems/Discrete

Discrete PID Controller (2DOF)

Control Systems / Discrete

A two-degree-of-freedom discrete-time PID controller. It takes the reference r and the measurement y on separate input ports rather than a pre-formed error, which is what lets the setpoint weights b and c route the reference into the proportional and derivative branches independently of the integral one:

Parallel:  u = P·(b·r − y) + I·F_i(z)·(r − y) + D·N/(1 + N·F_d(z))·(c·r − y)
Ideal:     u = P·[ the same three terms ]

F_i and F_d are the discrete accumulators chosen by the two method parameters. Setting b = c = 1 collapses the block to the one-degree-of-freedom Discrete PID Controller. The point of it is b < 1, which softens the proportional kick on a setpoint step without touching the disturbance response, and c = 0, which removes derivative kick entirely.

Ports

• r – the reference (setpoint), of any size [p,m]. It reaches the proportional branch weighted by b and the derivative branch weighted by c.
• y – the measurement, the same size as r. It enters every branch unweighted.
• u – the control signal, the same size again.

The controller is two-input/one-output, but it is applied independently to every entry of the signals, 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 and c are.
• Filter Coefficient (N) – the derivative filter bandwidth, a non-negative scalar. Zero removes the derivative action outright.
• Setpoint Weight (b) – how much of the reference reaches the proportional branch. One gives the ordinary error P·(r − y); zero makes the proportional action respond to the measurement alone.
• Setpoint Weight (c) – the same for the derivative branch. Zero is the common choice, and removes derivative kick on a setpoint step.
• 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, including the setpoint-weighted proportional term, 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.
• 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. 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, N, b and c 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. 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 (2DOF). "Proportional (P)" to P, "Integral (I)" to I, "Derivative (D)" to D, "Filter Coefficient (N)" to N, "Setpoint Weight (b)" to b, "Setpoint Weight (c)" to c, "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.

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.

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, as on the one-degree-of-freedom block.