no message

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("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->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
+            //Sig Energy, Herstellerunabhänig im WR Modus
-            } elseif ($batterieManagement == 1 && $batterietyp == 3) {
+            } 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);

Ladestation_v2/form.json

@@ -3,7 +3,7 @@
         {
             "type": "Select",
             "name": "Ladestation",
-            "caption": "Ladestation Typ",
+            "caption": "Ladestation",
             "options": [
                 {
                     "caption": "Go-E Wallbox (Alte Version)",

Manager/module.php

@@ -1,9 +1,11 @@
 <?php
+
 class Manager extends IPSModule
 {
     public function Create()
     {
         parent::Create();
+
         // Properies und Systemvariablen registrieren
         $this->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);
+                    $data = json_decode(
-                    if (isset($data["Timestamp"]))
+                        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 {
-                        else
+                            $sendarray = [
-                        {
+                                "Netzbezug" => GetValue(
-                            $sendarray = ["Netzbezug" => GetValue($this->ReadPropertyInteger("Netzbezug")) , "Timestamp" => time() , ];
+                                    $this->ReadPropertyInteger("Netzbezug")
-                            SetValue($this->ReadPropertyInteger("DatenHoch") , json_encode($sendarray));
+                                ),
+                                "Timestamp" => time(),
+                            ];
+
+                            SetValue(
+                                $this->ReadPropertyInteger("DatenHoch"),
+                                json_encode($sendarray)
+                            );
+
                             $this->DistributeEnergy();
                         }
-                    }
+                    } else {
-                    else
+                        $sendarray = [
-                    {
+                            "Netzbezug" => GetValue(
-                        $sendarray = ["Netzbezug" => GetValue($this->ReadPropertyInteger("Netzbezug")) , "Timestamp" => time() , ];
+                                $this->ReadPropertyInteger("Netzbezug")
-                        SetValue($this->ReadPropertyInteger("DatenHoch") , json_encode($sendarray));
+                            ),
+                            "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);
+        $Verbraucher_Liste = json_decode(
-        if (empty($Verbraucher_Liste))
+            $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
+            $Aktuelle_Leistung = GetValue(
-            $Bezogene_Energie = GetValue(IPS_GetObjectIDByIdent("Bezogene_Energie", $user["Verbraucher"]));
+                IPS_GetObjectIDByIdent("Power", $user["Verbraucher"])
-            $PV_Prio = GetValue(IPS_GetObjectIDByIdent("PV_Prio", $user["Verbraucher"]));
+            ); // Aktuelle Leistung durch Power ersetzt
-            $Sperre_Prio = GetValue(IPS_GetObjectIDByIdent("Sperre_Prio", $user["Verbraucher"]));
+            $Bezogene_Energie = GetValue(
-            $idle = GetValue(IPS_GetObjectIDByIdent("Idle", $user["Verbraucher"]));
+                IPS_GetObjectIDByIdent("Bezogene_Energie", $user["Verbraucher"])
-            $powerStepsJson = GetValue(IPS_GetObjectIDByIdent("PowerSteps", $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)
+            if ($Netzbezug < ($Peakleistung + $Ueberschussleistung) / 2) {
-            {
+                $remainingPower = -1 * (-1 * $Ueberschussleistung + $Netzbezug);
-                $remainingPower = - 1 * (-1 * $Ueberschussleistung + $Netzbezug);
                 $Is_Peak_Shaving = false;
-            }
+            } else {
-            else
-            {
                 $remainingPower = $Peakleistung - $Netzbezug;
                 $Is_Peak_Shaving = true;
             }
         }
         // Statische ermittlung der Betriebsart
-        else
+        else {
-        {
+            if (
-            if ($Netzbezug < $this->ReadPropertyInteger("Umschalt_Solarladen"))
+                $Netzbezug < $this->ReadPropertyInteger("Umschalt_Solarladen")
-            {
+            ) {
-                $remainingPower = - 1 * (-1 * $Ueberschussleistung + $Netzbezug);
+                $remainingPower = -1 * (-1 * $Ueberschussleistung + $Netzbezug);
                 $Is_Peak_Shaving = false;
-            }
+            } elseif (
-            elseif ($Netzbezug > $this->ReadPropertyInteger("Umschalt_Peakshaving"))
+                $Netzbezug > $this->ReadPropertyInteger("Umschalt_Peakshaving")
-            {
+            ) {
                 $remainingPower = $Peakleistung - $Netzbezug;
                 $Is_Peak_Shaving = true;
-            }
+            } elseif ($this->GetValue("Is_Peak_Shaving") == false) {
-            elseif ($this->GetValue("Is_Peak_Shaving") == false)
+                $remainingPower = -1 * (-1 * $Ueberschussleistung + $Netzbezug);
-            {
-                $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)
+        foreach ($Verbraucher_Liste as $user) {
-        {
+            if (IPS_InstanceExists($user["Verbraucher"])) {
-            if (IPS_InstanceExists($user["Verbraucher"]))
+                IPS_RequestAction(
-            {
+                    $user["Verbraucher"],
-                IPS_RequestAction($user["Verbraucher"], "GetCurrentData", $Is_Peak_Shaving);
+                    "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"))
+        if (
-        {
+            !$allIdle ||
-            foreach ($filteredVerbraucher as $user)
+            $Is_Peak_Shaving != $this->GetValue("Is_Peak_Shaving")
-            {
+        ) {
-                IPS_RequestAction($user["InstanceID"], "SetAktuelle_Leistung", $user["Aktuelle_Leistung"]);
+            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])
+            if ($a[$primaryKey] == $b[$primaryKey]) {
-            {
+                return round($a["Bezogene_Energie"] / 2000) <=>
-                return round($a["Bezogene_Energie"] / 2000) <= round($b["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)
+
-        {
+        foreach ($priorities as $priority) {
-            $groupedUsers[$priority] = array_filter($filteredVerbraucher, function ($user) use ($priority, $priorityKey)
+            $groupedUsers[$priority] = array_filter(
-            {
+                $filteredVerbraucher,
-                return $user[$priorityKey] == $priority;
+                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))
+            if (!empty($withoutZeroHigh)) {
-            {
+                foreach ($withoutZeroHigh as $entry) {
-                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))
+            if (!empty($withoutZeroLow)) {
-            {
+                foreach ($withoutZeroLow as $entry) {
-                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 ($samePriorityUsers as $user) {
-                {
+                    foreach ($user["PowerSteps"] as $step) {
-                    foreach ($user["PowerSteps"] as $step)
+                        if ($step >= 0) {
-                    {
+                            $allSteps[] = [
-                        if ($step >= 0)
+                                "user" => $user["InstanceID"],
-                        {
+                                //"Leistung_Delta" => $user["Leistung_Delta"],
-                            $allSteps[] = ["user" => $user["InstanceID"],
+                                "step" => $step,
-                            //"Leistung_Delta" => $user["Leistung_Delta"],
+                            ];
-                            "step" => $step, ];
                         }
                     }
                 }
+
                 // Sortiere die Schritte nach Größe
-                usort($allSteps, function ($a, $b)
+                usort($allSteps, function ($a, $b) {
-                {
+                    return $a["step"] <=> $b["step"];
-                    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)
+                    $positiveValues = array_filter(
-                    {
+                        array_column(
-                        return $l >= 0;
+                            $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))
+                    if (IPS_InstanceExists($userInstanceID)) {
-                    {
+                        IPS_RequestAction(
-                        IPS_RequestAction($userInstanceID, "SetAktuelle_Leistung", $schreibleistung);
+                            $userInstanceID,
+                            "SetAktuelle_Leistung",
+                            $schreibleistung
+                        );
                     }
                 }
-            }
+            } else {
-            else
-            {
                 // Alle Schritte der Benutzer in einem Array sammeln
                 $allSteps = [];
-                foreach ($samePriorityUsers as $user)
+                foreach ($samePriorityUsers as $user) {
-                {
+                    foreach ($user["PowerSteps"] as $step) {
-                    foreach ($user["PowerSteps"] as $step)
+                        if ($step <= 0) {
-                    {
+                            $allSteps[] = [
-                        if ($step <= 0)
+                                "user" => $user["InstanceID"],
-                        {
+                                "step" => -1 * $step,
-                            $allSteps[] = ["user" => $user["InstanceID"], "step" => - 1 * $step, ];
+                            ];
                         }
                     }
                 }
+
                 // Sortiere die Schritte nach Größe
-                usort($allSteps, function ($a, $b)
+                usort($allSteps, function ($a, $b) {
-                {
+                    return $a["step"] <=> $b["step"];
-                    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)
+                    $positiveValues = array_filter(
-                    {
+                        array_column(
-                        return $l <= 0;
+                            $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))
+                    if (IPS_InstanceExists($userInstanceID)) {
-                    {
+                        IPS_RequestAction(
-                        IPS_RequestAction($userInstanceID, "SetAktuelle_Leistung", $schreibleistung);
+                            $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"]));
+            $Aktuelle_Leistung = GetValue(
-            $Bezogene_Energie = GetValue(IPS_GetObjectIDByIdent("Bezogene_Energie", $user["Verbraucher"]));
+                IPS_GetObjectIDByIdent(
-            $PV_Prio = GetValue(IPS_GetObjectIDByIdent("PV_Prio", $user["Verbraucher"]));
+                    "Aktuelle_Leistung",
-            $Sperre_Prio = GetValue(IPS_GetObjectIDByIdent("Sperre_Prio", $user["Verbraucher"]));
+                    $user["Verbraucher"]
-            $idle = GetValue(IPS_GetObjectIDByIdent("Idle", $user["Verbraucher"]));
+                )
-            $powerStepsJson = GetValue(IPS_GetObjectIDByIdent("PowerSteps", $user["Verbraucher"]));
+            );
-            $delta = GetValue(IPS_GetObjectIDByIdent("Leistung_Delta", $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));
+        $sendarray = [
-        $answerArray = json_decode(GetValue($this->ReadPropertyInteger("DatenZuruck")) , true);
+            "User" => $filteredVerbraucher,
-        foreach ($answerArray["User"] as $user)
+            "Netzbezug" => $Netzbezug,
-        {
+            "Timestamp" => time(),
-            IPS_RequestAction($user["InstanceID"], "GetCurrentData", $answerArray["Is_Peak_Shaving"]);
+        ];
-            IPS_RequestAction($user["InstanceID"], "SetAktuelle_Leistung", $user["Set_Leistung"]);
+
+        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"]
+            );
         }
     }
 }