generic PID controller in C

[v923z]

Hi all,

I know that there are quite a few PID controllers implemented in python (an excellent example can be found under https://github.com/2dof/esp_control/tree/main), but I have also seen the benchmarks, which indicated that they wouldn't be fast enough for my application, so I cobbled something together in C. I wanted to have something that is system-agnostic and fast. The concept is explained here https://github.com/v923z/micropython-ulab/blob/pid2/docs/ulab-pid.ipynb, while the code is in https://github.com/v923z/micropython-ulab/tree/pid2/code/pid. Before merging this, I'd like to have some sort of feedback on what extra functionality could be useful, what could be improved upon etc.

Beyond moving the PID loop itself to C, I wanted to get rid of two very annoying steps in the controller: the conversion between floating point results and the input/output devices, which most probably consume integers. Second, look-up tables and complicated functions for the sensor data.

So, for this reason, the controller shares its buffers with the input/output devices, where the conversion automatically takes place, and no data have to be passed between python methods. Sensor data are converted by means of a simple Taylor series expansion of the sensor + system transfer function.

All properties of the controller can be accessed via dot setters/getters, and time differences are measured by the loop itself. The python pseudo-code looks like this

from ulab import PID

pid = PID.PID()

# set up coefficients of the Taylor expansion, bit representation of sensor data etc.
pid.input.init()
pid.output.init()

input_buffer = bytearray([1, 2, 3, 4])
pid.input.bytes = input_buffer

output_buffer = bytearray([5, 6, 7, 8])
pid.output.bytes = output_buffer

while True:
    ADC.read_into(input_buffer)
    pid.step()
    DAC.write(output_buffer)

[2dof]

@v923z , I just noticed Your post (haven't got notification about topic). So primary code in micropython in repo is R&D but verified and tested (in thermal process control: pottery kiln) in two ways:

• as PLC lib in python for Raspberry PI, (full functionalities)
• as digital PID controller hardware solution in esp32 for thermal process (but simplified SP, PV, and CV preprocessing since hardware was fixed (PV sensor measuring (, and SSR control).

End of project is C (it is already easy to migrate), Code (with all preprocessing steps) is prepared for full customizable PLC pid-controller implementation (like Simens Simatic PLC standard PID solution) with additional functionalities.

In MP project, I used floating point and do not use here "tricks" use in commercial solution (i.e store parameters as integers for example, Kp=1.5 (float) , we can save as Kp=1500 and in any function calculation just divide by 1000 ( just like in some commercials product (Hitachi PLC and other).
As primary PID implementation i my project, all data storage is based on uctypes.struct() byte array defined by dictionary (like pid_aw) - easy to migrate to C struct Union .

About speed - target for my project was thermal process control- so it type of slow.
In My benchmark I just tested pure numerical speed computation but in real implementation a some safety (idiot resistant) should be added) and as for whole application sampling time will be slower (still fast for thermal type of process)

if You want fast sampling (processing) then:

-> cut of all necessary functionalities ( antiwindup, selectors etc, implement noise filtering as fixed point calculation (watch out for), simplify all preprocessing.

• in fixed type control process (motor speed/position control etc ) p-i-d controller can be implemented as pure driver architecture (no selectors, fixed architecture)
• sampling time (control update) should be always selected according to process dynamic time, but in many (hardware) thermal control solution sampling time of PV /SP is for example is 0.1 sec for preprocessing (filtering noise, detect sensor disconnection/fail etc during ADC read and for pure PID calculation and control update is, for example every 0.5 sec - 1.0 sec (it is true control sampling time).

It is all about control stability. For fixed control implementation (as driver) it is possible to implement calculation as fixed point, but then all approximation should be tested against stability and errors progression, and calculation overflow. (see How to Build a Fixed-Point PI Controller That Just Works

[v923z]

If we do the processing in python, then no matter what we do, it's simply too slow for our application. We used all tricks available except for implementing the code in assembly. That's why I moved everything to C.

On the other hand, your library has quite a few controller types, so, in that sense, it's definitely more universal.

[2dof]

it allows select/build a lot of P-I-D control configuration (2-degree, antiwindup, incremental form), but not necessary needed all features in real application (except PLC solution).

Another approach (usually in adaptive control ) is to use discretized form where all parameters are reduced to polynomial coefficients (numerator and denominator) and then IIR filtration algorithm can be used ( but for every PI, PD, PID , antiwindup, bumpless, configuration separate polynomials must be calculated), as Pros that form is comfortable for any adaptive control solution (vector/matrix operation) and then if possible fixed-point can be used (like in DSP solutions).
And most platofrm ussualy has optimized dsp processing (filtering) C libraries (for example for esp32 espressif iir biquad filter)