Flexible deferrable loads

[RikBast]

Hi All,

I am working on a kind of flexible deferrable load programming. What I want to do is define a deferrable load window say between 20:00 - 06:00 (the next day) runtime 6h and load of 2150 W. I have made a gui in HA for that with on/off boolean. So the moment I switch on this window, EMHASS will calculate in that time window the optimal 6h for the deferrable to operate, I use MPC. I have the start time (20:00) in timesteps and the end time in timesteps (06:00), there is a battery in the PV system.

What I do now is the following:

When enough data are available I run a day-ahead and store the data with dh_ prefix, that happens when I switch on the deferrable0 load (there is an automation made for it). I take the dh_p_deferrable0 array and look up the timeslot where the deferrable goes from 0 to a positive value, that's my real start time of the deferrable0, then I look up the timeslot where the deferrable0 goes from positive to 0, that's my real end time. Those two timeslots I store in 2 helpers: input_text.deferrable0_start_time and input_text.deferrable0_end_time, so the are fixed. Then MPC takes over with input_text.deferrable0_start_time and input_text.deferrable0_end_time as runtime for the timesteps, I don't want to change those values anymore. I run MPC every five minutes an store those data as wel with mpc_ prefix.

I see the following when running MPC: deferrable load keeps on shifting forward during the rolling window which I have. So start and end time shift also and my decreasing deferrable0 hour sensor will not start to decrease. That's the reason I use the start and end time from the day_ahead optimization which is run once. I now run it manually again to synchronize the day_ahead and mpc deferrable0 hours. I hope there is an easier way to accomplish my goals. I can share yaml when needed. Or is the shifting deferrable0 hours a bug in MPC? I can't tell. Any help is appreciated here.

[scruysberghs]

Do you pass the current_state(s) for the deferrable load(s) to mpc? It is the way to tell mpc the current deferrable load is active and in my exprience should stop the postponing you see.

Other than that, are you are sure you start and end_time to step translations is correct? I mean, you are sure your runtime parameters are correct is a way that start_timesteps_of_each_deferrable_load will be zero for your deferrable load when you are in the defined timerange 20-6 and it doesn't shift to 20:00 the next day.

[RikBast]

This is my runtime for the deferrable , for now only 1 deferrable, which can run from 20:00 - 06:00. This is the input at 21:00:

'num_def_loads': 2, 'P_deferrable_nom': [2150, 0], 'def_total_hours': [4, 0], 'treat_def_as_semi_cont': [1, 1], 'set_def_constant': [1, 1], 'def_start_timestep': [-2, 0], 'def_end_timestep': [18, 0]

So def_start_timestep = -2 (2x 30 min) = 20:00, def_end_timestep = 18 (9x 30 min) = 06:00 (next day)

Deferrable will start at 1:00 and run for 4h:

Seems all good to me? Or...

[scruysberghs]

I think you should add def_current_state for every def load as runtime paramter. I use input booleans from home assistant for that that switch together with the actual loads from the automations.

          "num_def_loads": 4,
            "operating_hours_of_each_deferrable_load": [2, 0, 0, 1],
            "def_current_state": [false, false, false, false],
            "nominal_power_of_deferrable_loads": [600.0, 0.0, 1000.0, 1300.0],
            "start_timesteps_of_each_deferrable_load": [0, 0, 0, 0],
            "end_timesteps_of_each_deferrable_load": [0, 0, 0, 0],
            "treat_deferrable_load_as_semi_cont": [true, false, true, true],
            "set_deferrable_load_single_constant": [true, false, true, true],
            *"set_deferrable_startup_penalty": [0, 0, 0, 0],

I use this template : {% set current_states = loads | map('string') | map('regex_replace', '^', 'input_boolean.deferrable') | map('regex_replace', '$', '_current_state') | map('states') | map('replace', 'on', 'true') | map('replace', 'off', 'false') %}

[scruysberghs]

Full template:

              "num_def_loads": 4,
              {% set loads = [0, 1, 2, 3] %}
              {% set op_hours = loads | map('string') | map('regex_replace', '^', 'input_number.deferrable') | map('regex_replace', '$', '_operating_hours') | map('states') | map('int') | list %}
              {% set current_states = loads | map('string') | map('regex_replace', '^', 'input_boolean.deferrable') | map('regex_replace', '$', '_current_state') | map('states') | map('replace', 'on', 'true') | map('replace', 'off', 'false') %}
              {% set nominal_powers = loads | map('string') | map('regex_replace', '^', 'input_number.deferrable') | map('regex_replace', '$', '_nominal_power') | map('states') | map('float') | list %}
              {% set start_timesteps = loads | map('string') | map('regex_replace', '^', 'input_number.deferrable') | map('regex_replace', '$', '_start_timestep') | map('states') | map('int') | list %}
              {% set end_timesteps = loads | map('string') | map('regex_replace', '^', 'input_number.deferrable') | map('regex_replace', '$', '_end_timestep') | map('states') | map('int') | list %}
              {% set semi_cont = loads | map('string') | map('regex_replace', '^', 'input_boolean.deferrable') | map('regex_replace', '$', '_semi_cont') | map('states') | map('replace', 'on', 'true') | map('replace', 'off', 'false') %}
              {% set single_constant = loads | map('string') | map('regex_replace', '^', 'input_boolean.deferrable') | map('regex_replace', '$', '_single_constant') | map('states') | map('replace', 'on', 'true') | map('replace', 'off', 'false') %}
              {% set startup_penalty = loads | map('string') | map('regex_replace', '^', 'input_number.deferrable') | map('regex_replace', '$', '_startup_penalty') | map('states') | map('int') | list %}
                "operating_hours_of_each_deferrable_load": {{ op_hours }},
                "def_current_state": [{{ current_states | join(', ') }}],
                "nominal_power_of_deferrable_loads": {{ nominal_powers }},
                "start_timesteps_of_each_deferrable_load": {{ start_timesteps }},
                "end_timesteps_of_each_deferrable_load": {{ end_timesteps }},
                "treat_deferrable_load_as_semi_cont": [{{ semi_cont | join(', ') }}],
                "set_deferrable_load_single_constant": [{{ single_constant | join(', ') }}],
                "set_deferrable_startup_penalty": {{ startup_penalty }},

[RikBast]

Hi, thank you for this. I added def_current_state as run time now. However I can't see how this will prevent the shifting of the deferrable? I am going to try it and see if the postponing stops.

Another question: how do you cope with 'operating_hours_of_each_deferrable_load', I generated some yaml which counts down to zero as time progresses, otherwise if operating_hours_of_each_deferrable_load remains a constant I get ' Infeasible ' outcome.

[scruysberghs]

I use templates to set operating hours, nominal power and start/end timestep dynamicly

[RikBast]

So you run your deferrables at already known begin- and end times? So for example from 8:00-10.00 for 2h. Then EMHASS will calculate the optimal schedule ' around ' this deferrable? I hope I am correct here. My idea is to define a time frame from 20:00 - 06.00 and runtime 6h and let EMHASS decide what the most optimal time frame is. This does not really work as the deferrable time starts shifting with a rolling window using mpc.