From a02e11ee13171cca4331c758d7a99ad7368d1d84 Mon Sep 17 00:00:00 2001 From: Dusan Vojacek Date: Sun, 19 Apr 2026 15:54:14 +0200 Subject: [PATCH] deye ridi maximalni flow do baterie hlavne z gridu --- backend/services/planning_engine.py | 9 +++- backend/tests/test_planning_dispatch_milp.py | 53 ++++++++++++++++++++ docs/04-modules/modbus-registers.md | 2 +- docs/04-modules/planning.md | 17 +++++-- 4 files changed, 76 insertions(+), 5 deletions(-) diff --git a/backend/services/planning_engine.py b/backend/services/planning_engine.py index 6fe738e..4681902 100644 --- a/backend/services/planning_engine.py +++ b/backend/services/planning_engine.py @@ -429,7 +429,14 @@ def solve_dispatch( ) # --- Proměnné --- - gi = [pulp.LpVariable(f"gi_{t}", 0, grid.max_import_power_w) for t in range(T)] + # gi[t] horní mez: site breaker (max_import_power_w) je fyzický strop, ale o jeho dodržení + # se v reálném čase stará **Deye reg 128** (grid charge current) + firmware throttling — + # dynamicky sníží nabíjení baterie, když aktuální `load + bc` přesáhne breaker. Proto LP + # povolí nominálně import až **breaker + BMS max charge**, aby mohl plánovat `bc = BMS max` + # i v slotech s vyšší baseline zátěží (jinak tvrdý strop zbytečně osekává arbitráž v cenově + # nejlepších 15min oknech). Reálný hardware nikdy víc než breaker nenatáhne. + gi_upper = float(grid.max_import_power_w) + float(battery.max_charge_power_w) + gi = [pulp.LpVariable(f"gi_{t}", 0, gi_upper) for t in range(T)] ge = [pulp.LpVariable(f"ge_{t}", 0, grid.max_export_power_w) for t in range(T)] bc = [pulp.LpVariable(f"bc_{t}", 0, battery.max_charge_power_w) for t in range(T)] bd = [pulp.LpVariable(f"bd_{t}", 0, battery.max_discharge_power_w) for t in range(T)] diff --git a/backend/tests/test_planning_dispatch_milp.py b/backend/tests/test_planning_dispatch_milp.py index 734d402..15e5171 100644 --- a/backend/tests/test_planning_dispatch_milp.py +++ b/backend/tests/test_planning_dispatch_milp.py @@ -259,5 +259,58 @@ class PlanningDispatchMilpTests(unittest.TestCase): ) + def test_grid_import_cap_allows_full_bms_charge_above_breaker(self) -> None: + """ + Cheap buy, load 3.7 kW, PV malé → breaker 17 kW limituje gi, ale bc musí moct být + plných BMS 18 kW (Deye reg 128 + firmware throttling chrání jistič fyzicky). + """ + slots = [ + _slot(load=3700, buy=0.4, sell=-0.3, pv_a=0, pv_b=1500), + _slot(load=2000, buy=5.0, sell=4.5, pv_a=0, pv_b=0), + _slot(load=2000, buy=5.0, sell=4.5, pv_a=0, pv_b=0), + ] + battery = _battery(uc_wh=64_000.0, min_pct=12.0, arb_pct=20.0) + battery.max_charge_power_w = 18_000 + battery.max_discharge_power_w = 18_000 + hp = SimpleNamespace( + rated_heating_power_w=0, + tuv_min_temp_c=45.0, + tuv_target_temp_c=55.0, + ) + grid = SimpleNamespace(max_import_power_w=17_000, max_export_power_w=13_500) + vehicles = [ + SimpleNamespace( + max_charge_power_w=0, + battery_capacity_kwh=1.0, + default_target_soc_pct=80.0, + ), + SimpleNamespace( + max_charge_power_w=0, + battery_capacity_kwh=1.0, + default_target_soc_pct=80.0, + ), + ] + soc0 = 0.55 * battery.usable_capacity_wh + results, _ms = solve_dispatch( + slots, + battery, + hp, + grid, + [None, None], + vehicles, + soc0, + 50.0, + tuv_delta_stats=None, + operating_mode="AUTO", + price_failsafe_active=False, + ) + self.assertEqual(len(results), 3) + self.assertGreaterEqual( + results[0].battery_setpoint_w, + 17_500, + msg="LP must be able to target near-BMS-max charge even when gi would exceed breaker", + ) + + if __name__ == "__main__": unittest.main() diff --git a/docs/04-modules/modbus-registers.md b/docs/04-modules/modbus-registers.md index ee3acf2..823c0e3 100644 --- a/docs/04-modules/modbus-registers.md +++ b/docs/04-modules/modbus-registers.md @@ -14,7 +14,7 @@ EMS zapisuje řídící hodnoty přes journal (`modbus_command`) a **`write_regi |-----|-------|--------|----------|---------------| | 108 | Max charge current | 0 … **max dle modelu** (manuál Deye) | 1 A | EMS počítá proud v **SQL**: `COALESCE(deye_register_max_charge_a, FLOOR(LEAST(W)/51.2))` — sloupec stropu v **A** je volitelný (NULL = jen odvod z kW); při vyplnění např. 350 při W→351 A se použije 350. V Pythonu se navíc **clampuje horní strop 350 A** (`DEYE_LV_BATTERY_MAX_CHARGE_DISCHARGE_A`), aby firmware nevracel 350 při zápisu 351. | | 109 | Max discharge current | 0 … **max dle modelu** (manuál Deye) | 1 A | Stejně: `COALESCE(deye_register_max_discharge_a, FLOOR(LEAST(W)/51.2))` + **clamp 350 A** jako u 108. | -| 128 | Grid charge current | 0 … **max dle modelu** (manuál Deye) | 1 A | Nabíjení ze sítě | +| 128 | Grid charge current | 0 … **max dle modelu** (manuál Deye) | 1 A | Nabíjení ze sítě. Firmware automaticky sníží reálný proud tak, aby `load + battery_charge` nepřekročil velikost jističe — proto LP v `planning_engine.py` plánuje `gi[t]` až **do `max_import_power_w + BMS_max_charge`**, aby uměl využít cenově nejlepší 15min okna pro nabíjení na plný BMS strop (viz `planning.md` sekce „Plánovací strop gi[t] vs. fyzický jistič"). Fyzické dodržení jističe drží reg 128 + firmware. | | 130 | Grid charge enable | 0/1 | — | 1 = povolit nabíjení ze sítě | | 141 | Energy mgmt mode | bitmask | — | EMS vždy **0** (neměnit jinak) | | 142 | Limit control (System work mode) | 0/1/2 | — | **0** = selling first, **1** = zero export to load, **2** = zero export to CT. Hodnota v non-SELL režimech pochází z `asset_inverter.deye_zero_export_mode` (závisí na instalaci – viz tabulka níže). V režimu SELL vždy **0**. | diff --git a/docs/04-modules/planning.md b/docs/04-modules/planning.md index a0bfc3d..753e57e 100644 --- a/docs/04-modules/planning.md +++ b/docs/04-modules/planning.md @@ -54,6 +54,15 @@ Solver optimalizuje celý horizont (typicky 36h) najednou, čímž přirozeně z - Max import ze sítě: dle `site_grid_connection.max_import_power_w` - Konfigurovatelné per site v DB +#### Plánovací strop `gi[t]` vs. fyzický jistič + +V LP má `grid_import[t]` (proměnná `gi`) horní mez **`max_import_power_w + battery.max_charge_power_w`**, ne jen `max_import_power_w`. Důvod: + +- Ceny se mění co 15 min a cílem je nabíjet baterii v **cenově nejlepších oknech** na BMS max (17–18 kW), i když baseline zátěž doma navíc sežere část jističe. +- O fyzické dodržení jističe se stará **Deye reg 128** (grid charge current) + firmware — v reálném čase sníží `bc`, když `load + bc` přesáhne breaker. +- Pokud bychom `gi[t] ≤ max_import_power_w` nechali jako tvrdé LP omezení, LP by v slotech s vyšší `load_baseline_w` zbytečně osekával `bc` dolů (viděno např. 2026-04-19 13:30: load 3.7 kW, breaker 17 kW → `bc ≤ 17 − 3.7 + pv_b ≈ 14.7 kW`, i když BMS zvládne 18 kW). Optimistický `gi` horní strop umožní plánovat plné využití BMS v cenových oknech; reálný HW nikdy nepřetáhne jistič. +- **Trade-off**: `expected_cost` v plánu může být mírně optimistický (LP spočítá s ~20 kW importem, reálně občas míň kvůli skokům domácí zátěže). Rozdíl se automaticky dohání rolling replanem co 15 min. + --- ## Energetická bilance (pro každý 15min slot t) @@ -82,7 +91,7 @@ kde: | Proměnná | Typ | Rozsah | Popis | |---|---|---|---| -| `grid_import[t]` | kontinuální | 0 – max_import | Nákup ze sítě v W | +| `grid_import[t]` | kontinuální | 0 – (max_import + bms_max_charge) | Nákup ze sítě v W; breaker fyzicky drží Deye reg 128 | | `grid_export[t]` | kontinuální | 0 – max_export (13500) | Prodej do sítě v W | | `battery_charge[t]` | kontinuální | 0 – max_charge | Nabíjení baterie v W | | `battery_discharge[t]` | kontinuální | 0 – max_discharge | Vybíjení baterie v W | @@ -200,7 +209,7 @@ soc_min_wh <= soc[t] <= soc_max_wh # min_soc_percent z DB (provozní podlaha, ```python 0 <= battery_charge[t] <= battery.max_charge_power_w 0 <= battery_discharge[t] <= battery.max_discharge_power_w -0 <= grid_import[t] <= grid.max_import_power_w +0 <= grid_import[t] <= grid.max_import_power_w + battery.max_charge_power_w # LP soft; fyzicky drží Deye reg 128 0 <= grid_export[t] <= grid.max_export_power_w # = 13500 pro home-01 0 <= pv_a_curtailed[t] <= pv_a_forecast[t] 0 <= ev_charge[t] <= ev_max_total_w @@ -271,7 +280,9 @@ def solve_dispatch( prob = pulp.LpProblem("ems_dispatch", pulp.LpMinimize) # --- Proměnné --- - grid_import = [pulp.LpVariable(f"gi_{t}", 0, grid.max_import_power_w) for t in range(T)] + # gi horní mez = breaker + BMS max_charge (LP optimistický strop, Deye reg 128 chrání fyzicky) + gi_upper = grid.max_import_power_w + battery.max_charge_power_w + grid_import = [pulp.LpVariable(f"gi_{t}", 0, gi_upper) for t in range(T)] grid_export = [pulp.LpVariable(f"ge_{t}", 0, grid.max_export_power_w) for t in range(T)] batt_charge = [pulp.LpVariable(f"bc_{t}", 0, battery.max_charge_power_w) for t in range(T)] batt_discharge = [pulp.LpVariable(f"bd_{t}", 0, battery.max_discharge_power_w) for t in range(T)]