Dynamic Export Limitation Automation

[Robert-2669]

Hi Guys,

Here in "Show and Tell", I would like to share an automation I'm working on, to limit the export of my PV power to the Grid.
Besides the goal of having this automation, it was also about understanding how this stuff all works.
I have fully documented all steps of my automation and also added my thoughts and issues I ran into. So its 95% comments and 5% code. So hopefully others can benefit from this as well.
Below I have also included a screenshot of my DashBoard to visualize all that is going on. Keep in mind that all is still work in progress.

I would appreciate any feedback, on what I have done including suggestions for improvements, questions or just point out where I completly went bonkers.

Regards,
Robert

Here we go...

# Based on an automation script shared by Gronaldo on Tweakers :-)
# Gronaldo's automation works fine, but I made some optimizations and added a few comments ;-)

# Goals and automation philosophy of this automation:
#   - Maximize self-consumption by minimizing export to the Grid.
#   - Mitigation of common integration or Inverter errors.
#   - Automation should do nothing if there is nothing meaningful to do. (Be Lazy!)
#   - Code readability above efficiency in speed or size.
#   - Main steps visible on a DashBoard (In Progress)
#   - Automation fully documented.
#   - Thoughts & Options mentioned.
#
# Note: This Automation can't compete with the native SolarEdge solution including InLine Meter as that will operate near real-time.

alias: SolarEdge Dynamic Export Limitation
description: Dynamic control of SolarEdge export limit with direct commit

# [POSSIBLE TRIGGER STRATEGIES]
# A: Often used strategy is to use random trigger every x seconds
#   - When triggered currently known Grid Power and PV Power are used for calculations. Depending on polling intervals these values can already be > 3sec old and 5 sec apart.
#   - It does technically work somehow, but it's the worst possible strategy.
#   - Polling: (P1 5s / ModBus 5s)
# B: Trigger on the P1 meter.
#   - This guarantees that the actual Grid Power value is used for the calculations and that only the PV Power value can be dated.
#   - Use threshold option to define deadband.
#   - Polling: (P1 5s / ModBus 5s)
# C: Trigger on the P1 meter & Update PV Power value.
#   - Once triggered the first action would be to refresh the PV Power value via (button.garage_solaredge_refresh). This is the most logical strategy.
#     However, it seems the HA orchestrator introduces accumulative delays when repeated rendering it less usable. (Self-Protection?)
#        - Crated an automation to measure these accumulative delays.
#   - Polling: (P1 5s / ModBus 300s)
# D: [CURRENT STRATEGY] Same as C but with 2sec ModBus interval.
#   - With 2sec interval, the PV Power value is max 2sec old (Reasonable compromise)
#     - 1sec interval fails (for me) as soon as APL value gets changed.
# E: (To Test) Trigger based on changing PV Power value.
#   - Check if forcing update of P1 sensors gives the same delay penalties.

# [CURRENT TRIGGER]
# The P1 meter value is read every 5s by the standard HomeWizard integration, so this determines the interval of this Automation.
# The Automation is only triggered if the current Grid Power goes outside the given DeadBand. No triggers are fired while within the DeadBand.
#   - This guarantees that the Grid Power value is actual.
#   - Deadband values can be chosen as desired as long as the gap is wider than the smallest Power Delta of your Inverter.
#   - A wider deadband means less APL corrections are required.
# Note: When home appliances are running the power draw can fluctuate a lot with many small changes. So it's better to keep the DeadBand a bit wide.
# Note: If APL is set to say 2500W it will actually drift +/- 0,1% (+/- 25W) on my inverter.

triggers:
  - trigger: power.changed
    target:
      entity_id: sensor.p1_meter_power
    options:
      threshold:
        type: outside
        value_min:
          active_choice: number
          unit_of_measurement: W
          number: -100
        value_max:
          active_choice: number
          unit_of_measurement: W
          number: 0

conditions:

  # [OPTIONAL / DASHBAORD]
  # Boolean Helper added as a condition so the automation can be enabled/disabled from the dashboard via toggle switch.
  #   Note: Disabling will not restore APL to 100% (By design for testing purposes)
  #
  - condition: state
    entity_id: input_boolean.solaredge_export_beperking_enabled
    state:
      - "on"

  # [CONDITION] Automation will not run if the Inverter sensor states are unavailable due to Integration or Inverter Error
  #   - This prevents calculations with missing sensor data.
  # Note: ModBus Multi updates all sensors in one burst: if AC Power is available, all other entities are available too.
  #
  - condition: template
    value_template: >
      {{ states('sensor.garage_solaredge_ac_power') not in ['unavailable', 'unknown', 'none'] }}

  # [CONDITION] Automation will only run when the inverter has status "THROTTLED" or "MPPT".
  #   - It would be pointless to run if the inverter has the status "SLEEPING".
  #
  - condition: state
    entity_id: sensor.garage_solaredge_status
    state:
      - I_STATUS_THROTTLED
      - I_STATUS_MPPT

