When Attemping To Discretize A PID Compensator, An Exception Is Generated

[oneEclipseUser1]

Hello community,

I am designing a compensator selector. When I discretize a Type III, Type II, or Phase Lag/Lead compensator, the conversion works as expected. However, when I attempt to discretize a PID compensator, an exception is generated.

Here is the test script:

import control as ct

# system plant
plant = ct.tf([10], [1, 100.1, 11])

# Compensator
kd, kp, ki = 0.051, 4.5, 4
pid = ct.tf([kd, kp, ki], [1, 0])

# Frequency and sampling period
freq = 100                        # Sampling frequency
Ts_dt = 1/freq                    # Sampling period

# Convert system to discrete domain
plant_z = ct.c2d(plant, Ts=Ts_dt, method='zoh')   # Digitize plant
comp_z = ct.c2d(pid, Ts=Ts_dt, method='bilinear') # Digitize compensator
Ls_z = ct.series(plant_z, comp_z)                 # Loop gain L(s)
Tz_dt = ct.feedback(Ls_z, 1)                      # Close feedback loop  

The exception that is generated is:
ValueError: Improper transfer function. "num" is longer than "den".

This is a bit odd. Can someone please offer insight as to the reason why it generates this exception when working with a PID compensator.

[slivingston]

In summary, the discretization method involves converting the transfer function to an LTI state-space system before discretizing, but the PID transfer function is improper (degree of numerator is greater than degree of denominator), so this is not possible.

In code, ct.c2d calls the sample method of pid. This method calls cont2discrete from scipy.signal. cont2discrete calls tf2ss first, which checks whether the transfer function is proper, hence the exception.

I do not know if discretization is possible without first finding a state-space realization, but I doubt it because "discretization" is sampling, which involves time, and therefore, requires a state-space realization.

[oneEclipseUser1]

@slivingston,

thank you very much for responding to my query and offering some insight into this matter.

After doing a little further looking into, apparently if I define the pid compensator in this form:

s = ct.tf('s')
N = 100       # Derivative filter coefficient

comp = kp + (ki / s) + (kd * s * N / (s + N))

Then the pid may be converted to its discretized counterpart. The sample script had this note included:

# Note: A real-world derivative term needs a low-pass filter (N) to be causal and realizable

I am not familiar with this last point of having to add the multiplier N to the derivative term (as a multiplier and s + N as a divider). I will have to do a bit of research into this to understand it.

Additionally, the last part (derivative) does look a bit odd tbh:

(kd * s * N / (s + N))

Note that when comparing the discretized time step response with the continuous time step response, the responses do align.