Add an adaptative regulation in over climate mode

[jmcollin78]

Following a discussion in #125 issue, we need a regulation for over climate mode. This regulation should:

1. take care of temperature sensor in the room,
2. adapt the target temperature by adding / substracing a value if the temp room is under / over the target temperature.

So regulation can be done by VTherm using the target temperature value and adapting it constently.

Some PI (proportionnel-intégral) algorithm seems to be exactly what is needed for this.

[maia]

Thanks. I suggest a development in two phases:

1. Add a configuration option for a constant offset value: underlying target temp = vtherm temp + offset. This allows to adjust for differences between the temperature measured internally by the TRV and the room temperature, preventing a constant over- or underheating. For example, my living room is overheated by 1,0°C on average, so I would set the offset at 1°C, so when I set the VTherm target temp to 21°, the TRV is sent a target temp of 20°C and as it's wrongly calibrated it will heat the room to 21°C.
2. Develop an algorithm (e.g. based on bayesian time series models, regression,…) that constantly compare the sensor data to adjust the offset explained above.

The second phase is most likely much more work (and might not be ready for this winter?)

[jmcollin78]

Yep. Will see that.

[Ra72xx]

If you add some kind of own mechanism to control the way the thermostat tries to reach target temperature, could you please nevertheless retain the current mode in which the thermostat does this with its own algorithms?
In fact, this is the main reason I prefer VT over Better Thermostat: VT currently does not mess with the internal algorithms of the thermostat but assumes that the thermostat knows best what regulations have to be done to reach the target temperature to which it is set and which is also visible and controllable on the hardware.

[maia]

In my understanding this feature would only calculate a long term (days, weeks) offset between target temp and room temp and allow to adjust for that by sending the TRV a slightly lower/higher target temp. But of course it should not change the way how a TRV achieves the goal of a certain target temperature.

[jmcollin78]

That is what I intend to do @Ra72xx.

[jebeke65]

This might also solve my issue. I have a innova 2.0, used as AC heater. The temperature sensor is very inaccurate as it's withing the heater and can't be moved outside.
If you set the target temp e.g. to 24deg then it quite soon stops heating as the internal temp sensor reaches 24deg, although the temp sensor that gives the real temp, is only showin e.g. 20deg. As long as the wanted temp is not reached on the temp sensor, it should keep heating by e.g. increasing the target temp to "internal temp sensor + x", where the x is driven by how fast you want to have it increased. As the innova 2.0 is driven by a heat pump, this might take some time. There is also an internal resistor/heater that is switched on if the difference between the targettemp and the internal temp sensor is too big. If you have time enough to wait (no boost needed), then one can gradually increase the room temp.

Would like to be able to control this behaviour on top of the underlying thermostat (here the innova 2.0) and I think this component is already doing a great thing.

[jmcollin78]

Development is starting.
What I intend to do is the following:

1. add an option to enable auto-regulation with 3 modes: light, medium, strong,
2. each option will have a set of parameter which will have influence on the algorithm: offset max, kp, ki
3. the algorithm is a PI (Proportional and Integral) which is a cycle based algorithm that is based on this method:

# pylint: disable=line-too-long
""" The PI algorithm implementation """

class RegulateurTemperature:
    """ A class implementing a PI Algorithm
    PI algorithms calculate a target temperature by adding an offset which is calculating as follow:
    - offset = kp * error + ki * accumulated_error

    To use it you must:
    - instanciate the class and gives the algorithm parameters: kp, ki, offset_max, stabilization_threshold, accumulated_error_threshold
    """

    def __init__(self, target_temperature, kp, ki, k_ext, offset_max, stabilization_threshold, accumulated_error_threshold):
        self.target_temperature = target_temperature
        self.kp = kp  # proportionnel gain
        self.ki = ki  # integral gain
        self.k_ext = k_ext # exterior gain
        self.offset_max = offset_max
        self.stabilization_threshold = stabilization_threshold
        self.accumulated_error = 0
        self.accumulated_error_threshold = accumulated_error_threshold

    def set_target_temperature(self, target_temperature):
        """ Set the new target_temperature"""
        self.target_temperature = target_temperature
        self.accumulated_error = 0

    def ajuster_target_temperature(self, internal_temp, external_temp): # pylint: disable=unused-argument
        """ Calculate a new target_temperature given some temperature"""
        # Calculate the error factor (P)
        error = self.target_temperature - internal_temp

        # Calculate the sum of error (I)
        self.accumulated_error += error

        # Capping of the error
        self.accumulated_error = min(self.accumulated_error_threshold, max(-self.accumulated_error_threshold, self.accumulated_error))

        # Calculate the offset (proportionnel + intégral)
        offset = self.kp * error + self.ki * self.accumulated_error
        # Capping of the offset
        offset = min(self.offset_max, max(-self.offset_max, offset))


        # Calculate the exterior offset
        offset_ext = self.k_ext * (external_temp - internal_temp)
        # Capping of offset_ext
        offset_ext = min(self.offset_max, max(-self.offset_max, offset_ext))

        # print(f"error: {error} accumulated_error: {self.accumulated_error}, offset: {offset}")

        # If temperature is near the target_temp, reset the accumulated_error
        if abs(error) < self.stabilization_threshold:
            # print("Stabilisation")
            self.accumulated_error = 0

        return self.target_temperature + offset + offset_ext

It calculates an offset (ajustement in French) which is the combinaison of the error (P) and the integral of the error (I).

4. at each cycle, I will calculate the target (consigne in French) + offset, store this into a new auto_regulated_target_temperature and send this new target to the underlying device.
5. Depending on the auto-regulation mode, the 4 parameters will have default values:

        self.kp = kp  # Gain proportionnel
        self.ki = ki  # Gain intégral
        self.offset_max = offset_max. # The max offset allowed
        self.seuil_stabilisation = seuil_stabilisation # The stabilization threshold 

6. I keep all current attributes like target_temperature (not auto-regulated)

Any comments on the plan would be greatly appreciated if any !.

NOTE: this will be available only in over_climate mode.

[maia]

Thanks a lot for working on it. I can't yet understand the code as I don't speak french and will need to get google translate to translate your code (isn't there a ChatGPT kinda tool that allows code translation? I would hope so). But I'd appreciate it if I could also define a manual offset that is not adjusted at all. And by the way, the outdoor temperature most likely has a strong influence on the offset. The colder it is outside, the higher the difference between the temperature measured at the radiator and the temperature measured in the middle of the room.

But as an initial question: What is a "cycle"? Is a cycle something that happens every few minutes or hours or days?

[jmcollin78]

What is a "cycle"? Is a cycle something that happens every few minutes or hours or days?

yes.

I will translate the algorithm now and post it with English variables names.

[maia]

Haha, so is a cycle minutes, hours or days? :)