Readme und Formatierung module.php angepasst

Batterie/README.md

@@ -84,7 +84,6 @@ Dieses Modul integriert Batteriespeicher als steuerbare Verbraucher/Erzeuger in
 | **Bezogene_Energie** | Float | Rechnerisch aufsummierte Energie (Leistung × Zeit). |
 | **PV_Prio** | Integer | Priorität des Verbrauchers für PV-Optimierung, Tiefe Nummer = Hohe Priorität |
 | **Sperre_Prio** | Integer | Priorität des Verbrauchers für Peak-Optimierung, Tiefe Nummer = Hohe Priorität |
-| **Bezogene_Energie** | Float | Rechnerisch aufsummierte Energie (Leistung × Zeit). |
 | **Is_Peak_Shaving** | Boolean | Vom Manager übermittelter aktueller Betriebsmodus. |
 | **Goodwe_EntLadeleistung** | Interner | Zusatzvariable für Steuerung der Sollleistung bei Goodwespeichern |
 | **Ladeleistung** | Interner | Sollladelesistung Speicher |
@@ -97,13 +96,13 @@ Dieses Modul integriert Batteriespeicher als steuerbare Verbraucher/Erzeuger in
 ## 6. WebFront / Bedienung
 
 Die Anbindung der Batterie sowie die regelung der Prioritäten wird über folgende Variabeln eingestellt:
-`Laden_Entladen`- Signalisation ob Speicher laden soll oder entladen (Herstellerunabhängig 0 = Laden, 1 = Entladen, ansonsten Herstellerabhängige Werte)
+- `Laden_Entladen`- Signalisation ob Speicher laden soll oder entladen (Herstellerunabhängig 0 = Laden, 1 = Entladen, ansonsten Herstellerabhängige Werte)
-`Ladeleistung` - Soll Ladeleistung Speicher
+- `Ladeleistung` - Soll Ladeleistung Speicher
-`Entladeleistung` - Soll Entladeleistung Speicher
+- `Entladeleistung` - Soll Entladeleistung Speicher
-`Goodwe_EntLadeleistung`- Zusatzvariable Entladeleistung für Goodwe-Speicher
+- `Goodwe_EntLadeleistung`- Zusatzvariable Entladeleistung für Goodwe-Speicher
 
-`PV_Prio` -  Priorität des Verbrauchers für PV-Optimierung, Tiefe Nummer = Hohe Priorität 
+- `PV_Prio` -  Priorität des Verbrauchers für PV-Optimierung, Tiefe Nummer = Hohe Priorität 
-`Sperre_Prio` - Priorität des Verbrauchers für Peak-Optimierung, Tiefe Nummer = Hohe Priorität
+- `Sperre_Prio` - Priorität des Verbrauchers für Peak-Optimierung, Tiefe Nummer = Hohe Priorität
 
 ## 7. Mapping auf Code-Komponenten
 

Batterie/module.php

@@ -1,527 +1,512 @@
 <?php
-
 class Batterie extends IPSModule
 {
     public function Create()
     {
         parent::Create();
-
         // Batterie spezifische Eigenschaften
         $this->RegisterPropertyInteger("MaxBatterieleistung", 0);
         $this->RegisterPropertyInteger("Batteriespannung", 50);
-        $this->RegisterPropertyInteger("AufdasNachladen",0);
+        $this->RegisterPropertyInteger("AufdasNachladen", 0);
-        $this->RegisterPropertyInteger("MinimumEntladen",0);
+        $this->RegisterPropertyInteger("MinimumEntladen", 0);
-        $this->RegisterPropertyInteger("Batterieladezustand",0);
+        $this->RegisterPropertyInteger("Batterieladezustand", 0);
-        $this->RegisterPropertyInteger("Batteriemanagement", 1); 
+        $this->RegisterPropertyInteger("Batteriemanagement", 1);
-        $this->RegisterPropertyInteger("Batterietyp", 1);   
+        $this->RegisterPropertyInteger("Batterietyp", 1);
-        $this->RegisterPropertyInteger("MaxNachladen",0);
+        $this->RegisterPropertyInteger("MaxNachladen", 0);
-        $this->RegisterPropertyInteger("Netzbezug", 0); 
+        $this->RegisterPropertyInteger("Netzbezug", 0);
-        $this->RegisterPropertyInteger("AktuelleBatterieleistung", 0);// Initialisierung mit 0
+        $this->RegisterPropertyInteger("AktuelleBatterieleistung", 0); // Initialisierung mit 0
         $this->RegisterPropertyInteger("Interval", 2); // Recheninterval
-        $this->RegisterVariableInteger("Batteriemanagement_Variabel","Batteriemanagement_Variabel", "",0);
+        $this->RegisterVariableInteger("Batteriemanagement_Variabel", "Batteriemanagement_Variabel", "", 0);
-        $this->RegisterVariableInteger("Laden_Entladen","Laden_Entladen", "",3);      
+        $this->RegisterVariableInteger("Laden_Entladen", "Laden_Entladen", "", 3);
-        $this->RegisterVariableBoolean("Hysterese", "Hysterese","",false);
+        $this->RegisterVariableBoolean("Hysterese", "Hysterese", "", false);
-
-
-
         // 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("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);
         $this->RegisterVariableInteger("IdleCounter", "IdleCounter", "", 0);
         $this->SetValue("IdleCounter", 0);
-
         // Initialisiere Idle
-       
+        $this->RegisterTimer("Timer_Do_UserCalc_Battery", $this->ReadPropertyInteger("Interval") * 1000, "IPS_RequestAction(" . $this->InstanceID . ', "Do_UserCalc", "");');
-        $this->RegisterTimer("Timer_Do_UserCalc_Battery",$this->ReadPropertyInteger("Interval")*1000,"IPS_RequestAction(" .$this->InstanceID .', "Do_UserCalc", "");');
-
-
     }
-
     public function ApplyChanges()
     {
         parent::ApplyChanges();
-
         $batterieManagement = $this->ReadPropertyInteger("Batteriemanagement");
         $this->SetValue("Batteriemanagement_Variabel", $batterieManagement);
-        $this->SetTimerInterval("Timer_Do_UserCalc_Battery",$this->ReadPropertyInteger("Interval")*1000); 
+        $this->SetTimerInterval("Timer_Do_UserCalc_Battery", $this->ReadPropertyInteger("Interval") * 1000);
-
         $batterietyp = $this->ReadPropertyInteger("Batterietyp");
-
         // Batterietypabhängige Variabeln Initialisieren
-        switch ($batterietyp) {
+        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;        
+            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);
-                break;
+            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);
-                break;
+            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);
-                break;
+            break;
-
             default:
                 // Default, werden alle ausgeschaltet
                 $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;
