Do-it-yourself PID controller

I. Statement of the problem

It is necessary to keep the temperature at a certain level and change the task. There is a microcontroller to which a temperature meter is attached, and a triac for power control. We will not warm our heads on TAU, no difference schemes , we just take and make a PID controller in the forehead.

Ii. Theoretical introductory

How is the PID controller obtained? We take the difference between the current temperature and the desired one, multiply by the adjustable coefficient, we get the power that must be given at the moment. This is a proportional component, it works when a mismatch occurs — that is, it instantly responds to both the setpoint change and the object behavior. Began to warm up? Power begins to subside. Overheated? Turned off, or even gave a cooling signal. Everything is good, only in real life the effect of the impact manifests itself with a delay, and the object is affected not only by us, but also by the environment: the heated reactor is not only hot inside, but also cools, giving heat to the room, and therefore just turn off power, it immediately begins to cool. Therefore, the net proportional regulator oscillates around the maintenance point, and the more it fluctuates, the higher the environmental / reactor contents are.

To compensate for the "external" effects on the reactor, an integral component is added to the circuit. All the mismatch that was in the system goes to the integrator (respectively, as soon as we overheat - the amount decreases, while underheated - the amount increases). And the accumulated integral, with its coefficient, gives its increase-decrease to power. As a result of this approach, in a stationary process, after some time the integral selects such a contribution to the sum with a power that compensates for environmental losses, and the oscillations disappear - the integral becomes stable, therefore the amount of output power becomes constant. And since this keeps the right temperature, there is no mismatch, the proportional component does not work at all.

To compensate for the effects of delays between exposure and system response, a differential component is added to the system. Just a proportional regulator gives power all the time until the temperature reaches the desired point, the proportional-differential begins to reduce the supplied power before it reaches the desired point - as the mismatch decreases, there is a negative derivative that reduces the effect. This minimizes overheating at large transitions.
')
So, we have dealt with the physical meaning, we turn to the basic questions of implementation.

Iii. Who should use the regulator?

- To technicians.

What follows from this? It follows from this that technicians understand the physical component, and have experience in setting up hardware PID controllers. This means that the software implementation must proceed from the convenience of customization by technicians - repeating the physical model. And this is extremely important! Very often, for the sake of simplifying the code, the coefficients are changed, for example, to inverse - to get rid of division. As a result, tuning becomes a hell and a nightmare, and one needs experience in setting up this particular regulator, instead of understanding the process. From here we get that our coefficients — the integration constant and the differentiation constant — should have the dimension of time, that is, be specified in seconds, and not at all in “1 / s”, as they like to do.

Iv. Area of ​​operation.

We are trying to make a universal regulator, which means that it should work both on small fast objects and on powerful large furnaces. Therefore, it should be assumed that the regulated temperature is limited in general by a meter. The most commonly used are HA (K) and HC (L). Their area of ​​applicability is somewhere up to 1200 ° C. Cooling requires more sophisticated equipment (cryostats), additional cooling control (fans and opening doors of heating cabinets) is also rarely required - which means we exclude from consideration for now. We obtain that the controlled temperature from ~ 15 ° C to ~ 1200 ° C, only the power supply is controlled.

The accuracy of the control is determined by a 1x measurement accuracy: calibration tables are given after 0.1 degrees; linearity inside the tables is, in principle, decent, so the accuracy is limited primarily by the amplifier and the current meter. In my case, I wanted to achieve an accuracy of maintaining 0.1 degrees, so the meter is set to 1/32 degrees: this gives ~ 3 quanta by 0.1 degrees, thus having a normal regulation “noise” + -1 quantum, we remain within the same 0.1 degrees Using 1/32 allows you to work with a fixed point - 5 bits = fractional part, the rest is whole. In 16 bits it turns out to present from 0 to 2047 °. Instead of working with negative numbers, we will work in Kelvin instead of Celsius, so it appears from 0 to 2047 ° K, which is equivalent to from -273 to 1775 ° C; in increments of 0.03125 °.

V. Range of customizability.

To control a microreactor with a powerful power plant, it may turn out that 1% of power is enough for heating by 10 degrees, while for a large inert furnace, 100% of the capacity of heating is just enough to heat a degree. (In real life, it looks like this - there are several heaters with manual control - they are turned on by a separate switch and produce initial heating, in the future maintaining the operating point provides the thermostat, controlling another heater, which at full power produces a maximum of + 10 ° C to that are constantly heated). Based on this, it is logical to assume that the limiting coefficient of proportionality is 100% power per degree. It no longer makes sense, since we want controllability of 0.1 degrees. Minimal, for simplicity, I took inverse - 1% power per 100 degrees.

