TPI output is linear, but TRV valve behavior is intentionally non-linear

[maia]

I am using TPI with radiator valves (Sonoff TRVZB) and I have a question about the link between the TPI output and the real valve effect. In VTherm TPI appears to represent a linear power model.

From my (non-expert) reading, thermostatic radiator valves are intentionally not designed to be linear. They are often described as having an “equal percentage” valve characteristic. This means that each similar increase in valve opening leads to a similar relative increase in water flow. As a result, the flow rises very quickly in the lower and middle opening range. In practice, a change like +10% valve opening can already produce a much larger change in flow, and an opening that looks like “medium” (around 50%) can already deliver most of the available heating power.

If this understanding is roughly correct, a linear TPI output may not match the real, intentional behavior of the valve very well. When the controller outputs something like “50%”, this looks like medium power, but hydraulically the system may already be close to full power. This seems especially relevant for water-based heating systems with high thermal inertia, where this mismatch can lead to overshoot or oscillation.

Parameters like opening threshold, minimum opening and maximum opening help to tune the behavior, but the controller output itself remains linear. Because of this, some situations may still be difficult to control when the valve reacts very strongly at small openings.

I was wondering whether it could make sense to optionally introduce a simple valve-characteristic mapping between the TPI output (on_percent) and the commanded valve opening. Not a complex physical model, but a lightweight way to reflect the intentionally non-linear design of real TRVs.

For example, the user could define how strong the heating effect is at a typical mid-range opening, such as 50%. This could be a simple value like “50% opening feels like 80% heating power”, or selected via a small set of presets (for example: moderate, strong, very strong).

Internally, the TPI output could stay exactly the same, but before sending the command to the valve, the system would adjust the valve opening so that a TPI output of 50% results in the user-defined effective heating level. Values below and above 50% would be smoothly adjusted in the same way. This would keep the TPI logic unchanged, while making the valve response closer to real TRV behavior.

This may already have been discussed or there may be good reasons not to do this. I would be very interested to hear whether such an approach has been considered, and whether it could help TPI behave more predictably with real radiator systems and high thermal inertia.

[caiusseverus]

Yes this is a problem that has been discussed at some length before. Unfortunately, it's scattered around various threads relating to different problems and updates, so it's hard to find what has been written previously.

The problem is controlling an inherently non-linear device (the radiator as a whole) with a single linear variable. The algorithm outputs a power level of 0-100%, but the actual heat output of a radiator is dependent on a lot of different variables.

If the flow temperature remains constant, the power of the radiator is roughly proportional to the flow rate, for a given room temperature. The flow rate depends on the valve position (which we can control), but also the pressure difference across the radiator (which we can't) - other radiators opening and closing can affect this, as can a variable speed pump which could be mapped to maintain constant pressure or constant flow rate.

If the flow temperature also varies, either due to weather compensation (which means it will remain fairly constant in the shorter term) or by load compensation (it will change a lot in the short term depending on heating demand), then that's another variable to account for.

Even if you successfully compensate for flow temperature and flow rate, you then have the issue that the heat output of a radiator depends on the difference between average radiator temperature and room temperature - as the room heats up the power output drops, even if everything else remains constant.

It's a complex problem. Modifying the valve response to the algorithm output to make it more linearly adjust the flow rate should help quite a bit, but it won't completely cure the problem.

Part of the issue is that there are such a large variety of systems, all with their own quirks - old fashioned constant heat boilers, modern modulating condensing boilers, heat pumps, district heating systems, big radiators in small rooms, small radiators in big rooms etc.

Generalising all this into a few controls without making things horribly complicated, and in a way that actually provides some benefit over something much more basic is non-trivial. For example my sonoff trvs can maintain temperature within 0.2-0.3º using their internal bang/bang controller, so there comes a point where you are well into diminishing returns and it's just not worth the effort.

That said, I'm currently experimenting with an automation to mitigate the TRV calibration problem, and that lends itself to easy adjustment to modify the valve response so I will try it. When I have something working I'll post it here.

[altruizine]

A recent discussion of the nonlinear opening-degree–power relation took place in #1554. There, I argued that the new max-opening-degree feature is a means to limit the valve-opening range such that the relation becomes near-linear so that TPI can work better; from my experience, this works reasonably well. We also discussed how a nonlinear relation could be modeled in VT, without a clear conclusion.

Before I discuss further, a quick digression regarding terminology: Equal-percentage valve characteristics refer to a slowly opening valve. What you describe (high power at 50 %) is called a quick-opening characteristic curve [1]. The latter seems to be quite common in radiator valves, judging from your and my experience and from earlier discussions of the topic.

I like your proposal for asking the user to help shape the model curve with specifying approximate energy output at a 50 % opening degree. Even if the user's value is not exactly correct, I'd expect the model to be vastly improved, and AutoTPI to produce much better results.

If you want to experiment with nonlinear valve characteristics, you could experiment with an automation that virtualizes the valve and exposes to VT an ideal linear valve. In the discussion I mentioned, I did this for implementing a maximum opening degree before VT got the feature, but you could easily adapt this for other characteristics as well.

[1] The Engineering ToolBox on valve characteristics