+            break;
+        }
+        //
+        $maxBatVar = $this->ReadPropertyInteger("MaxBatterieleistung");
+        $maxNachVar = $this->ReadPropertyInteger("MaxNachladen");
+        if ($maxBatVar > 0)
+        {
+            $this->RegisterMessage($maxBatVar, VM_UPDATE);
+        }
+        if ($maxNachVar > 0)
+        {
+            $this->RegisterMessage($maxNachVar, VM_UPDATE);
         }
-            
-            // 
-            $maxBatVar = $this->ReadPropertyInteger("MaxBatterieleistung");
-            $maxNachVar = $this->ReadPropertyInteger("MaxNachladen");
-
-            if ($maxBatVar > 0) {
-                $this->RegisterMessage($maxBatVar, VM_UPDATE);
-            }
-            if ($maxNachVar > 0) {
-                $this->RegisterMessage($maxNachVar, VM_UPDATE);
-            }
-
-                
     }
-
+    public function RequestAction($Ident, $Value)
-
+    {
-public function RequestAction($Ident, $Value)
+        switch ($Ident)
-{
+        {
-    switch ($Ident) {
+            case "SetAktuelle_Leistung":
-        
+                $this->SetValue("Power", (int)$Value);
-        case "SetAktuelle_Leistung":
-            $this->SetValue("Power", (int)$Value);
             break;
-
+            case "GetCurrentData":
-        case "GetCurrentData":
+                $this->SetValue("Is_Peak_Shaving", (bool)$Value);
-            $this->SetValue("Is_Peak_Shaving", (bool)$Value);
             break;
-
+            case "Do_UserCalc":
-        
+                $this->SetAktuelle_Leistung($this->GetValue("Power"));
-        case "Do_UserCalc":
+                $this->GetCurrentData($this->GetValue("Is_Peak_Shaving"));
-
+            break;
-            $this->SetAktuelle_Leistung($this->GetValue("Power"));
+            default:
-            $this->GetCurrentData($this->GetValue("Is_Peak_Shaving"));
+            break;
-            break; 
+        }
-
-        default:
-            break; 
-
     }
-}
+    // Nach aufruf bei anpassung Batteriewerte, sofort Getcurrentdata aufrufen.
-
-    // Nach aufruf bei anpassung Batteriewerte, sofort Getcurrentdata aufrufen. 
     public function MessageSink($TimeStamp, $SenderID, $Message, $Data)
-{
+    {
-    if ($Message !== VM_UPDATE) {
+        if ($Message !== VM_UPDATE)
-        return;
+        {
+            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"));
+        }
     }
-
-    $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");
-            $batterietyp = $this->ReadPropertyInteger("Batterietyp");
+        $batterieManagement = $this->ReadPropertyInteger("Batteriemanagement");
-            $batterieManagement = $this->ReadPropertyInteger("Batteriemanagement");
+        //Fallunterscheidung, soll Enelix überhaupt steuern?
-
+        // Wechselrichter steuert
-            //Fallunterscheidung, soll Enelix überhaupt steuern? 
+        // Goodwe, Solaredge WR Modus
-
+        if ($batterieManagement == 1 && ($batterietyp == 1 || $batterietyp == 2))
-            // Wechselrichter steuert
+        {
-            // Goodwe, Solaredge WR Modus
+            $this->SetValue("Entladeleistung", 0);
-            if ($batterieManagement == 1 && ($batterietyp == 1 || $batterietyp == 2))  {
+            $this->SetValue("Ladeleistung", 0);
-                $this->SetValue("Entladeleistung", 0);   
+            $this->SetValue("Batteriemanagement_Variabel", 1);
-                $this->SetValue("Ladeleistung", 0);  
+            return;
-                $this->SetValue("Batteriemanagement_Variabel", 1);
-                return;  
             //Sig Energy, Herstellerunabhänig im WR Modus
-            } elseif ($batterieManagement == 1 && ($batterietyp == 0 || $batterietyp == 3)) {
+            
-                $this->SetValue("Entladeleistung", 0);   
+        }
-                $this->SetValue("Ladeleistung", 0);  
+        elseif ($batterieManagement == 1 && ($batterietyp == 0 || $batterietyp == 3))
-                $this->SetValue("Batteriemanagement_Variabel", 0);
+        {
-                return;
+            $this->SetValue("Entladeleistung", 0);
-               
+            $this->SetValue("Ladeleistung", 0);
+            $this->SetValue("Batteriemanagement_Variabel", 0);
+            return;
             // Enelix Steuert
             // Sig Energy Symcon Modus
-            } elseif ($batterieManagement == 2 && ($batterietyp == 0 || $batterietyp == 3)) {
-                $this->SetValue("Batteriemanagement_Variabel", 1);
             
+        }
+        elseif ($batterieManagement == 2 && ($batterietyp == 0 || $batterietyp == 3))
+        {
+            $this->SetValue("Batteriemanagement_Variabel", 1);
             //Solaredge Symcon Modus
-            }elseif ($batterieManagement == 2 && $batterietyp == 2)  {
+            
-                $this->SetValue("Batteriemanagement_Variabel", 4);
+        }
+        elseif ($batterieManagement == 2 && $batterietyp == 2)
+        {
+            $this->SetValue("Batteriemanagement_Variabel", 4);
+        }
+        // Variabeln entsprechend gewältem Batterietyp setzen
+        $batterietyp = $this->ReadPropertyInteger("Batterietyp");
+        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
-    // Variabeln entsprechend gewältem Batterietyp setzen
+            {
-    $batterietyp = $this->ReadPropertyInteger("Batterietyp");
+                if ($power >= 0)
-    if ($batterietyp == 0) {//Herstellerunabhängig
+                {
-
+                    $this->SetValue("Ladeleistung", $power);
-        if($this->GetValue("Is_Peak_Shaving")==true){
+                    $this->SetValue("Entladeleistung", 0);
-
+                    $this->SetValue("Laden_Entladen", 0);
-            if ($power >= 0) {
+                }
-                $this->SetValue("Ladeleistung", $power);   
+                else
-                $this->SetValue("Entladeleistung", 0);     
+                {
-                $this->SetValue("Laden_Entladen", 0);  
+                    $this->SetValue("Entladeleistung", abs($power));
-            } else {
+                    $this->SetValue("Ladeleistung", 0);
-                $this->SetValue("Entladeleistung", abs($power));   
+                    $this->SetValue("Laden_Entladen", 1);
-                $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)
-    elseif ($batterietyp == 1) {//Goodwe
+        {
-        $this->SetValue("Entladeleistung", 0);  
+            //Goodwe
-        $this->SetValue("Ladeleistung", 0);   
+            $this->SetValue("Entladeleistung", 0);
-        if($this->GetValue("Is_Peak_Shaving")==true){
+            $this->SetValue("Ladeleistung", 0);
-
+            if ($this->GetValue("Is_Peak_Shaving") == true)
-            if ($power >= 0) {
+            {
-                $this->SetValue("Goodwe_EntLadeleistung", abs($power));       
+                if ($power >= 0)
-                $this->SetValue("Laden_Entladen", 11); 
+                {
-            } else {
+                    $this->SetValue("Goodwe_EntLadeleistung", abs($power));
-                $this->SetValue("Goodwe_EntLadeleistung", abs($power));    
+                    $this->SetValue("Laden_Entladen", 11);
-                $this->SetValue("Laden_Entladen", 12);               
+                }
+                else
+                {
+                    $this->SetValue("Goodwe_EntLadeleistung", abs($power));
+                    $this->SetValue("Laden_Entladen", 12);
+                }
             }
-
+            else
-        }else{
+            {
-
+                if ($power >= 0)
-            if ($power >= 0) {
+                {
-                $this->SetValue("Goodwe_EntLadeleistung", abs($power));      
+                    $this->SetValue("Goodwe_EntLadeleistung", abs($power));
-                $this->SetValue("Laden_Entladen", 11);  
+                    $this->SetValue("Laden_Entladen", 11);
-            } else {
+                }
-                $this->SetValue("Goodwe_EntLadeleistung", abs($power));    
+                else
-                $this->SetValue("Laden_Entladen", 12);              
+                {
-            }
+                    $this->SetValue("Goodwe_EntLadeleistung", abs($power));
-
+                    $this->SetValue("Laden_Entladen", 12);
-        }
+                }
-
-    }elseif ($batterietyp == 2) {//Solaredge
-
-        if($this->GetValue("Is_Peak_Shaving")==true){
-
-            if ($power >= 0) {
-                $this->SetValue("Ladeleistung", $power);   
-                $this->SetValue("Entladeleistung", 0);     
-                $this->SetValue("Laden_Entladen", 3);  
-            } else {
-                $this->SetValue("Entladeleistung", abs($power));   
-                $this->SetValue("Ladeleistung", 0);  
-                $this->SetValue("Laden_Entladen", 4);              
-            }
-
-        }else{
-            if ($power >= 0) {
-                $this->SetValue("Ladeleistung", $power);   
-                $this->SetValue("Entladeleistung", 0);     
-                $this->SetValue("Laden_Entladen", 3);  
-            } else {
-                $this->SetValue("Entladeleistung", abs($power));   
-                $this->SetValue("Ladeleistung", 0);  
-                $this->SetValue("Laden_Entladen", 4);              
             }
         }
-    }   elseif ($batterietyp == 3) {//Sig Energy
+        elseif ($batterietyp == 2)
-
+        {
-        if($this->GetValue("Is_Peak_Shaving")==true){
+            //Solaredge
-
+            if ($this->GetValue("Is_Peak_Shaving") == true)
-            if ($power >= 0) {
+            {
-                $this->SetValue("Ladeleistung", $power/1000);   
+                if ($power >= 0)
-                $this->SetValue("Entladeleistung", 0);     
+                {
-                $this->SetValue("Laden_Entladen", 3);  
+                    $this->SetValue("Ladeleistung", $power);
-            } else {
+                    $this->SetValue("Entladeleistung", 0);
-                $this->SetValue("Entladeleistung", abs($power)/1000);   
+                    $this->SetValue("Laden_Entladen", 3);
-                $this->SetValue("Ladeleistung", 0);  
+                }
-                $this->SetValue("Laden_Entladen", 6);              
+                else
+                {
+                    $this->SetValue("Entladeleistung", abs($power));
+                    $this->SetValue("Ladeleistung", 0);
+                    $this->SetValue("Laden_Entladen", 4);
+                }
             }
-
+            else
-        }else{
+            {
-            if ($power >= 0) {
+                if ($power >= 0)
-                $this->SetValue("Ladeleistung", $power/1000);   
+                {
-                $this->SetValue("Entladeleistung", 0);     
+                    $this->SetValue("Ladeleistung", $power);
-                $this->SetValue("Laden_Entladen", 3);  
+                    $this->SetValue("Entladeleistung", 0);
-            } else {
+                    $this->SetValue("Laden_Entladen", 3);
-                $this->SetValue("Entladeleistung", abs($power)/1000);   
+                }
-                $this->SetValue("Ladeleistung", 0);  
+                else
-                $this->SetValue("Laden_Entladen", 6);              
+                {
+                    $this->SetValue("Entladeleistung", abs($power));
+                    $this->SetValue("Ladeleistung", 0);
+                    $this->SetValue("Laden_Entladen", 4);
+                }
+            }
+        }
+        elseif ($batterietyp == 3)
+        {
+            //Sig Energy
+            if ($this->GetValue("Is_Peak_Shaving") == true)
+            {
+                if ($power >= 0)
+                {
+                    $this->SetValue("Ladeleistung", $power / 1000);
+                    $this->SetValue("Entladeleistung", 0);
+                    $this->SetValue("Laden_Entladen", 3);
+                }
+                else
+                {
+                    $this->SetValue("Entladeleistung", abs($power) / 1000);
+                    $this->SetValue("Ladeleistung", 0);
+                    $this->SetValue("Laden_Entladen", 6);
+                }
+            }
+            else
+            {
+                if ($power >= 0)
+                {
+                    $this->SetValue("Ladeleistung", $power / 1000);
+                    $this->SetValue("Entladeleistung", 0);
+                    $this->SetValue("Laden_Entladen", 3);
+                }
+                else
+                {
+                    $this->SetValue("Entladeleistung", abs($power) / 1000);
+                    $this->SetValue("Ladeleistung", 0);
+                    $this->SetValue("Laden_Entladen", 6);
+                }
             }
         }
-    }
-
- 
-
-
         // Prüfe auf Änderung der Leistung im Vergleich zur letzten Einstellung
         $lastPower = GetValue($this->GetIDForIdent("Aktuelle_Leistung"));
-        if ($power != $lastPower) {
+        if ($power != $lastPower)
+        {
             $this->SetValue("Idle", false);
-            $this->SetValue(
+            $this->SetValue("IdleCounter", $this->ReadPropertyInteger("IdleCounterMax"));
-                "IdleCounter",
-                $this->ReadPropertyInteger("IdleCounterMax")
-            );
         }
-    
         // Setze die neue aktuelle Leistung
         $this->SetValue("Aktuelle_Leistung", $power);
-        $this->SetValue("Bezogene_Energie", ($this->GetValue("Bezogene_Energie") + ($this->GetValue("Aktuelle_Leistung")*($this->ReadPropertyInteger("Interval")/3600))));
+        $this->SetValue("Bezogene_Energie", $this->GetValue("Bezogene_Energie") + $this->GetValue("Aktuelle_Leistung") * ($this->ReadPropertyInteger("Interval") / 3600));
-
         // IdleCounter verarbeiten
         $this->ProcessIdleCounter();
-
-
     }
-    
-
     public function GetCurrentData(bool $Peak)
     {
         // Aktuelle Daten ausarbeiten und Berechnen
         $array_powersteps = $this->GeneratePowerSteps();
         $aufdasnachladen = $this->ReadPropertyInteger("AufdasNachladen");
         $minimumentladen = $this->ReadPropertyInteger("MinimumEntladen");
-        $maxleistung = GetValue($this->ReadPropertyInteger("MaxBatterieleistung"));//Ladeleistung
+        $maxleistung = GetValue($this->ReadPropertyInteger("MaxBatterieleistung")); //Ladeleistung
-        $maxentladeleistung = GetValue($this->ReadPropertyInteger("MaxNachladen"));//Entladeleistung
+        $maxentladeleistung = GetValue($this->ReadPropertyInteger("MaxNachladen")); //Entladeleistung
         $dummy_array = [];
         $batterieladezustand = GetValue($this->ReadPropertyInteger("Batterieladezustand"));
         $filtered_powersteps_entladen = [];
-        if ($this->ReadPropertyInteger("Batteriemanagement") == 1) {
+        if ($this->ReadPropertyInteger("Batteriemanagement") == 1)
+        {
             $dummy_array[] = 0;
             return $this->SetValue("PowerSteps", json_encode($dummy_array));
         }
-
-        
         $netzbezug = GetValue($this->ReadPropertyInteger("Netzbezug"));
         $bat_leistung = GetValue($this->ReadPropertyInteger("AktuelleBatterieleistung"));
-        
+        if ($Peak && $netzbezug > 0)
-        
+        {
-        if ($Peak && $netzbezug > 0) {
+            $netzbezug = - min($netzbezug, $maxentladeleistung) + $bat_leistung;
-            $netzbezug = -min($netzbezug, $maxentladeleistung) + $bat_leistung;
         }
-
+        if ($batterieladezustand > 5 + $aufdasnachladen)
-        if($batterieladezustand>(5+$aufdasnachladen)){
+        {
-
             $this->SetValue("Hysterese", false);
-
+        }
-        }elseif($batterieladezustand<=$aufdasnachladen){
+        elseif ($batterieladezustand <= $aufdasnachladen)
+        {
             $this->SetValue("Hysterese", true);
         }
-
         $hyst = $this->GetValue("Hysterese");
-
+        if ($Peak)
-        if($Peak){
+        {
-
+            if ($batterieladezustand > $aufdasnachladen && $hyst == false)
-            if($batterieladezustand>$aufdasnachladen && $hyst==false){
+            {
-
                 $dummy_array[] = $netzbezug;
                 $this->SetValue("PowerSteps", json_encode($dummy_array));
-
+            }
-            }elseif($batterieladezustand>$aufdasnachladen && $hyst==true){
+            elseif ($batterieladezustand > $aufdasnachladen && $hyst == true)
-
+            {
-
+                $filtered_powersteps = array_filter($array_powersteps, function ($value)
-                $filtered_powersteps = array_filter($array_powersteps, function ($value) {
+                {
                     return $value <= 0;
                 });
                 $filtered_powersteps_laden = array_values($filtered_powersteps);
                 $this->SetValue("PowerSteps", json_encode($filtered_powersteps_laden));
-
-            }elseif($batterieladezustand>$minimumentladen){
-
-                    $this->SetValue("PowerSteps", json_encode($array_powersteps));
             }
-            else{
+            elseif ($batterieladezustand > $minimumentladen)
-
+            {
-                $filtered_powersteps = array_filter($array_powersteps, function ($value) {
-                    return $value >= 0;
-                });
-                $filtered_powersteps_laden = array_values($filtered_powersteps);
-                $this->SetValue("PowerSteps", json_encode($filtered_powersteps_laden));
-            }
-
-        }else{
-
-
-            if($batterieladezustand>99){
-
-                $filtered_powersteps = array_filter($array_powersteps, function ($value) {
-                    return $value <= 0;
-                });
-                $filtered_powersteps_laden = array_values($filtered_powersteps);
-                $this->SetValue("PowerSteps", json_encode($filtered_powersteps_laden));
-
-            }elseif($batterieladezustand>$aufdasnachladen && $hyst==false){
-             
                 $this->SetValue("PowerSteps", json_encode($array_powersteps));
-
+            }
-
+            else
-            }elseif($batterieladezustand>=$aufdasnachladen && $hyst==true){
+            {
-             
+                $filtered_powersteps = array_filter($array_powersteps, function ($value)
-                $filtered_powersteps = array_filter($array_powersteps, function ($value) {
+                {
                     return $value >= 0;
                 });
                 $filtered_powersteps_laden = array_values($filtered_powersteps);
                 $this->SetValue("PowerSteps", json_encode($filtered_powersteps_laden));
-
+            }
-
+        }
-            }elseif($batterieladezustand<$aufdasnachladen){
+        else
-
+        {
+            if ($batterieladezustand > 99)
+            {
+                $filtered_powersteps = array_filter($array_powersteps, function ($value)
+                {
+                    return $value <= 0;
+                });
+                $filtered_powersteps_laden = array_values($filtered_powersteps);
+                $this->SetValue("PowerSteps", json_encode($filtered_powersteps_laden));
+            }
+            elseif ($batterieladezustand > $aufdasnachladen && $hyst == false)
+            {
+                $this->SetValue("PowerSteps", json_encode($array_powersteps));
+            }
+            elseif ($batterieladezustand >= $aufdasnachladen && $hyst == true)
+            {
+                $filtered_powersteps = array_filter($array_powersteps, function ($value)
+                {
+                    return $value >= 0;
+                });
+                $filtered_powersteps_laden = array_values($filtered_powersteps);
+                $this->SetValue("PowerSteps", json_encode($filtered_powersteps_laden));
+            }
+            elseif ($batterieladezustand < $aufdasnachladen)
+            {
                 //$dummy_array[] = GetValue($this->ReadPropertyInteger("MaxNachladen"));
                 $dummy_array[] = GetValue($this->ReadPropertyInteger("MaxBatterieleistung"));
                 $this->SetValue("PowerSteps", json_encode($dummy_array));
-
             }
-
-        }
-
-    }
-    
-
-  // 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++;
         }
     }
-
+    // Ab hier Hilfsfunktionen
-    // Feine Werte um closestValue herum (±4 * 50)
+    private function GeneratePowerSteps()
-    $newValues = [];
+    {
-    for ($i = -4; $i <= 4; $i++) {
+        // Hilfsfunktion um die Möglichen Powersteps zu generieren
-        $v = $closestValue + ($i * $stepSizeSmall);
+        $maxleistung_raw = GetValue($this->ReadPropertyInteger("MaxBatterieleistung"));
-        if ($v >= $minleistung && $v <= $maxleistung) {
+        $nachladen_raw = GetValue($this->ReadPropertyInteger("MaxNachladen"));
-            $newValues[] = $v;
+        $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;
     }
-
-    // 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
+    {
+        // Hilfsfunktion zum Prüfen ob die Batterie schon wieder Leistung verändern kann
         $lastpower = GetValue("Aktuelle_Leistung");
-        if ($lastpower != GetValue("Aktuelle_Leistung")) {
+        if ($lastpower != GetValue("Aktuelle_Leistung"))
+        {
             $this->SetValue("Idle", false);
-            $this->SetValue(
+            $this->SetValue("IdleCounter", $this->ReadPropertyInteger("IdleCounterMax"));
-                "IdleCounter",
-                $this->ReadPropertyInteger("IdleCounterMax")
-            );
         }
         // IdleCounter auslesen und verarbeiten
         $idleCounter = $this->GetValue("IdleCounter");
-        if ($idleCounter > 0) {
+        if ($idleCounter > 0)
+        {
             $this->SetValue("Idle", false);
             $this->SetValue("IdleCounter", $idleCounter - 1);
-        } else {
+        }
+        else
+        {
             $this->SetValue("Idle", true);
         }
     }
-        
-
     private function ProcessIdleCounter()
     {
         // IdleCounter auslesen und verarbeiten
         $idleCounter = $this->GetValue("IdleCounter");
-        if ($idleCounter > 0) {
+        if ($idleCounter > 0)
+        {
             $this->SetValue("Idle", false);
             $this->SetValue("IdleCounter", $idleCounter - 1);
-        } else {
+        }
+        else
+        {
             $this->SetValue("Idle", true);
         }
     }
-    
 }
 ?>

Manager/README.md

@@ -93,7 +93,7 @@ Dem Managermodul müssen bei Erstinbetriebnahme eine Variable mit dem zu regelnd
 | **Zyklischer Aufruf** | Timer löst `RequestAction()` mit dem Ident `DistributeEnergy` aus. |
 | **Mode-Entscheidlogik** | Dynamisch: Abgleich von `$Netzbezug` mit Mittelwert aus Peak und Überschuss. <br>Statisch: Schwellwertprüfung über Properties `Umschalt_Solarladen` / `Umschalt_Peakshaving`. |
 | **Leistungszuteilung** | Funktion `DistributeEnergy()` berechnet die Schritte und steuert Verbraucher via `IPS_RequestAction(..., "SetAktuelle_Leistung", ...)`. |
-| **Externe Kommunikation** | Funktion `DistributeEnergy_Extern()` liest/schreibt Arrays über die festgelegten Variablen-IDs. |
+| **Externe Kommunikation** | Funktion `DistributeEnergy_Extern()` liest/schreibt Arrays über die festgelegten Variablen-IDs um über verteilte Manager zu steuern. |
 
 ---
 

Manager/module.php

@@ -1,11 +1,9 @@
 <?php
-
 class Manager extends IPSModule
 {
     public function Create()
     {
         parent::Create();
-
         // Properies und Systemvariablen registrieren
         $this->RegisterPropertyInteger("Peakleistung", 0);
         $this->RegisterPropertyInteger("Ueberschussleistung", 0);
@@ -19,461 +17,361 @@ 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(
+                    $data = json_decode(GetValue($this->ReadPropertyInteger("DatenZuruck")) , true);
-                        GetValue($this->ReadPropertyInteger("DatenZuruck")),
+                    if (isset($data["Timestamp"]))
-                        true
+                    {
-                    );
-
-                    if (isset($data["Timestamp"])) {
                         $timestamp = $data["Timestamp"];
                         $currentTime = time();
-
+                        if ($currentTime - $timestamp < 3600)
-                        if ($currentTime - $timestamp < 3600) {
+                        {
                             $this->DistributeEnergy_Extern();
-                        } else {
+                        }
-                            $sendarray = [
+                        else
-                                "Netzbezug" => GetValue(
+                        {
-                                    $this->ReadPropertyInteger("Netzbezug")
+                            $sendarray = ["Netzbezug" => GetValue($this->ReadPropertyInteger("Netzbezug")) , "Timestamp" => time() , ];
-                                ),
+                            SetValue($this->ReadPropertyInteger("DatenHoch") , json_encode($sendarray));
-                                "Timestamp" => time(),
-                            ];
-
-                            SetValue(
-                                $this->ReadPropertyInteger("DatenHoch"),
-                                json_encode($sendarray)
-                            );
-
                             $this->DistributeEnergy();
                         }
-                    } else {
+                    }
-                        $sendarray = [
+                    else
-                            "Netzbezug" => GetValue(
+                    {
-                                $this->ReadPropertyInteger("Netzbezug")
+                        $sendarray = ["Netzbezug" => GetValue($this->ReadPropertyInteger("Netzbezug")) , "Timestamp" => time() , ];
-                            ),
+                        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(
+        $Verbraucher_Liste = json_decode($this->ReadPropertyString("Verbraucher_Liste") , true);
-            $this->ReadPropertyString("Verbraucher_Liste"),
+        if (empty($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(
+            $Aktuelle_Leistung = GetValue(IPS_GetObjectIDByIdent("Power", $user["Verbraucher"])); // Aktuelle Leistung durch Power ersetzt
-                IPS_GetObjectIDByIdent("Power", $user["Verbraucher"])
+            $Bezogene_Energie = GetValue(IPS_GetObjectIDByIdent("Bezogene_Energie", $user["Verbraucher"]));
-            ); // Aktuelle Leistung durch Power ersetzt
+            $PV_Prio = GetValue(IPS_GetObjectIDByIdent("PV_Prio", $user["Verbraucher"]));
-            $Bezogene_Energie = GetValue(
+            $Sperre_Prio = GetValue(IPS_GetObjectIDByIdent("Sperre_Prio", $user["Verbraucher"]));
-                IPS_GetObjectIDByIdent("Bezogene_Energie", $user["Verbraucher"])
+            $idle = GetValue(IPS_GetObjectIDByIdent("Idle", $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(
+            $delta = GetValue(IPS_GetObjectIDByIdent("Leistung_Delta", $user["Verbraucher"]));
-                IPS_GetObjectIDByIdent("Leistung_Delta", $user["Verbraucher"])
-            );
-
             // Verbraucher-Daten zum gefilterten Array hinzufügen
-            $filteredVerbraucher[] = [
+            $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, ];
-                "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 = $this->ReadPropertyInteger("Ueberschussleistung");
-            "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 (
+        {
-                $Netzbezug < $this->ReadPropertyInteger("Umschalt_Solarladen")
+            if ($Netzbezug < $this->ReadPropertyInteger("Umschalt_Solarladen"))
-            ) {
+            {
-                $remainingPower = -1 * (-1 * $Ueberschussleistung + $Netzbezug);
+                $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) {
+        foreach ($Verbraucher_Liste as $user)
-            if (IPS_InstanceExists($user["Verbraucher"])) {
+        {
-                IPS_RequestAction(
+            if (IPS_InstanceExists($user["Verbraucher"]))
-                    $user["Verbraucher"],
+            {
-                    "GetCurrentData",
+                IPS_RequestAction($user["Verbraucher"], "GetCurrentData", $Is_Peak_Shaving);
-                    $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 (
+        if (!$allIdle || $Is_Peak_Shaving != $this->GetValue("Is_Peak_Shaving"))
-            !$allIdle ||
+        {
-            $Is_Peak_Shaving != $this->GetValue("Is_Peak_Shaving")
+            foreach ($filteredVerbraucher as $user)
-        ) {
+            {
-            foreach ($filteredVerbraucher as $user) {
+                IPS_RequestAction($user["InstanceID"], "SetAktuelle_Leistung", $user["Aktuelle_Leistung"]);
-                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) <=>
+            {
-                    round($b["Bezogene_Energie"] / 2000);
+                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(
+        $priorities = array_unique(array_column($filteredVerbraucher, $priorityKey));
-            array_column($filteredVerbraucher, $priorityKey)
-        );
         $groupedUsers = [];
-
+        foreach ($priorities as $priority)
-        foreach ($priorities as $priority) {
+        {
-            $groupedUsers[$priority] = array_filter(
+            $groupedUsers[$priority] = array_filter($filteredVerbraucher, function ($user) use ($priority, $priorityKey)
-                $filteredVerbraucher,
+            {
-                function ($user) use ($priority, $priorityKey) {
+                return $user[$priorityKey] == $priority;
-                    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])
+            $samePriorityUsers = isset($groupedUsers[$priority]) ? $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 =
+                $steps = isset($entry["PowerSteps"]) && is_array($entry["PowerSteps"]) ? $entry["PowerSteps"] : [0];
-                    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) {
+                {
-                        if ($step >= 0) {
+                    foreach ($user["PowerSteps"] as $step)
-                            $allSteps[] = [
+                    {
-                                "user" => $user["InstanceID"],
+                        if ($step >= 0)
-                                //"Leistung_Delta" => $user["Leistung_Delta"],
+                        {
-                                "step" => $step,
+                            $allSteps[] = ["user" => $user["InstanceID"],
-                            ];
+                            //"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 (
+                    if ($remainingPower >= $powerstep - $userEnergyProv[$user])
-                        $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(
+                    $positiveValues = array_filter(array_column($samePriorityUsers, "PowerSteps", "InstanceID") [$userInstanceID], function ($l)
-                        array_column(
+                    {
-                            $samePriorityUsers,
+                        return $l >= 0;
-                            "PowerSteps",
+                    });
-                            "InstanceID"
-                        )[$userInstanceID],
-                        function ($l) {
-                            return $l >= 0;
-                        }
-                    );
                     // Falls keine Werte ≥ 0 vorhanden sind, auf 0 zurückfallen
-                    $fallbackMinimum = empty($positiveValues)
+                    $fallbackMinimum = empty($positiveValues) ? max(array_column($samePriorityUsers, "PowerSteps", "InstanceID") [$userInstanceID]) : min($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(
+                    {
-                            $userInstanceID,
+                        IPS_RequestAction($userInstanceID, "SetAktuelle_Leistung", $schreibleistung);
-                            "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) {
+                {
-                        if ($step <= 0) {
+                    foreach ($user["PowerSteps"] as $step)
-                            $allSteps[] = [
+                    {
-                                "user" => $user["InstanceID"],
+                        if ($step <= 0)
-                                "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 (
+                    if ($remainingPower >= $powerstep - $userEnergyProv[$user])
-                        $remainingPower >=
+                    {
-                        $powerstep - $userEnergyProv[$user]
-                    ) {
                         // oder bedingung testen
                         // Aktualisiere die verbleibende Energie und die bereitgestellte Energie für den Benutzer
                         $remainingPower -= $powerstep - $userEnergyProv[$user];
@@ -481,139 +379,65 @@ 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(
+                    $positiveValues = array_filter(array_column($samePriorityUsers, "PowerSteps", "InstanceID") [$userInstanceID], function ($l)
-                        array_column(
+                    {
-                            $samePriorityUsers,
+                        return $l <= 0;
-                            "PowerSteps",
+                    });
-                            "InstanceID"
-                        )[$userInstanceID],
-                        function ($l) {
-                            return $l <= 0;
-                        }
-                    );
                     // Falls keine Werte ≥ 0 vorhanden sind, auf 0 zurückfallen
-                    $fallbackMinimum = empty($positiveValues)
+                    $fallbackMinimum = empty($positiveValues) ? min(array_column($samePriorityUsers, "PowerSteps", "InstanceID") [$userInstanceID]) : max($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(
+                    {
-                            $userInstanceID,
+                        IPS_RequestAction($userInstanceID, "SetAktuelle_Leistung", $schreibleistung);
-                            "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(
+            $Aktuelle_Leistung = GetValue(IPS_GetObjectIDByIdent("Aktuelle_Leistung", $user["Verbraucher"]));
-                IPS_GetObjectIDByIdent(
+            $Bezogene_Energie = GetValue(IPS_GetObjectIDByIdent("Bezogene_Energie", $user["Verbraucher"]));
-                    "Aktuelle_Leistung",
+            $PV_Prio = GetValue(IPS_GetObjectIDByIdent("PV_Prio", $user["Verbraucher"]));
-                    $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"]));
-            $Bezogene_Energie = GetValue(
+            $delta = GetValue(IPS_GetObjectIDByIdent("Leistung_Delta", $user["Verbraucher"]));
-                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[] = [
+            $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") , ];
-                "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() , ];
-        $sendarray = [
+        SetValue($this->ReadPropertyInteger("DatenHoch") , json_encode($sendarray));
-            "User" => $filteredVerbraucher,
+        $answerArray = json_decode(GetValue($this->ReadPropertyInteger("DatenZuruck")) , true);
-            "Netzbezug" => $Netzbezug,
+        foreach ($answerArray["User"] as $user)
-            "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"]
-            );
         }
     }
 }