actions:

  # Get ACTUAL AC Power value from Inverter. (The biggest challenge here)
  #   - To be able to make an accurate calculation, the ACTUAL AC_Power value from the Inverter is required. 

  # [REFRESH STRATEGY OPTIONS]
  #   => This is the biggest challenge for this Automation.
  #
  #   A: Refresh now & wait for change doesn't work as needed. (ModBus Polling interval lowerd to 100s)
  #     -  HA doesn't seem to like out of band reads/writes.
  #   B: Use wide DeadBand to minimize updates and use Refresh now anyhow.
  #     - Still to be tested.
  #   C: [CURRENT STRATEGY] Polling Interval reduced to 2s and accept PV_Power value can be up to 2sec old.
  #     - 1s interval breaks when starting to change APL values (2sec is stable on my system)



  # ==================================================================
  #[STRATEGY A] Doesn't work as expected :-(
  #   - Left here for further review/follow-up
  #
  # Capture the current last_updated timestamp before the update_entity call.
  #   - After the update we wait until this value changes, ensuring ModBus Multi has fetched a fresh values before all calculations.
  #
  #- variables:
  #    PV_Last_Updated: "{{ states.sensor.garage_solaredge_ac_power.last_updated | as_timestamp }}"
  #
  # Force an update of the current PV power so we can calculate with up-to-date values.
  #   - ModBus Multi updates all sensors simultaneously in one ModBus-poll burst.
  #
  #- action: button.press
  #  target:
  #    entity_id: button.garage_solaredge_refresh
  #
  # [WAIT FOR UPDATE]
  # Wait until last_updated changes: proof that the new values have been received.
  #   - Timeout of 2000ms as fallback for a slow bus; continue_on_timeout: true so the automation does not stop on timeout but continues with the last known values.
  #   - In theory this (should) complete faster than 1000ms.
  #
  # [ISSUE]: Quite often the sensor is not updated within 2000ms. Delays can even go above 6sec.
  #
  #- wait_template: "{{ states.sensor.garage_solaredge_ac_power.last_updated | as_timestamp > PV_Last_Updated }}"
  #  timeout:
  #    milliseconds: 2000
  #  continue_on_timeout: true
  # ==================================================================

  - variables:

     # For the calculations -50W Grid Power (export) is used as the target value. Right in the middle of the Deadband.
     # The DeadBand as defined within the Trigger and the width need to be matched (DeadBand > Min. Step)
     # 
     Targeted_Grid_Power: -50

     # The inverter's maximum power is required for calculation the new APL value. The rated power is often ~105% of nominal. So SE5K = 5250W.
     # At an APL setting of 50%, the inverter's power output will be limited to ~2625W.
     # The smallest possible APL step is therefor 52.5W (1% of 5250).
     #
     Inverter_Power_Rating: 5250
     
     # Active Power Limit can be set between 0% and 100%.
     #    Note: Min set to 1% as the Inverter seems to stick to 0% for a long time once it gets there for some reason.
     #    Note: When Inverter Status shows "THROTTLED", the inverter is actually limiting power output.
     #
     Min_APL_Limit: 1
     Max_APL_Limit: 100

     # According to SE documentation every inverter can switch between 0% and 100% within 2s.
     # Max_APL_Delta can be limited here if required. Intentionally set to 99% here for testing purposes (effectively disabled).
     #
     Max_APL_Delta: 99

     # Dynamic minimum PV value.
     # Not essential, but a safeguard if calculations go wrong so the PV Power stays > standby consumption of the house.
     #  Note: 4% (~210W) chosen as this matches the minimum power consumption of my house when absent.
     #  Note: Same can actually be achieved by setting (Min_APL_Limit = 4). (Future Optimalization?)
     #
     Min_PV_Power: "{{ Inverter_Power_Rating * 0.04 }}"

     # [ACTUAL CALLCULATIONS]
     # The actual calculations for this automation are here below. Calculations could be combined, but that would reduce readability.
     #  Note: Script efficiency isn't relevant as it runs only once per 5 sec.
 
     # Get the current Grid Power from the P1 meter. 
     #  Note: The HomeWizard meter returns a negative value when feeding back to the grid.
     #
     Current_Grid_Power: "{{ states('sensor.p1_meter_power') | float(0) }}"

     # Get current APL Limit
     # [V5 Safety #1] Fallback changed from float(0) to float(100).
     # With float(0) the Max_APL_Delta clamp became [-99, 99], covering the full APL range and
     # completely disabling rate limiting. float(100) = no restriction, safest unknown state.
     #  - Statistically (in my setup) APL is just under 10% most of the time during the day. So, 10% would be a more suitable fallback value.
     #
     Current_APL_Limit: "{{ states('number.garage_solaredge_active_power_limit') | float(100) }}"

     # Get current PV Power
     #
     Current_PV_Power: "{{ states('sensor.garage_solaredge_ac_power') | float(0) }}"

     # Calculate the PV Power correction needed to reach the Targeted Grid Power.
     #  Note: With a lot of appliances (Car charging) running, don't be surprised if (Required Power >> Inverter_Power_Rating)
     #
     Required_PV_Power_Delta: "{{ Current_Grid_Power - Targeted_Grid_Power }}"

     # Calculate how much power the inverter must deliver to match the target export.
     #  Note: Required_PV_Power can never go negative due to max() (Mitigation)
     #  Note: Can never go lower that Min_PV_Power.
     #
     Required_PV_Power: "{{ max(Min_PV_Power, (Current_PV_Power + Required_PV_Power_Delta) | float(0)) }}"

     # Calculate what the new APL limit should be in x.xxx%.
     #
     Raw_Target_APL_Limit: "{{ Required_PV_Power / Inverter_Power_Rating * 100 }}"

     # Ensure the APL limit always stays between defined Min & Max APL Limits.
     #
     Clamped_Target_APL_Limit: "{{ clamp(Raw_Target_APL_Limit | float(0), Min_APL_Limit, Max_APL_Limit) }}"

     # Ensures the maximum APL delta per cycle is limited to the defined Max_APL_Delta value
     #  - Now set to 99% effectively disabling this step.
     #
     Stepped_APL_Limit: "{{ clamp(Clamped_Target_APL_Limit, Current_APL_Limit - Max_APL_Delta, Current_APL_Limit + Max_APL_Delta) }}"

     # New APL_Limit rounded to whole percent.
     #
     New_APL_Limit: "{{ Stepped_APL_Limit | round(0) }}"

     # [OPTIONAL / DASHBAORD]
     #  - APL Delta indicator.
     #
     New_APL_Delta: "{{ New_APL_Limit - Current_APL_Limit }}"

  # [CONDITION] Automation will only execute if there is actualy a change to the APL limit.
  #     - Prevents unnecessary Modbus load and wear on the commit counter.
  #
  - condition: template
    value_template: "{{ (New_APL_Limit - Current_APL_Limit) | abs >= 1 }}"

  # [CONDITION] Automation will only increase APL_Limit if there is actually more PV Power available.
  #     - Inverter Status MPPT --> Inverter is already providing max PV Power (Increasing APL% would be pointless)
  #     - Inverter Status THROTTLED & APL<100% --> Additional power can be delivered. (How much can't be determined as far as I know)
  # Note: Decreasing APL_Limit remains obviously possible in all cases.
  #
  - condition: template
    value_template: "{{ not (states('sensor.garage_solaredge_status') == 'I_STATUS_MPPT' and Current_APL_Limit < 100 and New_APL_Limit > Current_APL_Limit) }}"

  # [EXECUTE ACTIONS]
  # Execute actions with the calculated variables.
  #

  # [UPDATE APL LIMIT]
  # Update the APL limit to the new value.
  #   Note: After changing the APL limit a commit is required to make it effective. (See below)
  #
  - target:
      entity_id: number.garage_solaredge_active_power_limit
    data:
      value: "{{ New_APL_Limit }}"
    action: number.set_value

  # [OPTIONAL / DASHBAORD]
  #   - HeartBeat indicator on DashBoard. (A separate automation turns the boolean off again after 500ms, so visible as a short pulse.)
  #   - Show Required APL Delta
  #   - Show Required PV Power
  #   - Show Required PV Delta
  #
  - action: input_boolean.turn_on
    target:
      entity_id: input_boolean.solaredge_apl_heartbeat

  - target:
      entity_id: input_number.solaredge_apl_delta
    data:
      value: "{{ New_APL_Delta }}"
    action: input_number.set_value

  - target:
      entity_id: input_number.solaredge_required_pv_power
    data:
      value: "{{ Required_PV_Power }}"
    action: input_number.set_value

  - target:
      entity_id: input_number.solaredge_required_pv_delta
    data:
      value: "{{ Required_PV_Power_Delta }}"
    action: input_number.set_value

  # [DELAY]
  # A delay is required between setting the new APL value and pressing commit.
  #   - A 500ms delay before the commit. Reason: number.set_value returns as soon as HA has queued the Modbus write, not when the inverter has actually received the value.
  #     Per the SunSpec Technical Note (Appendix B), write response time is < 500ms. The delay should ensure the inverter has acknowledged the APL value change before the commit is sent.
  #
  - delay:
      milliseconds: 500

  # [COMMIT]
  # A commit is mandatory for static writes to take effect.
  #   - (SunSpec Technical Note: "You need to follow static write commands with a commit.")
  #  
  - target:
      entity_id: button.garage_solaredge_commit_power_settings
    action: button.press

  # [AUTOMATION COOLDOWN]
  #   - This delay actually just blocks the starting of an other instance to ensure the Inverter has time to change it's power output. 
  # P1 updates every 5s so no trigger should arrive sooner.
  #   - Per SunSpec Technical Note (Appendix B):
  #     - Commit reaction time < 1.5s
  #     - Active power < 1s.
  # Without this delay the cycle completes in ~2.5s, leaving ~2.5s before the next trigger well above the 1.5s reaction time. Safe to remove; kept for conservative margin.
  #
  - delay:
      seconds: 3

# Single mode will block another new instance from starting while the current session is still running.
#
mode: single

And a Screenshot of my DashBoard from just now: (Work in progress)

[UrbanOlsson]

Interesting! Polling every 2 seconds, I assume your inverter is connected via ethernet and not wifi?

[Robert-2669]

That is correct.
I would always recommend wired over wireless. If possible..