Prediktivní brzda proudu FVE (solarAmax)

1. Co se děje teď

Na /ai-fve-pv je Ochrana proudu FVE (solarA): solarAmax (např. 22 A) a solarAThrottlePct (např. 90 % → soft ≈ 19,8 A). Funkce applySolarAmaxPwmLimit() v spotove_ceny.h reaguje až když naměřené solarA vstoupí do soft pásma / nad Amax.

2. Proč je to agresivní

1. Regulátor přidává PWM podle přebytku (MQTT solarW / load) — bez znalosti „o kolik W tyč přibude“.
2. Tyč 2500 W při +10 % PWM ≈ +250 W okamžitě (SSR/PWM). Při vyšším PWM je skok ještě cítit.
3. MQTT solarA / solarW přijde se zpožděním (stovky ms až sekundy) → soft limit se spustí až po špičce.
4. Měnič mezitím vidí přetížení DC/AC a sraží výrobu; teprve pak UI ukáže I blízko soft a cut.
5. Při cutu stejný lag: A v MQTT ještě vysoké, PWM už snížené → opakované cuty až na 0 % (horší u topidel ≥1 kW — větší ΔW/ΔA a setrvačnost tepla v tyči).

3. Parametr heatMaxW na /teplota

Na stránce /teplota (Měření → Tepl) je samostatný řádek Max výkon topení při 100 % PWM (W). Jde o jmenovitý součet topných těles řízených PWM (např. 2500 W).

Ukládání

• Logický klíč /heatMaxW.ea → trvale v šifrovaném /easun.cfg (jako ostatní nastavení).
• Stejná hodnota se zrcadlí i do /solar-sim.cfg (heatMaxW=…) při uložení ze sim / teplota.
• RAM: gSolarSimHeatMaxW — sdílené pro provoz i simulaci.
• Default: 2000 W (pokud klíč chybí, zapíše se při ensure defaults).

HeatW_est = heatMaxW × (PWM% / 100)   // lineární odhad (výchozí)
HeatA_est = HeatW_est / GridV           // PZEM nebo cezV

4. Kalibrační test PWM 0–100 % (V / A / W topení)

Implementováno na stránce /pwm (tlačítka Spustit / Stop, progress %, CSV, Použít W@100% jako heatMaxW). Lineární heatMaxW × PWM% zůstává fallback; naměřená křivka je v /heat-pwm-cal.csv pro další FF zpracování.

4.1 Jak to poběží (krok 1 %)

1. Start — na /pwm tlačítko Spustit (confirm). Automatika OFF, ruční PWM ON, sim FVE se vypne.
2. Bod 0 % — nastaví PWM = 0, krátce počká, zapíše V / A / W topení (PZEM).
3. Smyčka — PWM += 1 % → settle → zapsat V/A/W topení + FVE (U/I/W, solarW_eff) → dál.
4. Konec A — dorazí na 100 % → PWM=0, CSV hotovo.
5. Konec B (důležité) — FVE výroba spadne z peaku na ~0 → stop, event SOLAR_DROP, uloží se heatCalDropPwm (= limit PWM před pádem měniče).

pro pwm = 0 … 100  (krok 1 %):
    nastav PWM = pwm
    počkej settleMs (např. 2500 ms)
    zapiš: čas, pwm, heat_V, heat_A, heat_W [, solar U/I/W]
konec → PWM=0 → ulož soubor

Odhad doby: 101 × ~2,5 s ≈ 4–5 minut. Delší settle = přesnější, ale pomalejší. Stop tlačítko kdykoli → ihned PWM=0.

4.2 Co z toho získáte

4.3 Archivace (CSV + easun.cfg)

ms,pwm_pct,heat_V,heat_A,heat_W,grid_V,solar_V,solar_A,solar_W,solarW_eff,event
…
45250,47,229.8,5.10,1170,230,118,0.2,24,24,SOLAR_DROP

• Soubor /heat-pwm-cal.csv + download /api/heat-cal-csv.
• Shrnutí do easun.cfg: heatCalLastReason, heatCalLastPwm, heatCalSolarPeak, heatCalDropPwm, heatCalDropHeatW, heatCalLastHeatW.
• Detekce pádu: peak FVE ≥ 200 W (max MQTT / U×I) a aktuální U×I ≤ max(50 W, 5 % peaku) při PWM ≥ 5 % a solarA < 0.8 A (nečeká na zpožděné MQTT).
• API: start/stop/apply-w100 (při dropu použije W topení v okamžiku pádu).

