Daily Solar Yield - Input Power with Efficiency Loss

[Roving-Ronin]

Just looking at the 'Input Power with Efficiency Loss' calculation at: https://github.com/wlcrs/huawei_solar/wiki/Daily-Solar-Yield#a-better-approach and thinking that this rather rough in its calculation, given its only using arbitrary weightings (98% / 95% / 90%). Thinking that since the integration provides access to the actual efficiency ratings of the inverter(s) that this sensor could be better calculated by calling the input power of the inverter and applying the actual / live efficiency rating of the inverter (as the inverter is calculating at that moment).

Throwing it out there for feedback and suggestions if this sensor would be more accurate if it was calculated using the following, instead of the version at the above URL:

  # Shows 'Daily Solar Yield' being the yield of your solar panels, minus any efficiency losses by the inverter
  # See: https://github.com/wlcrs/huawei_solar/wiki/Daily-Solar-Yield
  - sensor:
    - name: "Inverters Input Power with Efficiency Loss"
      unique_id: inverters_input_power_with_efficiency_loss
      unit_of_measurement: "W"
      device_class: power
      state_class: measurement
      state: >
        {% set inverter1_input_with_efficiency_loss = (states('sensor.inverter_efficiency_1') | float(0) /100) * states('sensor.inverter_input_power_1') | float(0) %}
        {% set inverter2_input_with_efficiency_loss = (states('sensor.inverter_efficiency_2') | float(0) /100) * states('sensor.inverter_input_power_2') | float(0) %}
        {{ (inverter1_input_with_efficiency_loss + inverter2_input_with_efficiency_loss) | round(2) }}

