From 68e57a0f61c1035115435c1594e341299f5dc284 Mon Sep 17 00:00:00 2001 From: DanielHaefliger Date: Tue, 19 May 2026 11:52:30 +0200 Subject: [PATCH] no message --- Batterie/module.php | 301 ++++++++++---------- Ladestation_v2/form.json | 2 +- Manager/module.php | 588 +++++++++++++++++++++++++-------------- 3 files changed, 540 insertions(+), 351 deletions(-) diff --git a/Batterie/module.php b/Batterie/module.php index a9b04d9..4c385f2 100644 --- a/Batterie/module.php +++ b/Batterie/module.php @@ -18,26 +18,22 @@ class Batterie extends IPSModule $this->RegisterPropertyInteger("Netzbezug", 0); $this->RegisterPropertyInteger("AktuelleBatterieleistung", 0);// Initialisierung mit 0 $this->RegisterPropertyInteger("Interval", 2); // Recheninterval - - - // Variabeln für Kommunkation mit Manager $this->RegisterVariableInteger("Batteriemanagement_Variabel","Batteriemanagement_Variabel", "",0); - $this->RegisterVariableInteger("Laden_Entladen","Laden_Entladen", "",3); - $this->RegisterVariableInteger("Aktuelle_Leistung", "Aktuelle_Leistung", "", 0); - $this->RegisterVariableString("PowerSteps", "PowerSteps"); - $this->RegisterVariableBoolean("Idle", "Idle", "", 0); - $this->RegisterVariableInteger("Sperre_Prio", "Sperre_Prio"); - $this->RegisterVariableInteger("PV_Prio", "PV_Prio"); - $this->RegisterVariableInteger("Power", "Power"); - $this->RegisterVariableBoolean("Is_Peak_Shaving", "Is_Peak_Shaving"); - $this->RegisterVariableInteger("Leistung_Delta", "Leistung_Delta", "", 0); - - + $this->RegisterVariableInteger("Laden_Entladen","Laden_Entladen", "",3); $this->RegisterVariableBoolean("Hysterese", "Hysterese","",false); - - $this->RegisterVariableFloat("Bezogene_Energie", "Bezogene_Energie", "", 0); + + // Variabeln für Kommunkation mit Manager + $this->RegisterVariableInteger("Aktuelle_Leistung", "Aktuelle zugeteilte Leistung", "", 0); + $this->RegisterVariableString("PowerSteps", "Leistungsschritte"); + $this->RegisterVariableBoolean("Idle", "Idle", "", 0); + $this->RegisterVariableInteger("Sperre_Prio", "Priorität Peakshaving"); + $this->RegisterVariableInteger("PV_Prio", "Priorität PV"); + $this->RegisterVariableInteger("Power", "Leistung Batterie"); + $this->RegisterVariableBoolean("Is_Peak_Shaving", "Peakshavingmodus"); + $this->RegisterVariableInteger("Leistung_Delta", "Leistung Delta", "", 0); + $this->RegisterVariableFloat("Bezogene_Energie", "Bezogene Energie", "", 0); // Hilfsvariabeln für Idle zustand $this->RegisterPropertyInteger("IdleCounterMax", 2); @@ -45,8 +41,7 @@ class Batterie extends IPSModule $this->SetValue("IdleCounter", 0); // Initialisiere Idle - $this->SetValue("Idle", true); - + $this->RegisterTimer("Timer_Do_UserCalc_Battery",$this->ReadPropertyInteger("Interval")*1000,"IPS_RequestAction(" .$this->InstanceID .', "Do_UserCalc", "");'); @@ -62,37 +57,42 @@ class Batterie extends IPSModule $batterietyp = $this->ReadPropertyInteger("Batterietyp"); + // Batterietypabhängige Variabeln Initialisieren switch ($batterietyp) { + case 0: // Herstellerunabhängig + + $this->MaintainVariable("Goodwe_EntLadeleistung", "Goodwe_EntLadeleistung", VARIABLETYPE_FLOAT, "", 10, false); + $this->MaintainVariable("Ladeleistung", "Ladeleistung", VARIABLETYPE_FLOAT, "", 11, false); + $this->MaintainVariable("Entladeleistung", "Entladeleistung", VARIABLETYPE_FLOAT, "", 13, false); + break; + case 1: // Goodwe $this->MaintainVariable("Goodwe_EntLadeleistung", "Goodwe_EntLadeleistung", VARIABLETYPE_FLOAT, "", 10, true); $this->MaintainVariable("Ladeleistung", "Ladeleistung", VARIABLETYPE_FLOAT, "", 11, false); $this->MaintainVariable("Entladeleistung", "Entladeleistung", VARIABLETYPE_FLOAT, "", 13, false); - $this->MaintainVariable("Laden_Entladen", "Laden_Entladen", VARIABLETYPE_INTEGER, "", 12, true); break; case 2: // Solaredge $this->MaintainVariable("Goodwe_EntLadeleistung", "Goodwe_EntLadeleistung", VARIABLETYPE_FLOAT, "", 10, false); $this->MaintainVariable("Ladeleistung", "Ladeleistung", VARIABLETYPE_FLOAT, "", 11, true); $this->MaintainVariable("Entladeleistung", "Entladeleistung", VARIABLETYPE_FLOAT, "", 13, true); - $this->MaintainVariable("Laden_Entladen", "Laden_Entladen", VARIABLETYPE_INTEGER, "", 12, true); break; case 3: // SiG Energy $this->MaintainVariable("Goodwe_EntLadeleistung", "Goodwe_EntLadeleistung", VARIABLETYPE_FLOAT, "", 10, false); $this->MaintainVariable("Ladeleistung", "Ladeleistung", VARIABLETYPE_FLOAT, "", 11, true); $this->MaintainVariable("Entladeleistung", "Entladeleistung", VARIABLETYPE_FLOAT, "", 13, true); - $this->MaintainVariable("Laden_Entladen", "Laden_Entladen", VARIABLETYPE_INTEGER, "", 12, true); break; default: - // Sicherheit: alles weg + // Default, werden alle ausgeschaltet $this->MaintainVariable("Goodwe_EntLadeleistung", "Goodwe_EntLadeleistung", VARIABLETYPE_FLOAT, "", 10, false); $this->MaintainVariable("Ladeleistung", "Ladeleistung", VARIABLETYPE_FLOAT, "", 11, false); - $this->MaintainVariable("Laden_Entladen", "Laden_Entladen", VARIABLETYPE_INTEGER, "", 12, false); $this->MaintainVariable("Entladeleistung", "Entladeleistung", VARIABLETYPE_FLOAT, "", 13, false); break; } - + + // $maxBatVar = $this->ReadPropertyInteger("MaxBatterieleistung"); $maxNachVar = $this->ReadPropertyInteger("MaxNachladen"); @@ -106,99 +106,6 @@ class Batterie extends IPSModule } - public function MessageSink($TimeStamp, $SenderID, $Message, $Data) -{ - if ($Message !== VM_UPDATE) { - return; - } - - $maxBatVar = $this->ReadPropertyInteger("MaxBatterieleistung"); - $maxNachVar = $this->ReadPropertyInteger("MaxNachladen"); - - if ($SenderID === $maxBatVar || $SenderID === $maxNachVar) { - // PowerSteps sofort neu berechnen (mit aktuellem Peak-Status) - $this->GetCurrentData($this->GetValue("Is_Peak_Shaving")); - } -} - - - -private function GeneratePowerSteps() -{ - - $maxleistung_raw = GetValue($this->ReadPropertyInteger("MaxBatterieleistung")); - $nachladen_raw = GetValue($this->ReadPropertyInteger("MaxNachladen")); - - $stepSize = 250; // Grobe Schrittgröße - $stepSizeSmall = 50; // Feine Schrittgröße - - // Grenzen auf 50er abrunden (floor) - $maxleistung = (int)(floor($maxleistung_raw / $stepSizeSmall) * $stepSizeSmall); - $minleistung = (int)(-floor($nachladen_raw / $stepSizeSmall) * $stepSizeSmall); // negativ! - - // Sicherheitscheck: falls Werte komisch sind - if ($maxleistung < 0) $maxleistung = 0; - if ($minleistung > 0) $minleistung = 0; - - // Grundarray: von min bis max in 250er Schritten - $neg = ($minleistung < 0) ? range($minleistung, 0, $stepSize) : [0]; - $pos = range(0, $maxleistung, $stepSize); - - $array_powersteps = array_values(array_unique(array_merge($neg, $pos))); - sort($array_powersteps, SORT_NUMERIC); - - // Zusätzlichen Wert auf 50er abrunden (floor, nicht round!) - // (wichtig: floor bei negativen Zahlen geht "weiter runter", daher extra Logik) - $closestValue = (int)(floor($additionalValue / $stepSizeSmall) * $stepSizeSmall); - - // Clamp in den Bereich - if ($closestValue < $minleistung) $closestValue = $minleistung; - if ($closestValue > $maxleistung) $closestValue = $maxleistung; - - // Prüfen ob der Wert im Array existiert (bei 250er Raster oft NICHT) - $index = array_search($closestValue, $array_powersteps, true); - - // Wenn nicht vorhanden: an der richtigen Stelle einsortieren - if ($index === false) { - $index = 0; - $count = count($array_powersteps); - while ($index < $count && $array_powersteps[$index] < $closestValue) { - $index++; - } - // $index ist jetzt Einfügeposition - } - - // Feine Werte um closestValue herum (±4 * 50) - $newValues = []; - for ($i = -4; $i <= 4; $i++) { - $v = $closestValue + ($i * $stepSizeSmall); - if ($v >= $minleistung && $v <= $maxleistung) { - $newValues[] = $v; - } - } - - // Duplikate vermeiden (falls schon Werte vorhanden sind) - $newValues = array_values(array_unique($newValues)); - - // Wenn closestValue exakt im Grundarray war: diesen einen ersetzen - // sonst: feinwerte einfach an der Einfügestelle einfügen - if (array_search($closestValue, $array_powersteps, true) !== false) { - $existingIndex = array_search($closestValue, $array_powersteps, true); - array_splice($array_powersteps, $existingIndex, 1, $newValues); - } else { - array_splice($array_powersteps, $index, 0, $newValues); - } - - // Am Ende sortieren + Duplikate killen (sicher ist sicher) - $array_powersteps = array_values(array_unique($array_powersteps)); - sort($array_powersteps, SORT_NUMERIC); - - return $array_powersteps; -} // Ende Array Steps - - - - public function RequestAction($Ident, $Value) { @@ -220,32 +127,55 @@ public function RequestAction($Ident, $Value) break; default: - throw new Exception("Invalid Ident"); + break; + } } + // Nach aufruf bei anpassung Batteriewerte, sofort Getcurrentdata aufrufen. + public function MessageSink($TimeStamp, $SenderID, $Message, $Data) +{ + if ($Message !== VM_UPDATE) { + return; + } + + $maxBatVar = $this->ReadPropertyInteger("MaxBatterieleistung"); + $maxNachVar = $this->ReadPropertyInteger("MaxNachladen"); + + if ($SenderID === $maxBatVar || $SenderID === $maxNachVar) { + // PowerSteps sofort neu berechnen (mit aktuellem Peak-Status) + $this->GetCurrentData($this->GetValue("Is_Peak_Shaving")); + } +} + + + + // Aktuelle Leistung setzen lassen, der Manager vorgibt public function SetAktuelle_Leistung(int $power) { - $batterietyp = $this->ReadPropertyInteger("Batterietyp"); $batterieManagement = $this->ReadPropertyInteger("Batteriemanagement"); + //Fallunterscheidung, soll Enelix überhaupt steuern? + + // Wechselrichter steuert // Goodwe, Solaredge WR Modus if ($batterieManagement == 1 && ($batterietyp == 1 || $batterietyp == 2)) { $this->SetValue("Entladeleistung", 0); $this->SetValue("Ladeleistung", 0); $this->SetValue("Batteriemanagement_Variabel", 1); return; - //Sig Energy WR Modus - } elseif ($batterieManagement == 1 && $batterietyp == 3) { + //Sig Energy, Herstellerunabhänig im WR Modus + } elseif ($batterieManagement == 1 && ($batterietyp == 0 || $batterietyp == 3)) { $this->SetValue("Entladeleistung", 0); $this->SetValue("Ladeleistung", 0); $this->SetValue("Batteriemanagement_Variabel", 0); return; + // Enelix Steuert // Sig Energy Symcon Modus - } elseif ($batterieManagement == 2 && $batterietyp == 3) { + } elseif ($batterieManagement == 2 && ($batterietyp == 0 || $batterietyp == 3)) { $this->SetValue("Batteriemanagement_Variabel", 1); //Solaredge Symcon Modus @@ -253,12 +183,37 @@ public function RequestAction($Ident, $Value) $this->SetValue("Batteriemanagement_Variabel", 4); } - + // Variabeln entsprechend gewältem Batterietyp setzen $batterietyp = $this->ReadPropertyInteger("Batterietyp"); - if ($batterietyp == 1) {//Goodwe + if ($batterietyp == 0) {//Herstellerunabhängig + + if($this->GetValue("Is_Peak_Shaving")==true){ + + if ($power >= 0) { + $this->SetValue("Ladeleistung", $power); + $this->SetValue("Entladeleistung", 0); + $this->SetValue("Laden_Entladen", 0); + } else { + $this->SetValue("Entladeleistung", abs($power)); + $this->SetValue("Ladeleistung", 0); + $this->SetValue("Laden_Entladen", 1); + } + + }else{ + if ($power >= 0) { + $this->SetValue("Ladeleistung", $power); + $this->SetValue("Entladeleistung", 0); + $this->SetValue("Laden_Entladen", 0); + } else { + $this->SetValue("Entladeleistung", abs($power)); + $this->SetValue("Ladeleistung", 0); + $this->SetValue("Laden_Entladen", 1); + } + } + } + elseif ($batterietyp == 1) {//Goodwe $this->SetValue("Entladeleistung", 0); $this->SetValue("Ladeleistung", 0); - //-----------------------Gooodwee-------------------------------------// if($this->GetValue("Is_Peak_Shaving")==true){ if ($power >= 0) { @@ -283,8 +238,6 @@ public function RequestAction($Ident, $Value) }elseif ($batterietyp == 2) {//Solaredge - //-----------------------Solaredge-------------------------------------// - $this->SetValue("Goodwe_EntLadeleistung",0); if($this->GetValue("Is_Peak_Shaving")==true){ if ($power >= 0) { @@ -310,8 +263,6 @@ public function RequestAction($Ident, $Value) } } elseif ($batterietyp == 3) {//Sig Energy - //-----------------------Sig Energy-------------------------------------// - $this->SetValue("Goodwe_EntLadeleistung",0); if($this->GetValue("Is_Peak_Shaving")==true){ if ($power >= 0) { @@ -363,8 +314,7 @@ public function RequestAction($Ident, $Value) public function GetCurrentData(bool $Peak) { - IPS_LogMessage("Batterie", "Currentdata"); - + // Aktuelle Daten ausarbeiten und Berechnen $array_powersteps = $this->GeneratePowerSteps(); $aufdasnachladen = $this->ReadPropertyInteger("AufdasNachladen"); $minimumentladen = $this->ReadPropertyInteger("MinimumEntladen"); @@ -382,13 +332,7 @@ public function RequestAction($Ident, $Value) $netzbezug = GetValue($this->ReadPropertyInteger("Netzbezug")); $bat_leistung = GetValue($this->ReadPropertyInteger("AktuelleBatterieleistung")); - /* - if (abs($netzbezug) > $maxentladeleistung) { - //$netzbezug = $maxentladeleistung * (-1); - $netzbezug = $netzbezug * (-1); - }*/ - - + if ($Peak && $netzbezug > 0) { $netzbezug = -min($netzbezug, $maxentladeleistung) + $bat_leistung; } @@ -404,7 +348,6 @@ public function RequestAction($Ident, $Value) $hyst = $this->GetValue("Hysterese"); if($Peak){ - IPS_LogMessage("Batterie", "Im if teil"); if($batterieladezustand>$aufdasnachladen && $hyst==false){ @@ -434,11 +377,9 @@ public function RequestAction($Ident, $Value) } }else{ - IPS_LogMessage("Batterie", "Im else teil"); if($batterieladezustand>99){ - IPS_LogMessage("Batterie", "im 1"); $filtered_powersteps = array_filter($array_powersteps, function ($value) { return $value <= 0; @@ -449,7 +390,6 @@ public function RequestAction($Ident, $Value) }elseif($batterieladezustand>$aufdasnachladen && $hyst==false){ $this->SetValue("PowerSteps", json_encode($array_powersteps)); - IPS_LogMessage("Batterie", "im 2"); }elseif($batterieladezustand>=$aufdasnachladen && $hyst==true){ @@ -466,7 +406,6 @@ public function RequestAction($Ident, $Value) //$dummy_array[] = GetValue($this->ReadPropertyInteger("MaxNachladen")); $dummy_array[] = GetValue($this->ReadPropertyInteger("MaxBatterieleistung")); $this->SetValue("PowerSteps", json_encode($dummy_array)); - IPS_LogMessage("Batterie", "im 3"); } @@ -475,10 +414,84 @@ public function RequestAction($Ident, $Value) } + // Ab hier Hilfsfunktionen + +private function GeneratePowerSteps() +{ + // Hilfsfunktion um die Möglichen Powersteps zu generieren + $maxleistung_raw = GetValue($this->ReadPropertyInteger("MaxBatterieleistung")); + $nachladen_raw = GetValue($this->ReadPropertyInteger("MaxNachladen")); + + $stepSize = 250; // Grobe Schrittgröße + $stepSizeSmall = 50; // Feine Schrittgröße + + // Grenzen auf 50er abrunden (floor) + $maxleistung = (int)(floor($maxleistung_raw / $stepSizeSmall) * $stepSizeSmall); + $minleistung = (int)(-floor($nachladen_raw / $stepSizeSmall) * $stepSizeSmall); // negativ! + + // Sicherheitscheck: falls Werte komisch sind + if ($maxleistung < 0) $maxleistung = 0; + if ($minleistung > 0) $minleistung = 0; + + // Grundarray: von min bis max in 250er Schritten + $neg = ($minleistung < 0) ? range($minleistung, 0, $stepSize) : [0]; + $pos = range(0, $maxleistung, $stepSize); + + $array_powersteps = array_values(array_unique(array_merge($neg, $pos))); + sort($array_powersteps, SORT_NUMERIC); + + // Zusätzlichen Wert auf 50er abrunden + $closestValue = (int)(floor($additionalValue / $stepSizeSmall) * $stepSizeSmall); + + // Clamp in den Bereich + if ($closestValue < $minleistung) $closestValue = $minleistung; + if ($closestValue > $maxleistung) $closestValue = $maxleistung; + + // Prüfen ob der Wert im Array existiert (bei 250er Raster oft NICHT) + $index = array_search($closestValue, $array_powersteps, true); + + // Wenn nicht vorhanden: an der richtigen Stelle einsortieren + if ($index === false) { + $index = 0; + $count = count($array_powersteps); + while ($index < $count && $array_powersteps[$index] < $closestValue) { + $index++; + } + } + + // Feine Werte um closestValue herum (±4 * 50) + $newValues = []; + for ($i = -4; $i <= 4; $i++) { + $v = $closestValue + ($i * $stepSizeSmall); + if ($v >= $minleistung && $v <= $maxleistung) { + $newValues[] = $v; + } + } + + // Duplikate vermeiden (falls schon Werte vorhanden sind) + $newValues = array_values(array_unique($newValues)); + + // Wenn closestValue exakt im Grundarray war: diesen einen ersetzen + // sonst: feinwerte einfach an der Einfügestelle einfügen + if (array_search($closestValue, $array_powersteps, true) !== false) { + $existingIndex = array_search($closestValue, $array_powersteps, true); + array_splice($array_powersteps, $existingIndex, 1, $newValues); + } else { + array_splice($array_powersteps, $index, 0, $newValues); + } + + // Am Ende sortieren + $array_powersteps = array_values(array_unique($array_powersteps)); + sort($array_powersteps, SORT_NUMERIC); + + return $array_powersteps; +} + + private function CheckIdle($power) - { + { // Hilfsfunktion zum Prüfen ob die Batterie schon wieder Leistung verändern kann $lastpower = GetValue("Aktuelle_Leistung"); if ($lastpower != GetValue("Aktuelle_Leistung")) { $this->SetValue("Idle", false); diff --git a/Ladestation_v2/form.json b/Ladestation_v2/form.json index 87e2adb..be54d2e 100644 --- a/Ladestation_v2/form.json +++ b/Ladestation_v2/form.json @@ -3,7 +3,7 @@ { "type": "Select", "name": "Ladestation", - "caption": "Ladestation Typ", + "caption": "Ladestation", "options": [ { "caption": "Go-E Wallbox (Alte Version)", diff --git a/Manager/module.php b/Manager/module.php index 9e50ee1..4c78aa4 100644 --- a/Manager/module.php +++ b/Manager/module.php @@ -1,9 +1,11 @@ RegisterPropertyInteger("Peakleistung", 0); $this->RegisterPropertyInteger("Ueberschussleistung", 0); @@ -17,361 +19,461 @@ class Manager extends IPSModule $this->RegisterPropertyInteger("DatenHoch", 0); // Initialisierung mit 0 $this->RegisterPropertyInteger("DatenZuruck", 0); // Initialisierung mit 0 $this->RegisterPropertyInteger("Interval", 2); // Recheninterval + $this->RegisterVariableBoolean("Is_Peak_Shaving", false); + // Timer registrieren - $this->RegisterTimer("Timer_DistributeEnergy", $this->ReadPropertyInteger("Interval") * 1000, "IPS_RequestAction(" . $this->InstanceID . ', "DistributeEnergy", "");'); + + $this->RegisterTimer( + "Timer_DistributeEnergy", + $this->ReadPropertyInteger("Interval") * 1000, + "IPS_RequestAction(" . + $this->InstanceID . + ', "DistributeEnergy", "");' + ); } + public function ApplyChanges() { parent::ApplyChanges(); - $this->SetTimerInterval("Timer_DistributeEnergy", $this->ReadPropertyInteger("Interval") * 1000); + + $this->SetTimerInterval( + "Timer_DistributeEnergy", + $this->ReadPropertyInteger("Interval") * 1000 + ); } + public function RequestAction($Ident, $Value) { - switch ($Ident) - { + switch ($Ident) { case "DistributeEnergy": // Fallunterscheidung, ist der Manager stand-alone oder in einem verbund mit Hauptmanager? - if ($this->ReadPropertyBoolean("HauptmanagerAktiv") == true) - { + if ($this->ReadPropertyBoolean("HauptmanagerAktiv") == true) { // Wenn im Verbund, parse die Verbraucherdaten und sende sie dem Hauptmanager, sofern dieser aktiv ist - $data = json_decode(GetValue($this->ReadPropertyInteger("DatenZuruck")) , true); - if (isset($data["Timestamp"])) - { + $data = json_decode( + GetValue($this->ReadPropertyInteger("DatenZuruck")), + true + ); + + if (isset($data["Timestamp"])) { $timestamp = $data["Timestamp"]; $currentTime = time(); - if ($currentTime - $timestamp < 3600) - { + + if ($currentTime - $timestamp < 3600) { $this->DistributeEnergy_Extern(); - } - else - { - $sendarray = ["Netzbezug" => GetValue($this->ReadPropertyInteger("Netzbezug")) , "Timestamp" => time() , ]; - SetValue($this->ReadPropertyInteger("DatenHoch") , json_encode($sendarray)); + } else { + $sendarray = [ + "Netzbezug" => GetValue( + $this->ReadPropertyInteger("Netzbezug") + ), + "Timestamp" => time(), + ]; + + SetValue( + $this->ReadPropertyInteger("DatenHoch"), + json_encode($sendarray) + ); + $this->DistributeEnergy(); } - } - else - { - $sendarray = ["Netzbezug" => GetValue($this->ReadPropertyInteger("Netzbezug")) , "Timestamp" => time() , ]; - SetValue($this->ReadPropertyInteger("DatenHoch") , json_encode($sendarray)); + } else { + $sendarray = [ + "Netzbezug" => GetValue( + $this->ReadPropertyInteger("Netzbezug") + ), + "Timestamp" => time(), + ]; + + SetValue( + $this->ReadPropertyInteger("DatenHoch"), + json_encode($sendarray) + ); + $this->DistributeEnergy(); } - } - else - { + } else { // wenn stand-alone, rufe einfach die Methode zum verteilen auf $this->DistributeEnergy(); } - break; + + break; + case "ApplyChanges": $this->ApplyChanges(); - break; + break; + default: throw new Exception("Invalid Ident"); } } + public function DistributeEnergy() { // Alle Energieverbraucher auslesen und dekodieren - $Verbraucher_Liste = json_decode($this->ReadPropertyString("Verbraucher_Liste") , true); - if (empty($Verbraucher_Liste)) - { + $Verbraucher_Liste = json_decode( + $this->ReadPropertyString("Verbraucher_Liste"), + true + ); + + if (empty($Verbraucher_Liste)) { // Wenn keine Verbruacher angemeldet sind abbrechen return; } + // Hilfsvariabeln initialiseren + $filteredVerbraucher = []; // Array das später mit allen Verbrauchsdaten der Energieverbraucher gefüllt wird $allIdle = true; // Variable zur Überprüfung, ob alle Benutzer Idle = true sind $totalAktuelle_Leistung = 0; // Variable zur Summierung der Aktuelle_Leistung Werte $helpvar_offset_peakermitteln = 0; // Variable zur Summierung der Aktuelle_Leistung Werte + // Fülle das Array mit allen entsprechenden Werten der Verbraucher ab - foreach ($Verbraucher_Liste as $user) - { + foreach ($Verbraucher_Liste as $user) { // Werte direkt von der Verbraucher-Instanz abrufen - $Aktuelle_Leistung = GetValue(IPS_GetObjectIDByIdent("Power", $user["Verbraucher"])); // Aktuelle Leistung durch Power ersetzt - $Bezogene_Energie = GetValue(IPS_GetObjectIDByIdent("Bezogene_Energie", $user["Verbraucher"])); - $PV_Prio = GetValue(IPS_GetObjectIDByIdent("PV_Prio", $user["Verbraucher"])); - $Sperre_Prio = GetValue(IPS_GetObjectIDByIdent("Sperre_Prio", $user["Verbraucher"])); - $idle = GetValue(IPS_GetObjectIDByIdent("Idle", $user["Verbraucher"])); - $powerStepsJson = GetValue(IPS_GetObjectIDByIdent("PowerSteps", $user["Verbraucher"])); + $Aktuelle_Leistung = GetValue( + IPS_GetObjectIDByIdent("Power", $user["Verbraucher"]) + ); // Aktuelle Leistung durch Power ersetzt + $Bezogene_Energie = GetValue( + IPS_GetObjectIDByIdent("Bezogene_Energie", $user["Verbraucher"]) + ); + $PV_Prio = GetValue( + IPS_GetObjectIDByIdent("PV_Prio", $user["Verbraucher"]) + ); + $Sperre_Prio = GetValue( + IPS_GetObjectIDByIdent("Sperre_Prio", $user["Verbraucher"]) + ); + $idle = GetValue( + IPS_GetObjectIDByIdent("Idle", $user["Verbraucher"]) + ); + $powerStepsJson = GetValue( + IPS_GetObjectIDByIdent("PowerSteps", $user["Verbraucher"]) + ); $powerSteps = json_decode($powerStepsJson, true); - $delta = GetValue(IPS_GetObjectIDByIdent("Leistung_Delta", $user["Verbraucher"])); + $delta = GetValue( + IPS_GetObjectIDByIdent("Leistung_Delta", $user["Verbraucher"]) + ); + // Verbraucher-Daten zum gefilterten Array hinzufügen - $filteredVerbraucher[] = ["Verbraucher" => $user["Verbraucher"], "InstanceID" => $user["Verbraucher"], "Aktuelle_Leistung" => $Aktuelle_Leistung, "Bezogene_Energie" => $Bezogene_Energie, "PV_Prio" => $PV_Prio, "Sperre_Prio" => $Sperre_Prio, "Idle" => $idle, "PowerSteps" => $powerSteps, "Leistung_Delta" => $delta, ]; + $filteredVerbraucher[] = [ + "Verbraucher" => $user["Verbraucher"], + "InstanceID" => $user["Verbraucher"], + "Aktuelle_Leistung" => $Aktuelle_Leistung, + "Bezogene_Energie" => $Bezogene_Energie, + "PV_Prio" => $PV_Prio, + "Sperre_Prio" => $Sperre_Prio, + "Idle" => $idle, + "PowerSteps" => $powerSteps, + "Leistung_Delta" => $delta, + ]; + // Überprüfen, ob alle Benutzer Idle = true sind (bereit für eine Leistungsänderung), wenn einer nicht ist, wird später verworfen... - if (!$idle) - { + if (!$idle) { $allIdle = false; } + // Addiere die aktuell bereits verwendete Leistung auf, um sie bei der verteilung zu berücksichtigen $totalAktuelle_Leistung += $Aktuelle_Leistung - $delta; } + // Variante der Leistungsregelung (Überschuss, Peak) ermitteln und aktuellen Netzbezug bereitstellen $Netzbezug = GetValue($this->ReadPropertyInteger("Netzbezug")); $Peakleistung = $this->ReadPropertyInteger("Peakleistung"); - $Ueberschussleistung = $this->ReadPropertyInteger("Ueberschussleistung"); + $Ueberschussleistung = $this->ReadPropertyInteger( + "Ueberschussleistung" + ); + // Dynamische ermittlung der Betriebsart - if ($this->ReadPropertyBoolean("UmschaltpunktStatisch") == false) - { + if ($this->ReadPropertyBoolean("UmschaltpunktStatisch") == false) { // Fallunterscheidung ob auf Solarladen oder Peakshaving gerregelt wird. - if ($Netzbezug < ($Peakleistung + $Ueberschussleistung) / 2) - { - $remainingPower = - 1 * (-1 * $Ueberschussleistung + $Netzbezug); + if ($Netzbezug < ($Peakleistung + $Ueberschussleistung) / 2) { + $remainingPower = -1 * (-1 * $Ueberschussleistung + $Netzbezug); $Is_Peak_Shaving = false; - } - else - { + } else { $remainingPower = $Peakleistung - $Netzbezug; $Is_Peak_Shaving = true; } } // Statische ermittlung der Betriebsart - else - { - if ($Netzbezug < $this->ReadPropertyInteger("Umschalt_Solarladen")) - { - $remainingPower = - 1 * (-1 * $Ueberschussleistung + $Netzbezug); + else { + if ( + $Netzbezug < $this->ReadPropertyInteger("Umschalt_Solarladen") + ) { + $remainingPower = -1 * (-1 * $Ueberschussleistung + $Netzbezug); $Is_Peak_Shaving = false; - } - elseif ($Netzbezug > $this->ReadPropertyInteger("Umschalt_Peakshaving")) - { + } elseif ( + $Netzbezug > $this->ReadPropertyInteger("Umschalt_Peakshaving") + ) { $remainingPower = $Peakleistung - $Netzbezug; $Is_Peak_Shaving = true; - } - elseif ($this->GetValue("Is_Peak_Shaving") == false) - { - $remainingPower = - 1 * (-1 * $Ueberschussleistung + $Netzbezug); + } elseif ($this->GetValue("Is_Peak_Shaving") == false) { + $remainingPower = -1 * (-1 * $Ueberschussleistung + $Netzbezug); $Is_Peak_Shaving = false; - } - elseif ($this->GetValue("Is_Peak_Shaving") == true) - { + } elseif ($this->GetValue("Is_Peak_Shaving") == true) { $remainingPower = $Peakleistung - $Netzbezug; $Is_Peak_Shaving = true; } } + // Aktuelle bereits verwendete Leistung auf die verbleibende Leistung als Offset summieren. $remainingPower += $totalAktuelle_Leistung; + // Frage alle Energieverbraucher ab, was sie für Leistungen benötigen könnten - foreach ($Verbraucher_Liste as $user) - { - if (IPS_InstanceExists($user["Verbraucher"])) - { - IPS_RequestAction($user["Verbraucher"], "GetCurrentData", $Is_Peak_Shaving); + foreach ($Verbraucher_Liste as $user) { + if (IPS_InstanceExists($user["Verbraucher"])) { + IPS_RequestAction( + $user["Verbraucher"], + "GetCurrentData", + $Is_Peak_Shaving + ); } } + // Abbrechen wenn es keine Verbruacher gibt, die verfügbar sind - if (empty($filteredVerbraucher)) - { + if (empty($filteredVerbraucher)) { return; } + // Wenn nicht alle Benutzer Idle = true sind, oder sich der zustand von Is_Peak_shaving gerade verändert hat rufe SetAktuelle_Leistung mit Aktuelle_Leistung Werten auf, (alle Verbraucher behalten die aktuelle Leistung) - if (!$allIdle || $Is_Peak_Shaving != $this->GetValue("Is_Peak_Shaving")) - { - foreach ($filteredVerbraucher as $user) - { - IPS_RequestAction($user["InstanceID"], "SetAktuelle_Leistung", $user["Aktuelle_Leistung"]); + if ( + !$allIdle || + $Is_Peak_Shaving != $this->GetValue("Is_Peak_Shaving") + ) { + foreach ($filteredVerbraucher as $user) { + IPS_RequestAction( + $user["InstanceID"], + "SetAktuelle_Leistung", + $user["Aktuelle_Leistung"] + ); } $this->SetValue("Is_Peak_Shaving", $Is_Peak_Shaving); + return; } + $this->SetValue("Is_Peak_Shaving", $Is_Peak_Shaving); + // Sortiere die Verbruacher nach Priorität entweder der PV_Prio oder der Peak Prio - usort($filteredVerbraucher, function ($a, $b) use ($Is_Peak_Shaving) - { + usort($filteredVerbraucher, function ($a, $b) use ($Is_Peak_Shaving) { $primaryKey = $Is_Peak_Shaving ? "Sperre_Prio" : "PV_Prio"; // Wenn die Prio geleich ist, sortiere danach welcher verbraucher bisher am wenigsten Energie bekommen hat. - if ($a[$primaryKey] == $b[$primaryKey]) - { - return round($a["Bezogene_Energie"] / 2000) <= round($b["Bezogene_Energie"] / 2000); + if ($a[$primaryKey] == $b[$primaryKey]) { + return round($a["Bezogene_Energie"] / 2000) <=> + round($b["Bezogene_Energie"] / 2000); } - return $a[$primaryKey] <= $b[$primaryKey]; + return $a[$primaryKey] <=> $b[$primaryKey]; }); + // Primärschlüssel für die Priorität basierend auf dem Parameter auswählen (für sortierung in gruppen anschliessend) $priorityKey = $Is_Peak_Shaving ? "Sperre_Prio" : "PV_Prio"; + // Schleife durch alle Prioritäten - $priorities = array_unique(array_column($filteredVerbraucher, $priorityKey)); + $priorities = array_unique( + array_column($filteredVerbraucher, $priorityKey) + ); $groupedUsers = []; - foreach ($priorities as $priority) - { - $groupedUsers[$priority] = array_filter($filteredVerbraucher, function ($user) use ($priority, $priorityKey) - { - return $user[$priorityKey] == $priority; - }); + + foreach ($priorities as $priority) { + $groupedUsers[$priority] = array_filter( + $filteredVerbraucher, + function ($user) use ($priority, $priorityKey) { + return $user[$priorityKey] == $priority; + } + ); } + // Jetzt werden die energien pro gruppe verteilt (Immer alle pro prio in einer gruppe miteinander) - foreach ($groupedUsers as $priority => $users) - { + foreach ($groupedUsers as $priority => $users) { // Verbraucher mit gleicher Priorität sammeln - $samePriorityUsers = isset($groupedUsers[$priority]) ? $groupedUsers[$priority] : []; + $samePriorityUsers = isset($groupedUsers[$priority]) + ? $groupedUsers[$priority] + : []; + // Wenn keine Verbraucher mit gleicher Priorität vorhanden sind, überspringen - if (empty($samePriorityUsers)) - { + if (empty($samePriorityUsers)) { continue; } $withZero = []; $withoutZeroHigh = []; $withoutZeroLow = []; + // Sammle alle Verbraucher die nicht null als Verbruach annehmen können. (inkl. sortierung in positive und Negative) - foreach ($samePriorityUsers as $entry) - { + foreach ($samePriorityUsers as $entry) { $withZero[] = $entry; - if (min($entry["PowerSteps"]) > 0) - { + + if (min($entry["PowerSteps"]) > 0) { $withoutZeroHigh[] = $entry; } - if (max($entry["PowerSteps"]) < 0) - { + if (max($entry["PowerSteps"]) < 0) { $withoutZeroLow[] = $entry; } } + // positiven Verbrauchern die nicht 0 annhemen können bereits den minimalwert zuteilen - if (!empty($withoutZeroHigh)) - { - foreach ($withoutZeroHigh as $entry) - { + if (!empty($withoutZeroHigh)) { + foreach ($withoutZeroHigh as $entry) { $instanceID = $entry["InstanceID"]; $minPowerStep = min($entry["PowerSteps"]); } } // negativen Verbrauchern die nicht 0 annhemen können bereits den minimalwert zuteilen - if (!empty($withoutZeroLow)) - { - foreach ($withoutZeroLow as $entry) - { + if (!empty($withoutZeroLow)) { + foreach ($withoutZeroLow as $entry) { $instanceID = $entry["InstanceID"]; $minPowerStep = max($entry["PowerSteps"]); } } + // Nun die Verbrucher verteilen, die auch 0 erhalten können. $samePriorityUsers = $withZero; + $userEnergyProv = []; - foreach ($samePriorityUsers as $entry) - { + + foreach ($samePriorityUsers as $entry) { $instanceID = $entry["InstanceID"]; // Schutz: falls PowerSteps nicht gesetzt oder kein Array ist - $steps = isset($entry["PowerSteps"]) && is_array($entry["PowerSteps"]) ? $entry["PowerSteps"] : [0]; + $steps = + isset($entry["PowerSteps"]) && + is_array($entry["PowerSteps"]) + ? $entry["PowerSteps"] + : [0]; + // Wenn 0 als möglicher Step vorhanden ist -> 0 setzen + $minStep = min($steps); $maxStep = max($steps); - if (in_array(0, $steps, true)) - { + + if (in_array(0, $steps, true)) { $userEnergyProv[$instanceID] = 0; continue; - } - elseif ($minStep > 0) - { + } elseif ($minStep > 0) { // nur positive Schritte -> minimalen positiven Wert einsetzen $userEnergyProv[$instanceID] = $minStep; // entspricht deinem vorherigen Verhalten: remainingPower reduzieren $remainingPower -= $minStep; - } - elseif ($maxStep < 0) - { + } elseif ($maxStep < 0) { // nur negative Schritte -> maximalen (am wenigsten negativen) Wert einsetzen $userEnergyProv[$instanceID] = $maxStep; // entspricht deinem vorherigen Verhalten: remainingPower erhöhen (maxStep ist negativ) $remainingPower += $maxStep; - } - else - { + } else { // Mixed (positive & negative) aber kein 0 -> Fallback 0 (ändere wenn nötig) $userEnergyProv[$instanceID] = 0; } } + // Beginne mit aktiver Verteilung - if ($remainingPower >= 0) - { + if ($remainingPower >= 0) { // Alle Schritte der Benutzer in einem Array sammeln $allSteps = []; - foreach ($samePriorityUsers as $user) - { - foreach ($user["PowerSteps"] as $step) - { - if ($step >= 0) - { - $allSteps[] = ["user" => $user["InstanceID"], - //"Leistung_Delta" => $user["Leistung_Delta"], - "step" => $step, ]; + foreach ($samePriorityUsers as $user) { + foreach ($user["PowerSteps"] as $step) { + if ($step >= 0) { + $allSteps[] = [ + "user" => $user["InstanceID"], + //"Leistung_Delta" => $user["Leistung_Delta"], + "step" => $step, + ]; } } } + // Sortiere die Schritte nach Größe - usort($allSteps, function ($a, $b) - { - return $a["step"] <= $b["step"]; + usort($allSteps, function ($a, $b) { + return $a["step"] <=> $b["step"]; }); + //if remaining power >0 // Iteriere durch alle Schritte - foreach ($allSteps as $entry) - { + foreach ($allSteps as $entry) { $user = $entry["user"]; $powerstep = $entry["step"]; + // Überprüfe, ob noch genügend verbleibende Energie für den nächsten Schritt vorhanden ist - if ($remainingPower >= $powerstep - $userEnergyProv[$user]) - { + if ( + $remainingPower >= + $powerstep - $userEnergyProv[$user] + ) { // oder bedingung testen // Aktualisiere die verbleibende Energie und die bereitgestellte Energie für den Benutzer $remainingPower -= $powerstep - $userEnergyProv[$user]; $userEnergyProv[$user] = $powerstep; } } + // Prüfen, dass jeder User mindestens seinen minimalwert an Leistung bekommt - foreach ($userEnergyProv as $userInstanceID => $leistung) - { + foreach ($userEnergyProv as $userInstanceID => $leistung) { // Innerhalb der Schleife: alle nicht-negativen Leistungen sammeln - $positiveValues = array_filter(array_column($samePriorityUsers, "PowerSteps", "InstanceID") [$userInstanceID], function ($l) - { - return $l >= 0; - }); + $positiveValues = array_filter( + array_column( + $samePriorityUsers, + "PowerSteps", + "InstanceID" + )[$userInstanceID], + function ($l) { + return $l >= 0; + } + ); // Falls keine Werte ≥ 0 vorhanden sind, auf 0 zurückfallen - $fallbackMinimum = empty($positiveValues) ? max(array_column($samePriorityUsers, "PowerSteps", "InstanceID") [$userInstanceID]) : min($positiveValues); + $fallbackMinimum = empty($positiveValues) + ? max( + array_column( + $samePriorityUsers, + "PowerSteps", + "InstanceID" + )[$userInstanceID] + ) + : min($positiveValues); + // minimalleistung = dieser Fallback $minimalleistung = $fallbackMinimum; + //den höheren Wert wählen und für IPS negativieren - if (abs($leistung) > abs($minimalleistung)) - { + + if (abs($leistung) > abs($minimalleistung)) { $schreibleistung = $leistung; - } - else - { + } else { $schreibleistung = $minimalleistung; } + // Die Veteilten Leistungen auf die Verbruacher schreiben - if (IPS_InstanceExists($userInstanceID)) - { - IPS_RequestAction($userInstanceID, "SetAktuelle_Leistung", $schreibleistung); + if (IPS_InstanceExists($userInstanceID)) { + IPS_RequestAction( + $userInstanceID, + "SetAktuelle_Leistung", + $schreibleistung + ); } } - } - else - { + } else { // Alle Schritte der Benutzer in einem Array sammeln $allSteps = []; - foreach ($samePriorityUsers as $user) - { - foreach ($user["PowerSteps"] as $step) - { - if ($step <= 0) - { - $allSteps[] = ["user" => $user["InstanceID"], "step" => - 1 * $step, ]; + foreach ($samePriorityUsers as $user) { + foreach ($user["PowerSteps"] as $step) { + if ($step <= 0) { + $allSteps[] = [ + "user" => $user["InstanceID"], + "step" => -1 * $step, + ]; } } } + // Sortiere die Schritte nach Größe - usort($allSteps, function ($a, $b) - { - return $a["step"] <= $b["step"]; + usort($allSteps, function ($a, $b) { + return $a["step"] <=> $b["step"]; }); + $remainingPower = $remainingPower * -1; // Iteriere durch alle Schritte - foreach ($allSteps as $entry) - { + foreach ($allSteps as $entry) { $user = $entry["user"]; $powerstep = $entry["step"]; + // Überprüfe, ob noch genügend verbleibende Energie für den nächsten Schritt vorhanden ist - if ($remainingPower >= $powerstep - $userEnergyProv[$user]) - { + if ( + $remainingPower >= + $powerstep - $userEnergyProv[$user] + ) { // oder bedingung testen // Aktualisiere die verbleibende Energie und die bereitgestellte Energie für den Benutzer $remainingPower -= $powerstep - $userEnergyProv[$user]; @@ -379,65 +481,139 @@ class Manager extends IPSModule } } $remainingPower = $remainingPower * -1; + // Prüfen, dass jeder User mindestens seinen minimalwert an Leistung bekommt - foreach ($userEnergyProv as $userInstanceID => $leistung) - { + foreach ($userEnergyProv as $userInstanceID => $leistung) { // Innerhalb der Schleife: alle nicht-negativen Leistungen sammeln - $positiveValues = array_filter(array_column($samePriorityUsers, "PowerSteps", "InstanceID") [$userInstanceID], function ($l) - { - return $l <= 0; - }); + $positiveValues = array_filter( + array_column( + $samePriorityUsers, + "PowerSteps", + "InstanceID" + )[$userInstanceID], + function ($l) { + return $l <= 0; + } + ); // Falls keine Werte ≥ 0 vorhanden sind, auf 0 zurückfallen - $fallbackMinimum = empty($positiveValues) ? min(array_column($samePriorityUsers, "PowerSteps", "InstanceID") [$userInstanceID]) : max($positiveValues); + $fallbackMinimum = empty($positiveValues) + ? min( + array_column( + $samePriorityUsers, + "PowerSteps", + "InstanceID" + )[$userInstanceID] + ) + : max($positiveValues); + // minimalleistung = dieser Fallback $minimalleistung = $fallbackMinimum; + // den höheren Wert wählen und negieren - if (abs($leistung) > abs($minimalleistung)) - { + + if (abs($leistung) > abs($minimalleistung)) { $schreibleistung = $leistung * -1; - } - else - { + } else { $schreibleistung = $minimalleistung; } + // Die Veteilten Leistungen auf die Verbruacher schreiben - if (IPS_InstanceExists($userInstanceID)) - { - IPS_RequestAction($userInstanceID, "SetAktuelle_Leistung", $schreibleistung); + if (IPS_InstanceExists($userInstanceID)) { + IPS_RequestAction( + $userInstanceID, + "SetAktuelle_Leistung", + $schreibleistung + ); } } } } } + public function DistributeEnergy_Extern() { // Systemvariablen abrufen $Netzbezug = GetValue($this->ReadPropertyInteger("Netzbezug")); - $Verbraucher_Liste = json_decode($this->ReadPropertyString("Verbraucher_Liste") , true); + + $Verbraucher_Liste = json_decode( + $this->ReadPropertyString("Verbraucher_Liste"), + true + ); $filteredVerbraucher = []; // Fülle das Array mit allen entsprechenden Werten der Verbraucher ab - foreach ($Verbraucher_Liste as $user) - { + foreach ($Verbraucher_Liste as $user) { // Werte direkt von der Verbraucher-Instanz abrufen - $Aktuelle_Leistung = GetValue(IPS_GetObjectIDByIdent("Aktuelle_Leistung", $user["Verbraucher"])); - $Bezogene_Energie = GetValue(IPS_GetObjectIDByIdent("Bezogene_Energie", $user["Verbraucher"])); - $PV_Prio = GetValue(IPS_GetObjectIDByIdent("PV_Prio", $user["Verbraucher"])); - $Sperre_Prio = GetValue(IPS_GetObjectIDByIdent("Sperre_Prio", $user["Verbraucher"])); - $idle = GetValue(IPS_GetObjectIDByIdent("Idle", $user["Verbraucher"])); - $powerStepsJson = GetValue(IPS_GetObjectIDByIdent("PowerSteps", $user["Verbraucher"])); - $delta = GetValue(IPS_GetObjectIDByIdent("Leistung_Delta", $user["Verbraucher"])); + $Aktuelle_Leistung = GetValue( + IPS_GetObjectIDByIdent( + "Aktuelle_Leistung", + $user["Verbraucher"] + ) + ); + $Bezogene_Energie = GetValue( + IPS_GetObjectIDByIdent("Bezogene_Energie", $user["Verbraucher"]) + ); + $PV_Prio = GetValue( + IPS_GetObjectIDByIdent("PV_Prio", $user["Verbraucher"]) + ); + $Sperre_Prio = GetValue( + IPS_GetObjectIDByIdent("Sperre_Prio", $user["Verbraucher"]) + ); + $idle = GetValue( + IPS_GetObjectIDByIdent("Idle", $user["Verbraucher"]) + ); + $powerStepsJson = GetValue( + IPS_GetObjectIDByIdent("PowerSteps", $user["Verbraucher"]) + ); + $delta = GetValue( + IPS_GetObjectIDByIdent("Leistung_Delta", $user["Verbraucher"]) + ); $powerSteps = json_decode($powerStepsJson, true); + // Verbraucher-Daten zum gefilterten Array hinzufügen - $filteredVerbraucher[] = ["Verbraucher" => $user["Verbraucher"], "InstanceID" => $user["Verbraucher"], "Aktuelle_Leistung" => $Aktuelle_Leistung, "Bezogene_Energie" => $Bezogene_Energie, "PV_Prio" => $PV_Prio, "Sperre_Prio" => $Sperre_Prio, "Idle" => $idle, "PowerSteps" => $powerSteps, "Leistung_Delta" => $delta, "ParentManager" => $this->ReadPropertyInteger("ManagerID") , ]; + $filteredVerbraucher[] = [ + "Verbraucher" => $user["Verbraucher"], + "InstanceID" => $user["Verbraucher"], + "Aktuelle_Leistung" => $Aktuelle_Leistung, + "Bezogene_Energie" => $Bezogene_Energie, + "PV_Prio" => $PV_Prio, + "Sperre_Prio" => $Sperre_Prio, + "Idle" => $idle, + "PowerSteps" => $powerSteps, + "Leistung_Delta" => $delta, + "ParentManager" => $this->ReadPropertyInteger("ManagerID"), + ]; } + $sendarray = []; - $sendarray = ["User" => $filteredVerbraucher, "Netzbezug" => $Netzbezug, "Timestamp" => time() , ]; - SetValue($this->ReadPropertyInteger("DatenHoch") , json_encode($sendarray)); - $answerArray = json_decode(GetValue($this->ReadPropertyInteger("DatenZuruck")) , true); - foreach ($answerArray["User"] as $user) - { - IPS_RequestAction($user["InstanceID"], "GetCurrentData", $answerArray["Is_Peak_Shaving"]); - IPS_RequestAction($user["InstanceID"], "SetAktuelle_Leistung", $user["Set_Leistung"]); + + $sendarray = [ + "User" => $filteredVerbraucher, + "Netzbezug" => $Netzbezug, + "Timestamp" => time(), + ]; + + SetValue( + $this->ReadPropertyInteger("DatenHoch"), + json_encode($sendarray) + ); + + $answerArray = json_decode( + GetValue($this->ReadPropertyInteger("DatenZuruck")), + true + ); + + foreach ($answerArray["User"] as $user) { + IPS_RequestAction( + $user["InstanceID"], + "GetCurrentData", + $answerArray["Is_Peak_Shaving"] + ); + + IPS_RequestAction( + $user["InstanceID"], + "SetAktuelle_Leistung", + $user["Set_Leistung"] + ); } } }