258 lines
8.3 KiB
PHP
258 lines
8.3 KiB
PHP
<?php
|
|
|
|
class Bat_EV_SDL extends IPSModule
|
|
{
|
|
public function Create()
|
|
{
|
|
parent::Create();
|
|
|
|
// Properties
|
|
$this->RegisterPropertyString("Batteries", "[]");
|
|
$this->RegisterPropertyInteger("SDL_Leistung", 0); // W
|
|
$this->RegisterPropertyInteger("UpdateInterval", 5); // Minuten
|
|
|
|
// Status
|
|
$this->RegisterVariableBoolean("State", "Aktiv", "~Switch", 1);
|
|
$this->EnableAction("State");
|
|
|
|
// Prozentwerte
|
|
$this->RegisterVariableFloat("SDL_Pos", "SDL Energie verfügbar (%)", "", 10);
|
|
$this->RegisterVariableFloat("SoC_EV", "EV Energie verfügbar (%)", "", 11);
|
|
|
|
// Leistungsgrenzen
|
|
$this->RegisterVariableFloat("P_SDL_max", "SDL max (W)", "", 20);
|
|
$this->RegisterVariableFloat("P_SDL_laden", "P SDL laden max (W)", "", 21);
|
|
$this->RegisterVariableFloat("P_SDL_entladen", "P SDL entladen max (W)", "", 22);
|
|
|
|
$this->RegisterVariableFloat("P_EV_max", "EV max (W)", "", 30);
|
|
$this->RegisterVariableFloat("P_EV_laden", "P EV laden max (W)", "", 31);
|
|
$this->RegisterVariableFloat("P_EV_entladen", "P EV entladen max (W)", "", 32);
|
|
|
|
// Debug
|
|
$this->RegisterVariableString("CalcJSON", "Berechnung (JSON)", "", 99);
|
|
|
|
// Timer
|
|
$this->RegisterTimer("UpdateTimer", 0, 'GEF_Update($_IPS["TARGET"]);');
|
|
}
|
|
|
|
public function ApplyChanges()
|
|
{
|
|
parent::ApplyChanges();
|
|
|
|
$intervalMin = (int)$this->ReadPropertyInteger("UpdateInterval");
|
|
$this->SetTimerInterval("UpdateTimer", ($intervalMin > 0) ? $intervalMin * 60 * 1000 : 0);
|
|
|
|
$this->Update();
|
|
}
|
|
|
|
public function RequestAction($Ident, $Value)
|
|
{
|
|
if ($Ident === "State") {
|
|
SetValue($this->GetIDForIdent("State"), (bool)$Value);
|
|
if ((bool)$Value) {
|
|
$this->Update();
|
|
}
|
|
return;
|
|
}
|
|
throw new Exception("Invalid Ident: " . $Ident);
|
|
}
|
|
|
|
public function Update()
|
|
{
|
|
if (!GetValue($this->GetIDForIdent("State"))) {
|
|
return;
|
|
}
|
|
|
|
$batteries = json_decode($this->ReadPropertyString("Batteries"), true);
|
|
if (!is_array($batteries)) $batteries = [];
|
|
|
|
$sdlTotalW = (float)$this->ReadPropertyInteger("SDL_Leistung"); // W
|
|
if ($sdlTotalW < 0) $sdlTotalW = 0;
|
|
|
|
// 30 Minuten
|
|
$hours = 0.5;
|
|
|
|
// Summe Batterie-Maxleistungen
|
|
$sumBatPowerW = 0.0;
|
|
foreach ($batteries as $b) {
|
|
$p = (float)($b["powerbat"] ?? 0);
|
|
if ($p > 0) $sumBatPowerW += $p;
|
|
}
|
|
if ($sumBatPowerW <= 0.0) {
|
|
$this->WriteAllZero("sumBatPowerW=0");
|
|
return;
|
|
}
|
|
|
|
// SDL nicht größer als Summe Batterieleistung
|
|
if ($sdlTotalW > $sumBatPowerW) $sdlTotalW = $sumBatPowerW;
|
|
|
|
// Totals
|
|
$totalCapKWh = 0.0;
|
|
$totalStoredKWh = 0.0;
|
|
|
|
$sdlNeedTotalKWh = ($sdlTotalW / 1000.0) * $hours;
|
|
|
|
$sumSdlAvailKWh = 0.0; // wirklich lieferbar (energiebegrenzt)
|
|
$sumEvKWh = 0.0; // Restenergie nach SDL
|
|
|
|
$sumSdlChargeKW = 0.0;
|
|
$sumEvChargeKW = 0.0;
|
|
$sumSdlDisKW = 0.0;
|
|
$sumEvDisKW = 0.0;
|
|
|
|
$calc = [
|
|
"batteries" => [],
|
|
"total" => []
|
|
];
|
|
|
|
foreach ($batteries as $idx => $b) {
|
|
$pBatW = max(0.0, (float)($b["powerbat"] ?? 0));
|
|
$capKWh = max(0.0, (float)($b["capazity"] ?? 0));
|
|
$socPct = (float)($b["soc"] ?? 0);
|
|
|
|
if ($socPct < 0) $socPct = 0;
|
|
if ($socPct > 100) $socPct = 100;
|
|
|
|
$totalCapKWh += $capKWh;
|
|
|
|
// gespeicherte Energie
|
|
$storedKWh = $capKWh * ($socPct / 100.0);
|
|
$totalStoredKWh += $storedKWh;
|
|
|
|
// SDL-Leistung anteilig verteilen
|
|
$sdlShareW = 0.0;
|
|
if ($pBatW > 0 && $sdlTotalW > 0) {
|
|
$sdlShareW = $sdlTotalW * ($pBatW / $sumBatPowerW);
|
|
}
|
|
if ($sdlShareW > $pBatW) $sdlShareW = $pBatW;
|
|
|
|
$evShareW = max(0.0, $pBatW - $sdlShareW);
|
|
|
|
// in kW
|
|
$sdlShareKW = $sdlShareW / 1000.0;
|
|
$evShareKW = $evShareW / 1000.0;
|
|
|
|
// under_grenze = SDL Energiebedarf in 30min
|
|
$underKWh = $sdlShareKW * $hours;
|
|
|
|
// tatsächlich für SDL verfügbare Energie
|
|
$sdlAvailKWh = min($storedKWh, $underKWh);
|
|
|
|
// EV Energie = Restenergie nach SDL (aber nicht negativ)
|
|
$upKWh = max(0.0, $storedKWh - $sdlAvailKWh);
|
|
|
|
// --- RUNTERREGELN (Discharge) ---
|
|
// Max kW aus Energie in 30min: P = E / hours
|
|
$sdlDisKW = ($hours > 0) ? min($sdlShareKW, $sdlAvailKWh / $hours) : 0.0;
|
|
$evDisKW = ($hours > 0) ? min($evShareKW, $upKWh / $hours) : 0.0;
|
|
|
|
// Charge ist einfach die reservierte Leistung
|
|
$sdlChKW = $sdlShareKW;
|
|
$evChKW = $evShareKW;
|
|
|
|
// Totals sammeln
|
|
$sumSdlAvailKWh += $sdlAvailKWh;
|
|
$sumEvKWh += $upKWh;
|
|
|
|
$sumSdlChargeKW += $sdlChKW;
|
|
$sumEvChargeKW += $evChKW;
|
|
$sumSdlDisKW += $sdlDisKW;
|
|
$sumEvDisKW += $evDisKW;
|
|
|
|
$calc["batteries"][] = [
|
|
"idx" => $idx,
|
|
"typ" => (string)($b["typ"] ?? ("Bat " . ($idx + 1))),
|
|
|
|
"P_bat_W" => round($pBatW, 0),
|
|
"Cap_kWh" => round($capKWh, 3),
|
|
"SoC_pct" => round($socPct, 3),
|
|
|
|
"SDL_Power_kW" => round($sdlShareKW, 3),
|
|
"EV_Power_kW" => round($evShareKW, 3),
|
|
|
|
"under_grenze_kWh" => round($underKWh, 3),
|
|
"up_grenze_kWh" => round($upKWh, 3),
|
|
|
|
"SDL_Charge_kW" => round($sdlChKW, 3),
|
|
"SDL_Discharge_kW" => round($sdlDisKW, 3),
|
|
|
|
"EV_Charge_kW" => round($evChKW, 3),
|
|
"EV_Discharge_kW" => round($evDisKW, 3),
|
|
];
|
|
}
|
|
|
|
// SDL% = lieferbare SDL Energie / benötigte SDL Energie
|
|
$sdlPosPct = 0.0;
|
|
if ($sdlNeedTotalKWh > 0.000001) {
|
|
$sdlPosPct = ($sumSdlAvailKWh / $sdlNeedTotalKWh) * 100.0;
|
|
}
|
|
|
|
// EV%: ich nehme "EV verfügbar / (SumCap - SDL_need)" wie wir zuletzt hatten
|
|
// Wenn du lieber EV% auf Basis "SumStored - SDL_avail" willst, sag Bescheid.
|
|
$evMaxKWh = max(0.0, $totalCapKWh - $sdlNeedTotalKWh);
|
|
$evPosPct = 0.0;
|
|
if ($evMaxKWh > 0.000001) {
|
|
$evPosPct = ($sumEvKWh / $evMaxKWh) * 100.0;
|
|
}
|
|
|
|
// Variablen setzen
|
|
$this->SetIdentValue("SDL_Pos", round($sdlPosPct, 3));
|
|
$this->SetIdentValue("SoC_EV", round($evPosPct, 3));
|
|
|
|
// W-Variablen im Objekt: wir geben die totals in W aus
|
|
$this->SetIdentValue("P_SDL_max", round($sumSdlChargeKW * 1000.0, 0));
|
|
$this->SetIdentValue("P_SDL_laden", round($sumSdlChargeKW * 1000.0, 0));
|
|
$this->SetIdentValue("P_SDL_entladen", round($sumSdlDisKW * 1000.0, 0));
|
|
|
|
$this->SetIdentValue("P_EV_max", round($sumEvChargeKW * 1000.0, 0));
|
|
$this->SetIdentValue("P_EV_laden", round($sumEvChargeKW * 1000.0, 0));
|
|
$this->SetIdentValue("P_EV_entladen", round($sumEvDisKW * 1000.0, 0));
|
|
|
|
$calc["total"] = [
|
|
"SDL_SoC_pct" => round($sdlPosPct, 3),
|
|
"EV_SoC_pct" => round($evPosPct, 3),
|
|
|
|
"SDL_Charge_kW" => round($sumSdlChargeKW, 3),
|
|
"SDL_Discharge_kW" => round($sumSdlDisKW, 3),
|
|
|
|
"EV_Charge_kW" => round($sumEvChargeKW, 3),
|
|
"EV_Discharge_kW" => round($sumEvDisKW, 3),
|
|
|
|
"SDL_needTotal_kWh" => round($sdlNeedTotalKWh, 3),
|
|
"SDL_availTotal_kWh" => round($sumSdlAvailKWh, 3),
|
|
"EV_total_kWh" => round($sumEvKWh, 3),
|
|
"totalCap_kWh" => round($totalCapKWh, 3),
|
|
"totalStored_kWh" => round($totalStoredKWh, 3)
|
|
];
|
|
|
|
$this->SetIdentValue("CalcJSON", json_encode($calc, JSON_PRETTY_PRINT));
|
|
}
|
|
|
|
|
|
private function WriteAllZero(string $reason): void
|
|
{
|
|
$this->SetIdentValue("SDL_Pos", 0.0);
|
|
$this->SetIdentValue("SoC_EV", 0.0);
|
|
|
|
$this->SetIdentValue("P_SDL_max", 0.0);
|
|
$this->SetIdentValue("P_SDL_laden", 0.0);
|
|
$this->SetIdentValue("P_SDL_entladen", 0.0);
|
|
|
|
$this->SetIdentValue("P_EV_max", 0.0);
|
|
$this->SetIdentValue("P_EV_laden", 0.0);
|
|
$this->SetIdentValue("P_EV_entladen", 0.0);
|
|
|
|
$this->SetIdentValue("CalcJSON", json_encode(["error" => $reason], JSON_PRETTY_PRINT));
|
|
}
|
|
|
|
private function SetIdentValue(string $ident, $value): void
|
|
{
|
|
$id = @$this->GetIDForIdent($ident);
|
|
if ($id <= 0) {
|
|
$this->SendDebug(__FUNCTION__, "Ident nicht gefunden: $ident", 0);
|
|
return;
|
|
}
|
|
SetValue($id, $value);
|
|
}
|
|
}
|