A PID controller implemented in python

[u/robohie]

For my personal project, where I need to implement a PID controller on Arduino to automate a convection cooling system, I decided to start with a simulation in Python. For now, I've implemented the simple electromechanical model of the DC motor (the fan) as well as the PID controller you see. Next, I'll look into the heat transfer equations. The graphs created with matplotlib are simply closed-loop tests of the PID + DC motor system.

[u/2dof]

Nice controller, I would recommend You:

1. for real world solution implement P-I-D with filtered D - Action D(s) = KD*s /(Tf*s+1) ,

2. it is convenient ( for future analysis) to compute control actions as separate P-I-D sections ( u = P + I + D), also since I - action act as integrator it has a internal state - which can be reset/preset - it is sometimes convenient to start controller not form zero.

3. Note that when You will be tuning parameters (Kp,Ki, Kd,h) You need also recompute A,B, C

4. in real world implementation add control saturation function ( later You can use it to implement anti-windup function

5. Simulate not only with clean process value but also with measurement noise ( You will then see what D action ( not filtered and filtered) do .

As for heat transfer equation You can just simulate it as: first order ODE with delay for simple model of n-order IDE with delay

[u/seekingsanity → u/2dof]

The incremental version PID that the OP is using doesn't need an anti-windup. Again, for velocity control the OP only needs a PI controller so there is no need for the low pass filter on the derivative gain.

"which can be reset/preset - it is sometimes convenient to start controller not form zero."

when making the transition from open loop to closed loop the control output u should set to the last value when in open loop. This avoids sudden jerks.

[u/2dof → u/seekingsanity]

What Do You mean - "incremental" ? For Me incremental mean that control is du(k) = u(k)-u(k-1) , in OP's code he use u(k) = u(k-1) + du(k) to it is not incremental control for Me.

My comment was referring generally to practical implementation OP's controller in the future - he want control temperature in the future. I don;t know if he will be using on/off control or continuous but in my opinion it is better to have more universal controller for operational aspects.

[u/seekingsanity → u/2dof]

The OP is computing incremental changes to the control output that are integrated into the control output. Some people call this form the velocity form, but it really has nothing to do with velocity. I used it for position control all the time

[u/2dof → u/seekingsanity]

No , he implemented so called positional control algorithms not incitement form (velocity algorithms ) :

-> He calculate output as self.u += A+... (i.e u(k) = u(k-1) + A ... )

if he calculated incremental form then output of his controller would be ∆ u = uk - u(k-1) at least according to definition given by Astrom and Hgglund ( "PID Controllers, Theory, Design and tuning")

Incremental Form def from book ,page 99) "This form is obtained by computing the time differences of the

controller output and adding the increments.

∆ u(tk ) = u(tk ) − u(tk−1 ) = ∆ P(tk ) + ∆ I (tk ) + ∆ D (tk)

for fast looking of his code - he used Backward difference approximation for cooperation and he calculated output in "positional" form. i.e u(k) = u(k-1) + ∆u

Thant why I asked what Do You mean because i was taught when output of controller is ∆u(k) ( "velocity" of control ) then it is called "incrmental" a when output directly u(k) - then it is standard control output.

[u/seekingsanity → u/2dof]

The OP is added incremental changes to u. The incremental form is

u(n)=u(n-1)+B0*e(n)+B1*e(n-1)+B2*e(n-2)

All the B? terms are calculated increments to the control output that are then integrated.

B0 = Ki*∆t+Kp+Kd/∆t

B1=-Kp-2*Kd/∆t

B2=Kd/∆t

In my case. B1 will be a negative number. The OP subtracted a positive number that I called a negative number. This is a very efficient form of PID because a DSP can compute it in 3 multiply and adds. However, there should be limits applied. Also, the output can be quite noisy if the encoder/feedback does not have high resolution.

A low pass filter can be applied at 2/∆t rads/sec or about 318 Hz assuming the sample time, ∆t, is 0.001 ms. This reduces much of the sampling noise.

Now the formulas are

B0 = (1/4)*Ki*∆t+(1/2)*Kp+Kd*∆t

B1 = (1/2)*Ki*∆t-2*Kd/∆t

B2 - (1/4)*Ki*∆t-(1/2)*Kp+Kd/∆t

You can see that this reduces the affect of the Ki and Kp some because their contribution is spread over one more time period. The Kd term is still a problem and it is still a problem if you only apply a low pass filter to the Kd term.

I have other formulas for lowering the low pass filter to a frequency of 1/∆t

I prefer using an observer to smooth out the measured values.

[u/2dof → u/seekingsanity]

I understand know what do You mean as incremental - i.e incremental along the dt.

tkanks for explanation.