The ranges of temporal coefficients are calculated simply based on our operating conditions for the controller. Since we control through the power of the triac by calculating the delay of the moment of switching on after passing through 0, the limit frequency of the regulator is 50 Hz. If we are sure that we control the power which doesn’t plus or minus, we can work at 100 Hz, but this is not always the case, and therefore it is better to dose an equal amount of both positive and negative half-waves each time. To simplify life, I reduced the operation time to 25 Hz, thus any calculated impact will last for 4 half-waves, and during this time I will be able to calculate a new impact.

Thus, time constants are set in 1/25 sec, from 0 to ~ 2000 sec (2000 * 25 = 50,000, just 16bit interlaces).

Well, we also have a minimum and maximum power limit, from 0 to 100%.

Vi. Power management

From this point on, all theoretical calculations end, a bitter practice begins, tied to a specific implementation.

So, we have already decided that we control the delay in opening the triac after passing through 0. Thus, a delay of 0 means 100% power, infinite delay = 0% power.

Question: with what accuracy can we control the power? In general, with the accuracy of the timing of our timer. On the other hand, what power is needed? We calculate what% of the power you need to apply for 0.04sec. In principle, according to experience, power control even with an accuracy of 1% at a frequency of 0.1 seconds is enough to maintain a temperature of 1 degree. We manage 0.04sek (2.5 times faster). Therefore, it was decided to calculate the power table in 1/250 of the maximum (in 0.4% steps). This allows the table to have a not very large (500 bytes), and at the same time have an accuracy above 1%. If your case requires greater accuracy - it is not so difficult to count.

Now let's talk about the calculation of this table itself. In-1x it should be noted that there is a moment of triggering a signal passing through zero. In my case - 12V. That is, when the input voltage drops below 12V, I will receive a signal passing through 0.

This means that for 100% power, the start time = 12V transit time.


The processor works for me at a frequency of 32786, the PLL is set to 384/2, the half-wave has 100Hz, whence we get that the code for loading a constant into the timer for time T has the form:

65536-(T*(32768*384/2)/100.0 + 773)

We need to calculate the delay time, giving a uniform increase in the area of ​​the included part of the sinusoid. That is, we need to have time counts that give a uniform increase in power. The total power that we give out is integral over the entire sinusoid. [who knows how to embed formulas in Habré? no way I write in the maple-notation then].

 Max = int (sqr (sin (x)), x = 0..Pi)
 int (sqr (sin (x)), x = 0..T * Pi) = x / 2 - sin (2 * x) / 4 + C |  0..T * PI = (T * Pi) / 2 - sin (2 * T * Pi) / 4
 (T * Pi) / 2 - sin (2 * T * Pi) / 4 = Q * Pi / 2

Thus, we need to go through all Q with a given accuracy, and for each of them find T.

I decided this for myself in this stupid way:


Everything, at the output, we received a label of 250 values, corresponding to the constants of timer loading until the moment of ignition after receiving a signal about passing through 0 (more precisely, through 12V, as I said above).

VII. Input Measurement

I skip this question, because it deserves a separate large article. How I solved the issue with thermal resistance can be found in the archive of my blog, who has died in Bose .

The main thing we need to know is that we measure the data with the frequency we need (in this case, 25 Hz), and with the required accuracy (the output is a number from 0 to 2048 degrees Kelvin in 1/32 degrees). The data are assumed to be already normalized for all further calculations.

If anyone is interested - write in the comments, sign for the next time how this is done for thermocouples.

Viii. Impact calculation

And now it has happened: we have all the data in order to finally produce something for which we were plotting everything: calculate what kind of power should be fed to the control element.

Recall the PID controller formula:

U = K * ( Err + (1/Ti)*Int + Td*dErr )