4.4 Bezpečnost a podmínky

• Na /ai-fve-pv nastavený Strop odhadu W (např. 6200).
• Aktuální FVE ≥ need (zobrazeno na /pwm).
• Spustit kalibraci; nechat doběhnout do pádu / 100 % / Stop.
• Po dokončení zkontrolovat CSV / heatCalDropPwm.

Stav: hotovo ve FW (UI /pwm + FF brzda). Kalibrace má smysl hlavně kvůli vztahu U↔I panelů (nízké U → vysoké A).

4.5 Proč kalibrace: napětí panelů a proud měniče

Kalibrační sweep (a hledání SOLAR_DROP) není primárně o limitu sítě. Smysl má proto, že výkon FVE je vždy:

P ≈ U × I     →     I ≈ P / U

Co z toho plyne pro test

• Kalibrace při silné FVE zachytí, při jakém PWM topení už DC proud / ochrana měniče shodí výrobu na ~0 — to je praktický koncový bod pro dané U/I podmínky.
• Při nízkém U (typicky pod ~100–120 V podle stringu) bude pád dřív (nižší heatCalDropPwm) — to je očekávané, ne chyba testu.
• Při vysokém U (slunce, MPPT nahoře) stejná tyč dovolí vyšší PWM, než proud dojde k Amax.
• FF brzda počítá dA ≈ dW / solarV — proto je v telemetrii důležité živé U; bez rozumného napětí odhad proudu neplatí.

Doporučení podle výkonu měniče (příklad 6200 W)

Strop topení a solarAmax držte pod jmenovitým výkonem / proudem měniče (katalog + string). Orientačně pro hybrid typu Anern / EASUN ~6200 W:

Příklad (stejné topení +250 W):
  U = 200 V → dA ≈ 250/200 = 1,25 A
  U = 100 V → dA ≈ 250/100 = 2,50 A   // 2× horší pro Amax
Proto má kalibrace + FF smysl právě kvůli omezení napětí / výkonu panelů.

5. Návrh prediktivní brzdy

5.1 Dvě vrstvy ochrany

5.2 Algoritmus A (před přidáním PWM)

1. Z měření: solarA, solarV (nebo U z FVE·AI), softA = Amax × throttle%.
2. Navržený krok: pwmNext = pwmNow + step (z surplus větve).
3. Odhad přírůstku topení: dW = W(pwmNext) − W(pwmNow) (z křivky po kalibraci, jinak heatMaxW × dPWM / 100).
4. Odhad přírůstku proudu FVE (konzervativně — celý dW jde z PV): dA = dW / max(solarV, 50).
5. Pokud solarA + dA ≥ softA − marginA → zmenšit step (nebo 0), dokud predikce neprojde.
6. V pásmu blízko soft (např. 85–100 % soft) násobit max. krok faktorem 0,35; u topení ≥1 kW navíc škálovat dolů (1000/W, u ≥2 kW ×0,55).

5.3 Úprava vrstvy B — settle hold (hotovo ve FW)

• Soft pásmo (solarA < solarAmax, ale latched): PWM se nereže — jen se blokuje přidávání (FF + latch). Dříve proporcionální cut až −35 %/tick.
• Nad hard Amax: jeden mírný cut, pak settle (gAmaxReactiveHoldUntilMs) — další cut až po uplynutí, nebo při nouzi (A stále roste výrazně nad poslední cut).
• Cap ΔW: cut se omezuje podle křivky heatWAtPwmPct() — ne jen podle % PWM (amaxCapCutByHeatDw).
• Hystereze přidávání: po cutu znovu přidávat až když solarA < softA − 0,5 A (gAmaxSoftLatched).
• FinalniUpravy: během settle se neaplikuje agresivní drop kvůli solarWEff < solarWMin (log solarWMin hold(amax)).

5.4 Reaktivní cut podle výkonu topení (≥1 kW)

Odhad výkonu: heatW = heatWAtPwmPct(PWM) — z CSV kalibrace nebo lineárně z heatMaxW. Parametry v amaxReactiveTuneForHeatW() (spotove_ceny.h):

