Merge branch 'wills106:main' into main

Author: gec75

custom_components/solax_modbus/plugin_growatt.py

@@ -9763,12 +9763,9 @@ async def async_determineInverterType(self, hub: Any, configdict: dict[str, Any]
                 invertertype = HYBRID | GEN4 | X3  # Hybrid TL3-XH (BP) 3kW - 10kW (MOD), 11kW - 30kW (MID)
             elif seriesnumber.startswith("V"):
                 invertertype = HYBRID | GEN4 | X3  # Hybrid TL3-XH 3kW - 10kW (MOD)
-            elif seriesnumber.startswith("067"):
+            # Include additional SPF5000ES firmware branches for auto-detection (e.g. 113).
+            elif seriesnumber.startswith(("067", "113", "500")):
                 invertertype = HYBRID | SPF | X1  # Hybrid SPF 5kW
-            elif seriesnumber.startswith("500"):
-                invertertype = HYBRID | SPF | X1  # Hybrid SPF 5kW
-            # elif seriesnumber.startswith('SPA'):  invertertype = AC | GEN2 | X3 # AC SPA 4kW - 10kW Could be based SPF?
-
             else:
                 invertertype = 0
                 _LOGGER.error(f"unrecognized {hub.name} inverter type - firmware version : {seriesnumber}")

custom_components/solax_modbus/plugin_sofar.py

@@ -768,6 +768,8 @@ def value_function_sync_rtc_ymd_sofar(initval: Any, descr: Any, datadict: dict[s
             3: "Passive Mode",
             4: "Peak Cut Mode",
             5: "Off-grid Mode",
+            6: "Generator mode",
+            7: "Feed-In Priority Mode",
         },
         allowedtypes=HYBRID,
         write_method=WRITE_MULTISINGLE_MODBUS,
@@ -3587,6 +3589,8 @@ def value_function_sync_rtc_ymd_sofar(initval: Any, descr: Any, datadict: dict[s
             3: "Passive Mode",
             4: "Peak Cut Mode",
             5: "Off-grid Mode",
+            6: "Generator mode",
+            7: "Feed-In Priority Mode",
         },
         internal=True,
         allowedtypes=HYBRID,

custom_components/solax_modbus/plugin_solax.py

@@ -563,6 +563,13 @@ def autorepeat_bms_charge(datadict: dict[str, Any], battery_capacity: float, max
     except Exception:
         f = 1.0
 
+    # Near full charge rate limit
+    chargeable_soc = max(0, max_charge_soc - battery_capacity)
+    if chargeable_soc <= 4:
+        # For last few % of charge, further reduce the rate limit to account
+        # for non-ideal charging curves and reduce battery wear
+        f = f * (float(chargeable_soc + 2.0) / 6.0)
+
     # BMS charge capability approximation
     bms_a = datadict.get("bms_charge_max_current", None)
     batt_v = (
@@ -631,19 +638,92 @@ def autorepeat_function_powercontrolmode8_recompute(initval: int, descr: Any, da
 
     if power_control == "Mode 8 - PV and BAT control - Duration":
         pvlimit = setpvlimit  # import capping is done later
-    elif power_control == "Negative Injection Price":  # grid export zero; PV restricted to house_load and battery charge
-        datadict.get("measured_power", 0)  # positive for export, negative for import - for future correction purposes
-        houseload = max(0, houseload)
-        if battery_capacity >= 92:
-            pvlimit = houseload + abs(setpvlimit) * (100.0 - battery_capacity) / 15.0 + 60  # slow down charging - nearly full
-        else:
-            pvlimit = setpvlimit + houseload + 60  # inverter overhead 40
-        pvlimit = max(houseload, pvlimit)
-        pushmode_power = houseload - min(pv, pvlimit) - 90 + pv / 14  # some kind of empiric correction for losses - machine learning would be better
+    elif power_control == "Negative Injection Price":
+        # --- Negative Injection Price (Mode 8 custom) ---
+        # Controller goals:
+        # 1) If PV < house load (deficit): discharge the battery up to the deficit (respecting min SOC),
+        #    aiming to prefer a slight grid import bias over export bias.
+        # 2) If PV ≥ house load (surplus): let PV feed the battery first. PV limit is then adjusted using
+        #    bounded step changes based on the measured power to prevent export.
+
+        # Use the alternative house load for house load measurement, clamping to strict positive values.
+        hl = max(0, int(houseload_alt))
+
+        # SOC bounds
+        min_discharge_soc = datadict.get("selfuse_discharge_min_soc", 10)
+        max_charge_soc = datadict.get("battery_charge_upper_soc", 100)
+        # bias towards import
+        export_target = int(datadict.get("negative_injection_bias", -20) or -20)
+        export_deadband_w = int(datadict.get("export_feedback_deadband_w", 50) or 50)
+        min_step_w = int(datadict.get("export_first_step_min_w", 100) or 100)
+        max_step_w = int(datadict.get("export_feedback_max_w", 500) or 500)
+
+        # Local copies
+        battery_charge = max(0, int(datadict.get("battery_power_charge", 0) or 0))
+        pvlimit = setpvlimit
+        cur_pvlimit = max(0, setpvlimit if (cur_pvlimit := datadict.get("remotecontrol_current_pv_power_limit", None)) is None else cur_pvlimit)
+        pushmode_power = 0  # + = discharge, - = charge
+
+        # Debug inputs
         _LOGGER.debug(
-            f"***debug*** setpvlimit: {setpvlimit} pvlimit: {pvlimit} pushmode: {pushmode_power} houseload:{houseload} pv: {pv} batcap: {battery_capacity}"
+            f"[Mode8 Negative Injection] inputs pv={pv}W hl={houseload}W hl_alt={houseload_alt}W (using hl) imp_lim={import_limit}W "
+            f"soc={battery_capacity}% min_soc={min_discharge_soc}% max_soc={max_charge_soc}% cur_pvlimit={cur_pvlimit}W "
+            f"battery_charge={battery_charge}W"
         )
 
+        # Optional probes (if available)
+        measured_power = datadict.get("measured_power", None)
+        _LOGGER.debug(f"[Mode8 Negative Injection] probes: measured_power={measured_power if measured_power is not None else 'n/a'} ")
+
+        if pv >= hl or cur_pvlimit < setpvlimit:
+            # Surplus or limited pv path: battery is requested to charge at up to the rate
+            # limit from PV alone then use measured export as the control signal to adjust PV limit.
+            # Below target: PV should be reduced to prevent export.
+            # At/above target: PV can be increased to reduce import in bounded steps.
+            # If PV has been limited below the setpoint and is now below house load, continue in this
+            # loop to release PV restriction slowly.
+            surplus = max(0, pv - hl)
+            measured_power = int(measured_power or 0)
+            error = measured_power - export_target
+            control_state = "surplus" if pv >= hl else "clipping"
+
+            # Battery gets surplus up to BMS limit
+            desired_charge, bms_cap_w, pct_cap_w = autorepeat_bms_charge(datadict, battery_capacity, max_charge_soc, surplus)
+            pushmode_power = -desired_charge
+
+            if abs(error) <= export_deadband_w:
+                step_w = 0
+                pvlimit = cur_pvlimit
+                control_reason = "hold"
+            elif error > 0:
+                step_w = min(max_step_w, max(min_step_w, error))
+                pvlimit = max(0, cur_pvlimit - step_w)
+                control_reason = "decrease-pv"
+            else:
+                step_w = min(max_step_w, max(min_step_w, -error))
+                pvlimit = min(setpvlimit, cur_pvlimit + step_w)
+                control_reason = "increase-pv"
+
+            _LOGGER.debug(
+                f"[Mode8 Negative Injection] {control_state}: surplus={surplus}W measured_power={measured_power}W "
+                f"export_target={export_target}W error={error}W step={step_w}W reason={control_reason} "
+                f"bms_cap≈{bms_cap_w}W pct_cap={pct_cap_w}W -> charge={desired_charge}W pvlimit={pvlimit}W hl={hl}W"
+            )
+
+        else:
+            # Deficit path: discharge battery up to the current house deficit (if SOC allows).
+            # Note this is only reached if pvlimit has been restored to above the house load by
+            # the limited pv path and we therefore have insufficient PV to cover the load.
+            deficit = hl + export_target - pv
+            if battery_capacity > min_discharge_soc:
+                pushmode_power = min(deficit, 30000)
+            else:
+                pushmode_power = 0
+            _LOGGER.debug(
+                f"[Mode8 Negative Injection] deficit: deficit={deficit}W export_target={export_target}W "
+                f"soc={battery_capacity}% chosen_push={pushmode_power}W"
+            )
+
     elif power_control == "Negative Injection and Consumption Price":  # disable PV, charge from grid
         pvlimit = 0
         pushmode_power = houseload - import_limit
@@ -720,14 +800,10 @@ def autorepeat_function_powercontrolmode8_recompute(initval: int, descr: Any, da
 
         # Export limit no readscale:
         export_limit = datadict.get("export_control_user_limit", 30000)
-        inverter_limit = datadict.get("inverter_power_type", 30000)
-
-        # Both house load and exported power come from the inverter and must fit within the inverter
-        # power limit. For example if we have a 6kW inverter and 4kW of house load, then we cannot
-        # export more than 2kW even if our export limit is higher. Trim the export limit so that any
-        # excess can be used for charging the battery rather than PV being clamped.
-        export_available = max(inverter_limit - hl, 0)
-        export_limit = min(export_limit, export_available)
+
+        # Test mode: do not trim the export target by inverter power minus house load.
+        # This lets Export-First try to use the configured export limit directly before charging the battery.
+        export_available = export_limit
 
         # SOC bounds
         min_discharge_soc = datadict.get("selfuse_discharge_min_soc", 10)