fix(deye): correct the TOU slot payload found by the Sunsynk comparison

Four corrections to the control payload, all surfaced by diffing this
component against the Sunsynk port built from it and against a real
inverter's live settings.

**A zero-length window became a multi-hour full-power grid charge (#4560).**
build_tou_slots() added an action segment at the window start and then
called setdefault() for the return-to-self-use segment at the window end -
a no-op when the two times are equal, so the action slot ran on until the
next boundary, up to four hours. The schedule default is
start = end = "00:00:00" and the control entities are written one at a
time, so an enable event landing before the times do produced exactly
this: a grid charge to the window's target at full power while
_window_active() - which has always guarded start == end - reported the
window inactive. The same guard now runs in build_tou_slots(), on the
normalised times so "02:00:00" against "02:00" is caught too.

**Solar Sell was switched off outside export windows (#4580).**
solarSellAction governs whether surplus PV reaches the grid at all, not
what the battery does, and it was derived from the window active right
now - on inside an export window, off everywhere else. A user with an
ordinary overnight charge window therefore had spare solar curtailed all
through the following day, invisibly: nothing in Predbat's model
represents PV curtailment, so the lost export revenue never showed up.
It is now written on unconditionally. Fixed in build_dynamic_payload()
rather than derive_control_state(), whose solar_sell field also
classifies action-vs-self-use slots.

**Non-export states now use ZERO_EXPORT_TO_CT (#4580).** The CT variant
measures at the grid CT, so the battery serves the whole house without
exporting; ZERO_EXPORT_TO_LOAD measures at the inverter's own output and
on a CT-clamp install would stop the battery serving anything not wired
to it, with the shortfall drawn from the grid. Confirmed on Sunsynk
hardware, which sits behind the same registers.

**Zero slot power is a freeze, and it was on the wrong slots (#4581).**
TimeUseSettingItem.power is the slot's charge/export power and zero is
how the inverter is told to hold. Self-use slots - every interval Predbat
is not actively charging or exporting - carried zero, freezing the
battery as its default state and putting the house on the grid, while the
two freeze states carried the requested power, the opposite of a freeze.
Self-use slots now carry the inverter's rated power, falling back to the
battery's own maximum charge rate for a model whose device/latest has no
RatedPower, and failing closed if neither is known: no payload is built
and nothing is written, because a zero there cannot be justified. That
warning is throttled to once per serial, since _reconcile_control()
rebuilds the payload every cycle. freeze_charge and freeze_export now
carry zero and still classify as action slots, keeping grid_charge and
solar_sell respectively.

hold_charge is deliberately unchanged: the battery is already at target,
so the slot keeps Predbat's chosen charge rate and only the grid-charge
flag differs. Zero there would mean freeze, which is a different state.

Closes #4560, #4580, #4581

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: springfall2008

apps/predbat/deye.py

@@ -130,6 +130,7 @@ def initialize(
         self._cache_restored = False
         self._saved_ratings = None  # signature of the ratings last written, to skip no-op saves
         self._soc_floor_warned = set()
+        self._self_use_power_warned = set()
         self.battery_nominal_voltage = self._as_float(battery_nominal_voltage, 0.0)
         # auth_method defaults to app_credentials, but an injected access token with no
         # developer app credentials can only be oauth — and in app_credentials mode
@@ -512,58 +513,107 @@ def _battery_config_value(self, sn, key, default=0.0):
         return self._as_float(raw, default)
 
     def derive_control_state(self, schedule, current_soc):
-        """Map Predbat's schedule intent to a DEYE control state (see design spec table)."""
+        """Map Predbat's schedule intent to a DEYE control state (see design spec table).
+
+        The work mode governs whether the BATTERY may export; it is orthogonal to
+        solarSellAction, which governs whether surplus PV may (see build_dynamic_payload).
+
+        Non-export states use ZERO_EXPORT_TO_CT: the battery serves the whole house,
+        measured at the grid CT, without exporting. The stricter ZERO_EXPORT_TO_LOAD
+        measures at the inverter's own output instead, so on a CT-clamp install it would
+        stop the battery serving anything not wired to the inverter and the shortfall would
+        come from the grid. Confirmed on Sunsynk hardware, which sits behind the same
+        registers.
+        """
         reserve = int(schedule.get("reserve", 0))
         charge = schedule.get("charge", {})
         export = schedule.get("export", {})
 
         if export.get("enable"):
             export_soc = int(export.get("soc", FREEZE_EXPORT_SOC))
             if export_soc >= FREEZE_EXPORT_SOC:
-                return {"behaviour": "freeze_export", "work_mode": DEYE_WORKMODE["selling_first"], "grid_charge": False, "solar_sell": True, "slot_soc": FREEZE_EXPORT_SOC, "power": int(export.get("power", 0))}
+                # Zero power IS the freeze: selling-first with no slot power holds the
+                # battery while surplus solar still exports.
+                return {"behaviour": "freeze_export", "work_mode": DEYE_WORKMODE["selling_first"], "grid_charge": False, "solar_sell": True, "slot_soc": FREEZE_EXPORT_SOC, "power": 0}
             return {"behaviour": "export", "work_mode": DEYE_WORKMODE["selling_first"], "grid_charge": False, "solar_sell": True, "slot_soc": export_soc, "power": int(export.get("power", 0))}
 
         if charge.get("enable"):
             charge_soc = int(charge.get("soc", 0))
             if charge_soc > current_soc and charge_soc > reserve:
-                return {"behaviour": "charge", "work_mode": DEYE_WORKMODE["zero_export_load"], "grid_charge": True, "solar_sell": False, "slot_soc": charge_soc, "power": int(charge.get("power", 0))}
+                return {"behaviour": "charge", "work_mode": DEYE_WORKMODE["zero_export_ct"], "grid_charge": True, "solar_sell": False, "slot_soc": charge_soc, "power": int(charge.get("power", 0))}
             if charge_soc == reserve:
-                return {"behaviour": "freeze_charge", "work_mode": DEYE_WORKMODE["zero_export_load"], "grid_charge": True, "solar_sell": False, "slot_soc": reserve, "power": int(charge.get("power", 0))}
-            return {"behaviour": "hold_charge", "work_mode": DEYE_WORKMODE["zero_export_load"], "grid_charge": False, "solar_sell": False, "slot_soc": reserve, "power": int(charge.get("power", 0))}
+                # Zero power IS the freeze: the slot is enabled for grid charge but given no
+                # power, so the battery neither charges nor discharges and simply holds.
+                return {"behaviour": "freeze_charge", "work_mode": DEYE_WORKMODE["zero_export_ct"], "grid_charge": True, "solar_sell": False, "slot_soc": reserve, "power": 0}
+            # The battery is already at or above the requested target, so grid charge stays
+            # off — the charge is simply not triggered. The slot still carries Predbat's
+            # charge rate, because that is the rate it chose for this window; zero here would
+            # mean freeze, which is a different state.
+            return {"behaviour": "hold_charge", "work_mode": DEYE_WORKMODE["zero_export_ct"], "grid_charge": False, "solar_sell": False, "slot_soc": reserve, "power": int(charge.get("power", 0))}
+
+        return {"behaviour": "idle", "work_mode": DEYE_WORKMODE["zero_export_ct"], "grid_charge": False, "solar_sell": False, "slot_soc": reserve, "power": 0}
+
+    def _self_use_power(self, sn):
+        """Return the power to write on self-use slots for one inverter, or 0 when unknown.
+
+        The inverter's AC rating first, so the battery is free to serve whatever the house
+        draws. Failing that, the battery's own maximum charge rate — a DC-side limit the
+        inverter clamps to its own capability anyway, and far better than a freeze on a
+        model whose device/latest carries no RatedPower. Zero only when neither is known,
+        which build_dynamic_payload turns into no write at all (see _self_use_slot).
+        """
+        return int(self.device_rated_power.get(sn, 0.0)) or int(self.battery_rate_max(sn))
 
-        return {"behaviour": "idle", "work_mode": DEYE_WORKMODE["zero_export_load"], "grid_charge": False, "solar_sell": False, "slot_soc": reserve, "power": 0}
+    def _self_use_slot(self, start_time, reserve, self_use_power):
+        """Build a self-use TOU slot holding at the reserve SoC.
 
-    def _self_use_slot(self, start_time, reserve):
-        """Build a self-use TOU slot holding at the reserve SoC."""
-        return {TOU_FIELD["time"]: start_time, TOU_FIELD["power"]: 0, TOU_FIELD["soc"]: int(reserve), TOU_FIELD["grid_charge"]: False, TOU_FIELD["generate"]: True}
+        self_use_power must NOT be zero. Zero power is how a slot expresses a freeze — the
+        battery neither charges nor discharges — so a zero-power self-use slot would stop
+        the battery serving the house for the whole interval and push the load onto the
+        grid. Self-use slots cover every interval Predbat is not actively charging or
+        exporting, so that would be the battery's default state.
+        """
+        return {TOU_FIELD["time"]: start_time, TOU_FIELD["power"]: int(self_use_power), TOU_FIELD["soc"]: int(reserve), TOU_FIELD["grid_charge"]: False, TOU_FIELD["generate"]: True}
 
     def _action_slot(self, start_time, state):
         """Build a TOU slot realising a derived control state."""
         return {TOU_FIELD["time"]: start_time, TOU_FIELD["power"]: int(state["power"]), TOU_FIELD["soc"]: int(state["slot_soc"]), TOU_FIELD["grid_charge"]: bool(state["grid_charge"]), TOU_FIELD["generate"]: True}
 
-    def build_tou_slots(self, schedule, current_soc):
+    def build_tou_slots(self, schedule, current_soc, self_use_power):
         """Build exactly TOU_SLOT_COUNT ordered slots covering 24h from the schedule windows."""
         reserve = int(schedule.get("reserve", 0))
         # Collect (start_time, state) segment boundaries. Baseline self-use at 00:00.
-        segments = {"00:00": {"behaviour": "idle", "power": 0, "slot_soc": reserve, "grid_charge": False, "solar_sell": False, "work_mode": None}}
+        idle = {"behaviour": "idle", "power": 0, "slot_soc": reserve, "grid_charge": False, "solar_sell": False, "work_mode": None}
+        segments = {"00:00": dict(idle)}
         for direction in ("charge", "export"):
             window = schedule.get(direction, {})
             if window.get("enable") and window.get("start") and window.get("end"):
-                intent = {"reserve": reserve, "charge": {"enable": False}, "export": {"enable": False}}
-                intent[direction] = {"enable": True, "soc": window.get("soc", 0), "power": window.get("power", 0)}
-                state = self.derive_control_state(intent, current_soc)
                 # Normalised to HH:MM here: these strings become DEYE slot times, and the
                 # entities they came from carry seconds.
-                segments[self._to_slot_time(window["start"])] = state
+                start_time = self._to_slot_time(window["start"])
+                end_time = self._to_slot_time(window["end"])
+                if start_time == end_time:
+                    # Mirrors the guard in _window_active: a zero-length window has no
+                    # interval to act over. Compared on the NORMALISED times, so "02:00:00"
+                    # against "02:00" is caught too. Without this, an enable event arriving
+                    # before the time fields (both still the "00:00:00" default) would add an
+                    # action segment whose matching return-to-self-use segment cannot be
+                    # added at the same key — an unterminated, multi-hour full-power
+                    # grid-charge/export slot, even though _active_state correctly reports
+                    # the window inactive.
+                    continue
+                intent = {"reserve": reserve, "charge": {"enable": False}, "export": {"enable": False}}
+                intent[direction] = {"enable": True, "soc": window.get("soc", 0), "power": window.get("power", 0)}
+                segments[start_time] = self.derive_control_state(intent, current_soc)
                 # After the window, return to self-use at reserve.
-                segments.setdefault(self._to_slot_time(window["end"]), {"behaviour": "idle", "power": 0, "slot_soc": reserve, "grid_charge": False, "solar_sell": False, "work_mode": None})
+                segments.setdefault(end_time, dict(idle))
         ordered = sorted(segments.items(), key=lambda kv: kv[0])
         slots = []
         for start_time, state in ordered:
             if state.get("grid_charge") or state.get("solar_sell") or state.get("power"):
                 slots.append(self._action_slot(start_time, state))
             else:
-                slots.append(self._self_use_slot(start_time, reserve))
+                slots.append(self._self_use_slot(start_time, reserve, self_use_power))
         # Normalise to exactly TOU_SLOT_COUNT slots, each with a DISTINCT ascending
         # start time (DEYE rejects/mis-applies duplicate slot times). Pad with
         # self-use slots at filler times not already used by a window boundary,
@@ -573,7 +623,7 @@ def build_tou_slots(self, schedule, current_soc):
             if len(slots) >= TOU_SLOT_COUNT:
                 break
             if filler_time not in used:
-                slots.append(self._self_use_slot(filler_time, reserve))
+                slots.append(self._self_use_slot(filler_time, reserve, self_use_power))
                 used.add(filler_time)
         slots = sorted(slots, key=lambda slot: slot[TOU_FIELD["time"]])[:TOU_SLOT_COUNT]
         return slots
@@ -647,10 +697,25 @@ def build_dynamic_payload(self, sn, schedule, current_soc, now_minutes=None):
         The top-level work mode / on-off flags follow the window active at
         now_minutes (defaults to the current local time); the 6 TOU slots still
         encode every window's per-slot config.
+
+        Returns {} when there is no honest self-use slot power for this inverter, which
+        the caller treats as "do not write": the alternative is a zero-power slot, and
+        zero power freezes the battery (see _self_use_slot).
         """
         if now_minutes is None:
             now_minutes = self._now_minutes()
-        slots = self.build_tou_slots(schedule, current_soc)
+        self_use_power = self._self_use_power(sn)
+        if not self_use_power:
+            # Once per serial: _reconcile_control rebuilds this payload every cycle, so an
+            # unconditional warning would fill the log for as long as the rating is missing.
+            # Cleared again below, so a serial that recovers and then regresses is reported
+            # afresh rather than staying quiet.
+            if sn not in self._self_use_power_warned:
+                self._self_use_power_warned.add(sn)
+                self.log(f"Warn: DEYE {sn} has no inverter rating and no battery config, so self-use slots would be written with zero power (a freeze); skipping the control write")
+            return {}
+        self._self_use_power_warned.discard(sn)
+        slots = self.build_tou_slots(schedule, current_soc, self_use_power)
         active = self._active_state(schedule, current_soc, now_minutes)
         # Final guard: never ask the battery to go below the floor its own installer
         # settings declare (config/battery battLowCapacity). Predbat's control entities
@@ -674,7 +739,22 @@ def build_dynamic_payload(self, sn, schedule, current_soc, now_minutes=None):
             "deviceSn": sn,
             "workMode": active["work_mode"],
             "gridChargeAction": "on" if active["grid_charge"] else "off",
-            "solarSellAction": "on" if active["solar_sell"] else "off",
+            # Solar Sell is always left ON, whatever the active state derives.
+            #
+            # It does not govern the BATTERY — it governs whether surplus PV reaches the grid
+            # at all. Predbat plans when the battery charges and exports; it assumes, as it
+            # does for every other inverter it drives, that spare solar exports passively in
+            # the background. Deriving this from the active window (on only inside an export
+            # window, off otherwise) curtailed surplus PV for most daylight hours, silently
+            # costing export revenue on a sunny day once the battery was full — and Predbat
+            # has no notion it is doing so, because nothing in its model represents PV
+            # curtailment.
+            #
+            # An export window still exports: that comes from the selling-first work mode and
+            # the slot SoC targets, not from this flag. Turning it off is never useful here,
+            # only harmful, so it is not derived at all. derive_control_state still carries
+            # solar_sell because build_tou_slots uses it to classify action-vs-self-use slots.
+            "solarSellAction": "on",
             "touAction": "on",
             "timeUseSettingItems": slots,
         }
@@ -735,6 +815,11 @@ def is_busy_response(data):
     async def apply_dynamic_control(self, sn, schedule, current_soc, force=False):
         """Write the combined control payload, suppressing no-op writes via the applied-payload cache. Returns True if written."""
         desired = self.build_dynamic_payload(sn, schedule, current_soc)
+        if not desired:
+            # No honest self-use power for this inverter, so there is nothing safe to send —
+            # build_dynamic_payload has already said why. force does not override this: the
+            # payload it would write does not exist.
+            return False
         if not force and self.payloads_equal(desired, self.applied_payload.get(sn)):
             self.log(f"Info: DEYE {sn} control unchanged, skipping write")
             return False

apps/predbat/tests/test_deye_api.py

@@ -16,6 +16,11 @@
 from deye_const import DEYE_BASE_URLS, DEYE_TELEMETRY_KEYS, CONFIG_BATTERY_KEYS
 from tests.test_infra import run_async as run_async_local
 
+# Inverter AC rating handed to test doubles. Self-use TOU slots are written at the
+# inverter's rating and a serial with no rating fails closed (see _self_use_power), so any
+# test that builds a control payload has to give its serials one.
+MOCK_RATED_POWER = 5000.0
+
 
 class MockDeye(DeyeAPI):
     """Test double: build a DeyeAPI without the full component lifecycle."""
@@ -51,6 +56,7 @@ def __init__(self, auth_method="app_credentials", data_center="eu", inverter_sn=
         self._tier_refreshed = {}
         self._cache_restored = False
         self._soc_floor_warned = set()
+        self._self_use_power_warned = set()
         self.log_messages = []
         self.local_tz = pytz.timezone("Europe/London")
         self.base = MagicMock()
@@ -59,6 +65,12 @@ def __init__(self, auth_method="app_credentials", data_center="eu", inverter_sn=
         self.base.minutes_now = 0  # local minutes-since-midnight; tests set this for time-aware control
         self._init_oauth(auth_method, "test-token", None, "deye")
 
+    def with_rating(self, *serials, watts=MOCK_RATED_POWER):
+        """Record an inverter AC rating for each serial and return self, for chaining."""
+        for sn in serials:
+            self.device_rated_power[sn] = float(watts)
+        return self
+
     def log(self, message):
         """Capture logs."""
         self.log_messages.append(message)