6. Vzorce a příklady (tyč 2500 W)

softA   = solarAmax × solarAThrottlePct / 100
dW      = heatMaxW × dPWM / 100
dA_est  = dW / solarV          // konzervativní odhad proudu FVE
headroom = softA − solarA − marginA
dPWM_max ≈ headroom × solarV × 100 / heatMaxW

7. Postup implementace ve firmwaru

Stav: parametr heatMaxW + kalibrace PWM + prediktivní FF brzda hotové ve FW.

1. Parametr heatMaxW — UI /teplota, SPIFFS klíč heatMaxW v /easun.cfg, sync s /solar-sim. ✅
2. Kalibrační test PWM — /pwm, 0→100 % po 1 %, settle 2,5 s, CSV, apply W@100%. ✅
3. clampPwmStepByPredictedSolarA — dW z křivky CSV nebo lineárně z heatMaxW; cap před add v surplus i U-větvi; u topení ≥1 kW pomalejší rampa blízko soft. ✅
4. amaxBlocksAdd — soft − margin 0,4 A + hystereze soft latch. ✅
5. applySolarAmaxPwmLimit — soft pásmo jen latch (bez cutu); nad Amax cut podle výkonu topení + settle hold + cap ΔW (viz §5.4). ✅
6. FinalniUpravyARegulacePwmFunkce — během gAmaxReactiveHoldUntilMs neřezat kvůli solarWEff < solarWMin. ✅
7. Telemetrie /api/solar-sim: dA_est, dPwmCap, AMAX_FF_CAP, heatCurveOk, amaxSoftLatched, amaxHoldMs. ✅
8. Ověřit na ostrém odběru s tyčí ≥1 kW — PWM nesmí spadnout na 0 dřív než A/FVE.

float softA = solarAmax * throttlePct / 100.0f;
float marginA = 0.4f; // ~0.3–0.6 A
float headroom = softA - solarA - marginA;
if (headroom <= 0) return 0; // nepřidávat

float v = max(solarV, 50);
float dA_per_pct = (heatMaxW / 100.0f) / v;
float maxStep = headroom / max(dA_per_pct, 1e-4f);

// blízko soft — zpomalit
float near = solarA / softA;
if (near > 0.85f) maxStep *= 0.35f;
// topení ≥1 kW — ještě pomaleji
float heatWNow = heatWAtPwmPct(pwmNow);
if (heatWNow >= 1000) maxStep *= min(1.0f, 1000.0f / heatWNow);
if (heatWNow >= 2000) maxStep *= 0.55f;

return min(requestedStep, maxStep);

if (!gAmaxSoftLatched) return pwm;
if (solarA < solarAmax) return pwm;          // soft: jen držet, FF blokuje add

heatW = heatWAtPwmPct(pwm);
tune = amaxReactiveTuneForHeatW(heatW);      // cut/tick, settleMs, maxDwCut

if (millis() < gAmaxReactiveHoldUntilMs) {
  if (!emergencyStillRising()) return pwm;     // čekat na fyzický pokles I
}
target = pwm - proportionalCut(solarA, solarAmax, heatW);
target = amaxCapCutByHeatDw(pwm, target, maxDwCut);
gAmaxReactiveHoldUntilMs = millis() + settleMs;
return target;

8. Test na /solar-sim a ostrý provoz

8.1 Simulace (bez fyzického topení)

• Zapnout simulaci FVE; Přidávat na topení = ne (jen výpočet).
• Na /teplota Max výkon topení = skutečný součet tyčí (např. 2670 W z kalibrace).
• /ai-fve-pv: solarAmax=22, Brzdit od=85–90 %.
• Sledovat: dPwmCap, AMAX_FF_CAP, amaxSoftLatched, amaxHoldMs.
• Očekávání: při I blízko soft FF capne krok dřív; reaktivní cut jen nad hard Amax.

8.2 Ostrý provoz — tyč ≥1 kW (důležité)

• heatMaxW nebo CSV křivka na SPIFFS (heatCurveOk: true).
• Při překročení Amax: jeden mírný cut, pak amaxHoldMs 5500–7000 ms — PWM drží, nesmí kaskáda na 0.
• WebSerial 9/10: solarWMin hold(amax) během settle (FinalniUpravy neřeže).
• CSV log /api/solar-sim-log — méně opakovaných AMAX_SOFT_CUT, cut jen nad Amax.
• Video / log: po cutu počkat ~5–7 s — A a FVE by měly stabilizovat, PWM zůstat > 0 pokud je přebytek.