Note: Each inverter is calculated individually to ensure maximum accuracy, verses multiplying the combined input power by an averaged efficiency rating (that would also be open to error if one inverter is operating below efficiency, in which case the average efficieny would give an incorrect reading for the other inverter(s) in a cascade.

Also would users prefer to see a sensor for each inverters' input power with efficiency loss and then a seperate sensor that sums up the total of the individual inverters efficiency with loss, that would allow seeing the individual outputs and recording their individual statistics (in case of needing to fault find etc) in addition to the sensor showing the sum of all inverters (to use in dashboards etc) ?

Tagging some people who have shown interest in this sensor before:
@JohnMcLear
@graphistudio
@heinemannj

[JensenNick]

As an alternativ to the above sensors I've created two custom sensors based om the efficiency graps from the datasheets - one sensor for the M1 (3 phase inverter) and one for the L1 (single phase inverter). I'll explain how the functions have been created when I have a bit more time.

One more thing... I've had very poor conditions to do any testing, but from what I've seen they seem to behave correctly.

Ideally would maybe be to use the sensor providing the actual voltage, but the voltage is naturally provided pr. string so going down this route would then mean you'd have to create a sensor for the input power pr. string.

The sensor for M1 inverters.

    sensor:
      - name: "Power Inverter M1"
        unique_id: power_inverter_m1
        unit_of_measurement: W
        device_class: power
        state_class: measurement
        state: >
          {% set inverter_rating = 10000 %}
          {% set overall_factor = 1.00 %}
          {% set operating_voltage = 600 %}
          {% set input_power = states('sensor.inverter_input_power') | float(0) %}
          {% set load_factor = ( input_power / inverter_rating * 100 ) | float(0) %}
          {% set efficiency = (98.5 / (1 + 0.082 * e**(-0.145 * load_factor))) | float(0) %}
          {% if operating_voltage < 600 %}
            {% set voltage_factor = (
            ( -0.0077 * operating_voltage + 4.6154 ) * 
            ( -0.705 / ( 1 - 0.56 * e**( -0.05 * load_factor)))
            ) | float(0) %}
          {% elif operating_voltage > 600 %}
          {% set voltage_factor = (
            ( 0.004 * operating_voltage - 2.4 ) * 
            ( -0.587 / ( 1 - 0.845 * e**( -0.05 * load_factor)))
            ) | float(0) %}
          {% else %}
            {% set voltage_factor = 0 %}
          {% endif %}
            {{ (( overall_factor * input_power * (efficiency + voltage_factor) / 100) | float(0) ) | int }}
        availability: >
          {{ has_value('sensor.inverter_input_power') }}

The sensor for the L1 inverters.

    sensor:
      - name: "Power Inverter L1"
        unique_id: power_inverter_l1
        unit_of_measurement: W
        device_class: power
        state_class: measurement
        state: >
          {% set inverter_rating = 3000 %}
          {% set overall_factor = 1.00 %}
          {% set operating_voltage = 360 %}
          {% set input_power = states('sensor.inverter_input_power_2') | float(0) %}
          {% set load_factor = ( input_power / inverter_rating * 100 ) | float(0) %}
          {% set efficiency = ( 98.25 / (1 + 0.11 * e**(-0.18 * load_factor))) | float(0) %}
          {% if operating_voltage < 360 %}
            {% set voltage_factor = (
            ( -0.01 * operating_voltage + 3.6 ) * 
            ( -1.04 / ( 1 - 0.68 * e**( -0.07 * load_factor)))
            ) | float(0) %}
          {% elif operating_voltage > 360 %}
            {% set voltage_factor = (
            ( 0.0083 * operating_voltage + 3 ) * 
            ( -0.5 / ( 1 - 0.89 * e**( -0.04 * load_factor)))
            ) | float(0) %}
          {% else %}
            {% set voltage_factor = 0 %}
          {% endif %}
            {{ (( overall_factor * input_power * (efficiency + voltage_factor) / 100 ) | float(0) ) | int }}
        availability: >
          {{ has_value('sensor.inverter_input_power_2') }}

[JensenNick]

@Roving-Ronin I've been looking at the inverter efficiency numbers and if you have a battery connected to the inverter, the efficiency is not correct (it shows 100% all the time). At least this is my firsthand experience. Don't know if others have a different experience.

[Roving-Ronin]

@JensenNick
Unfortunately I can't confirm, not having a LUNA battery ($$$$) :-(
Just wondering though re the operating_voltage = 600, I assume that's referring to the PV Input voltage ? If so, just wondering how that goes versus the inverters are made to work up to 1,000V (its only Australia to hobbles them in residential installs to PV strings of up to 600V)?

BTW if you have a LUNA, any chance you might be interested in assisting testing and mapping out the HA entities to use with the SunSynk Power Flow card? I've got most of them worked out, just need someone to double check the entity names (using the standard names that WLCRS creates), flag entities missing (i.e. that derived sensors are needed for) and confirm the LUNA entities?

slipx06/sunsynk-power-flow-card#135 (comment)

Trying to get it all mapped out, so a default config for Huawei inverters can be published, allowing WLCRS users to go there and just copy and paste it into a HA card and be 95% up and running (5% being adding their own AUX / Non-Essential loads in).

[JensenNick]

@Roving-Ronin Happy New Year :-). The operating_voltage in the provided sensor is merely used as a correction factor (manual input). I realize the chalanges here (I myself have two unequal strings on my M1). Set to 600V / 360V respectively the voltage_factor will return "0" as in no correction of the efficiency. If operating_voltage is set to another value, the voltage_factor will return a reduction of the efficiency. If the operating_voltage is set to one of the voltages apparent on the data sheet (260/480V on L1 and 470/850V on the M1) it will return a reduction corresponding to the reduction apparent on the data sheet (blue and grey curve in data sheet / green and orange curve in Desmos). For simplicity I use a linear interpolation between those points, which then also is valid outside this range.

All the functions are my best approximation based on a conversion of the data sheet graphs to datapoints in AutoCAD, an analyze in GeoGebra and the above final adjustment/check in Desmos. I was considering limiting the input to the inverter operating voltage (90-560V for the L1 and 180-980V for the M1), but decided not to (the max input voltage is 1100V by the way. The M1 will not operate above 980V but you could put in that value as operating_voltage :-) ).

I was considering using the voltage sensor provided but this introduces some challenges. 1) You'd need a power sensor pr. string / you can't use the provided input power sensor. 2) A quick glance at the voltage and current sensors left me in doubt if it would be as simple just to multiply these inputs to get the input power pr. string. 3) Still uncertanties about the reduction outside / between the known values. 4) What would be the correct way of calcutating the overall efficiency - none of the strings can provide 100% load. 2 egual strings will never go beyond 50%... lots of detailed complexity.

I'd really like to help with the SunSynk, but my time is limited and right now I prioritize to update the PEES sensors and the readme, so they work with the above and incorporate the new options to discharge to grid. Next on my list is automation for charging battery based on production forecast, average consumption, and electricity prices. Next I guess an automation which sends yield to grid when the electricity prices are high during a day, but makes sure to charge your battery fully based on the forecast for the rest of the day.

What I do know though is that the naming convention has been changed. If you have more than one inverter, it and the power meter and the battery no longer gets the "_1" naming. Your slave though still gets the "_2" naming.