• U is the power that should be given out;
• K - proportional coefficient (note - put out of the brackets, why - I will describe just below);
• Ti is the integration time constant. Pay attention - in calculations the return value is used;
• Td - differentiation time constant
• Err - the current mismatch (the difference between the setpoint and the measured temperature
• dErr - mismatch derivative (the difference between the current and the previous error)
• Int is the accumulated mismatch integral (the sum of all Err's we have seen)

We again came to the question that was raised in Section III : technology will use this. Therefore, it is extremely important to prevent the classical error of all implementations - "the dimensions of the coefficients as it will." We make the device to control the physical process, and therefore, the model must comply.

Produce the output of all dimensions. Partially looking ahead, I have already described in IV , but now we will reveal more:

• U - has a value in% power. More precisely - in 2/5 of the% power, since our table goes through 1/250 from 100%.
• Err - mismatch, set in degrees. More precisely - through 1/32 degrees.
• Int is an integral, is the sum of degrees over time - and therefore, it has the dimensionality of degrees * sec. More precisely - (1/32 degrees) * (1/25 sec.)
• Ti - set in 1/25 sec
• (1 / Ti) * Int - after the calculation makes a contribution that has a dimension (1/32 degrees).
• dErr is a derivative, has the dimension of degrees / sec, or rather (1/32 degrees) / (1/25 sec)
• Td - set in 1/25 sec
• Td * dErr - after the product brings the contribution to the dimension (1/32 degrees)
• (...) - so, all addends under brackets are reduced to dimension (1/32 degrees)
• K - agrees U and (...) , and therefore has the dimension of percent-per-degree, more precisely (2/5)% / (1/32 degree)

Now you can clearly see why the proportional factor is out of the bracket - this allows you to leave the differential and int coefficients just as time constants, as a result, the operator operates with simple and clear numbers — a percentage per degree for proportional and seconds for integral and differential coefficients.

And thanks to a convenient selection of the position of points and the dimensions of time, as we will see now, all calculations are made almost "in the forehead."

Except for one thing - we have the value of Ti , and 1 / Ti is required for the calculation. The operation of dividing a high bit is very expensive. The multiplication operation is several times cheaper, so we will use the excellent article Division by Invariant Integers using Multiplication . After all, K / Ti / Td changes extremely rarely in our country, and therefore we can allow ourselves to somehow pervert with them after they are changed, the main thing is that the main calculation cycle works quickly.

Thus, instead of Ti for calculations, we decompose into a set of Ti_m , Ti_sh1 , Ti_sh2 ; and on each cycle we perform the calculation:

 T1 = MULUH(Ti_m, Int) Q = SHR(T1+SHR(Int-T1, Ti_sh1), Ti_sh2) 

Now we calculate the balance of digit capacity. To do this, we will write out the full formula step by step:

1. Eo = E ; We need an error has passed. Errors - 16bit
2. E = YX ; We calculate the new mismatch. 16bit
3. Int = Int + (E+Eo)/2 ; We integrate an error. In this case, we consider the half-sum of the difference (difference scheme). 32bit = 32bit + 16bit
4. cI = Int * (1/Ti) ; We consider the integral contribution - 32bit * 32bit => 32bit
5. cD = Td * (E-Eo) ; We consider differential contribution - 16 * 16 => 32bit
6. PID = E + cI + cD ; Podsbochnoe; 16 + 32 + 32 => 32bit
7. U = K*PID/256 ; Coeff; 32 * 16/8 bit => 40bit.

For all calculations, the position of the point up to the 7th step remains on the 5th right place. At the last moment there is an interesting feint ears. K is set in 1/256, respectively, after multiplying the point is shifted to the left to 5 + 8 = 13 places, so we should discard the lower 8 bits of the result. And the lowest byte of the result is the power we need in 2/5%. This is another reason why the power is aligned in steps of 1/250 - this allows the result to fit into one byte and get the desired result easily from the table.

Further, we remember that we are only interested in power from 0 to 250 - therefore, the 7th step of the calculations goes very simply, as soon as we get a negative number - we immediately add uMin. As soon as they found out that any high byte is not zero, we immediately add uMax. And only if the power is added in the range - we make a test for less than uMin or more than uMax.

If anyone is interested:

Ix. Application impact.

So, we have a calculated impact, and our task is to apply it. To do this, the total cycle works with a frequency of 50 Hz. On the even cycle - measurement and calculation is made, on the odd - application of the impact. Thus, the general scheme is: power is set, measurement and calculation are performed through one sine wave, and one through the use of a new one.

X. Underwater stones.

Compared to the difference scheme, there are very few pitfalls in the direct scheme, here is a list of those I have seen:

• Dimensioning . The most important and most common mistake. You can not just take U = K * (Err + Ki * Int + Kd * Diff), without specifying WHAT is K, Ki, Kd. And with what accuracy. Especially important for the coefficient Ki, which has the dimension of the inverse of time - if the operation goes in integers, DO NOT simply multiply by it - since there must be a DIVISION, and the reverse number in integers is not representable.
• Accounting sign . The second is very important - taking into account the sign. All operations must be signed, the integral must accumulate a significant one, since it not only replaces the proportional component, but also allows it to resist external influences, for example, the heat generation of the mixture itself; and then his sign is negative.
• Overflow accounting . It is important for us to get either power from 0% to 100%, or the fact that the calculated power is more than 100% or less than 0%. There is no need to do all the calculations if we get a negative jump result, for example. But at the same time it is important to take into account that during the creation-addition an overflow can occur - and it should be taken into account as “more than 100%”, and in no way leave the result after the overflow. This is fraught primarily with the lack of regulation when it is required - the object is below the required temperature, and power is not supplied
• Accounting time calculations . The need for large-scale multiplications (with the implementation curve - also division) takes time, so it is extremely important to calculate the execution time of the worst version of the calculations, and it should be less than the free time between measurements. Failure to comply with this condition leads to an unmanaged object that “seems to work, but somehow not so

Xi. Findings.

As a result, the direct implementation scheme does not have the problems that the difference scheme has , but it requires more computational costs. However, with proper implementation, the direct scheme is quite applicable even on cheap 8-bit microcontrollers, and gives more predictable results.