9. AI konzultace z logování aplikace

Od firmware S3.0913+ aplikace automaticky sestaví prompt včetně dotazů a mapy menu podle stavu zařízení a logů — stačí zkopírovat do Gemini nebo ChatGPT v prohlížeči. Na ESP32 nepotřebujete API klíč ani zapnutý AI Cloud.

9.1 Co to pro vás znamená

• Aplikace automaticky sestaví dotazy podle stavu zařízení, nastavení (# cfg) a event logu — nemusíte nic doplňovat ručně.
• Dostanete jeden hotový prompt s hlavním dotazem + až 8 konkrétními otázkami (WDT, MQTT, PWM, Amax, Spot, baterie…).
• Prompt obsahuje mapu menu aplikace (URL stránek + názvy polí) — AI má odpovídat přesně: kam jít, jaké pole, jaká hodnota, proč.
• Prompt se negeneruje do SPIFFS — vzniká při otevření /logs (šetří místo v paměti).
• V textu nejsou hesla WiFi, Gemini klíč ani MQTT secret.

9.2 Co aplikace detekuje (automatické dotazy)

9.3 Kde prompt najdete

9.4 Doporučený postup

1. Na /solar-sim zapněte Logovat PWM, nechte běžet test / provoz.
2. Otevřete /logs nebo /logs-ai-prompt — aplikace sama vloží CSV a vypne logování.
3. V prohlížeči otevřete Gemini nebo ChatGPT — účet zdarma stačí.
4. Vložte text (Ctrl+V) a odešlete — dotazy i solar-sim větev branch jsou už v promptu.
5. Další test: znovu zapněte Logovat PWM na /solar-sim.

9.5 Co je v promptu (jaké informace AI dostane)

9.6 Příklad odpovědi od AI (co očekávat)

Kam: http://192.168.1.50/teplota — pole «Max topeni W @100% PWM» (heatMaxW)
Aktualni: 4200 W (z # cfg)
Doporucit: 6500 W
Proc: solar-sim log ukazuje AMAX_REACTIVE_CUT — heatMaxW je nizsi nez skutecny odber tyce.

Obecné rady bez URL a bez názvu pole jsou v promptu zakázané — pokud AI neví, má napsat, které políčko ověřit.

9.7 Tři úrovně AI / logování — co kdy použít

10. Po resetu / nahrání aplikace — další krok

1. Po resetu / flashi — ověř WiFi, MQTT, Home běží; na /teplota zkontroluj heatMaxW.
2. Bezpečnost — silná FVE; topný okruh OK; víte, že Distr Max test neukončí.
3. Další krok — kalibrace je ve FW; na /pwm spustit test (pozor na odběr).
4. Po CSV — Použít W@100% jako heatMaxW → ověřit FF + settle na ostrém odběru (heatCurveOk, amaxHoldMs 5,5–7 s u ≥1 kW).
5. Při divném chování PWM / Amax — §9: zkopírovat prompt z /logs do Gemini/ChatGPT.

10.1 Smoke test po nahrání FW

1. /teplota: heatMaxW z kalibrace (např. 2670), restart → hodnota zůstane.
2. /api/solar-sim nebo snapshot: heatCurveOk true, pokud je /heat-pwm-cal.csv na SPIFFS.
3. /ai-fve-pv: solarAmax + soft % beze změny.
4. Ostrý test: při A>Amax jeden cut → amaxHoldMs 5500–7000 u ≥1 kW topení.
5. WebSerial 9: solarWMin hold (amax) během settle.

• heatMaxW uložen a po restartu sedí
• Uživatel potvrdil, že ví o odběru topení během kalibrace
• Kalibrace ve FW ✅ — /pwm, 1 % krok, settle, CSV
• FF + settle Amax ve FW ✅ (2026-08-12) — ověřit u tyče ≥1 kW
• amaxHoldMs po cutu odpovídá tabulce v §5.4
• Prompt pro AI z /logs — viz §9

11. Doporučené výchozí parametry

Související: 11b FVE·AI / Amax · Solar Sim ve V900 · PWM opravy