Refactoring

AT und Wolken

Belevo_Server_Kommunikation/form.json

@@ -9,8 +9,14 @@
           "name":"InfluxJaNein",
           "caption":"Influx Aufzeichnen Ja oder Nein",
           "options":[
-                { "caption": "Ja", "value": true },
+             {
-                { "caption": "Nein", "value": false }
+                "caption":"Ja",
+                "value":true
+             },
+             {
+                "caption":"Nein",
+                "value":false
+             }
           ]
        },
        {
@@ -25,6 +31,11 @@
           "name":"Gerätenummer",
           "caption":"Gerätenummer"
        },
+       {
+          "type":"ValidationTextBox",
+          "name":"Ortschaft",
+          "caption":"Ortschaft"
+       },
        {
           "type":"List",
           "name":"ZusatzVariablen",
@@ -33,7 +44,6 @@
           "delete":true,
           "columns":[
              {
-                    
                 "caption":"Influx Name",
                 "name":"Variablenname",
                 "width":"200px",

Belevo_Server_Kommunikation/locale.json

@@ -1,7 +0,0 @@
-{
-    "translations": {
-        "de": {
-
-        }
-    }
-}

Belevo_Server_Kommunikation/module.php

@@ -2,14 +2,16 @@
 
 class Belevo_Server_Kommunikation extends IPSModule
 {
-
     public function Create()
     {
         // Die Standard-Create() Methode aufrufen
         parent::Create();
 
         // Registrierung der Eigenschaften
-        $this->RegisterPropertyString("BaseURL", "http://192.168.20.140:5000/influx");
+        $this->RegisterPropertyString(
+            "BaseURL",
+            "https://brain.belevo.ch/storedata"
+        );
         $this->RegisterPropertyString("Anlagenummer", "0");
         $this->RegisterPropertyBoolean("InfluxJaNein", false);
 
@@ -18,9 +20,20 @@ class Belevo_Server_Kommunikation extends IPSModule
         $this->RegisterPropertyString("Variable", "0"); // Datenpunkt kann im Syncom ausgewählt werden
         $this->RegisterPropertyString("Variablenname", "0"); // Name für Influxaufzeichnung
         $this->RegisterPropertyString("Gerätenummer", "0");
+        $this->RegisterPropertyString("Ortschaft", "0");
+
+        $this->RegisterVariableInteger(
+            "Wolkenwarscheinlichkeit",
+            "Wolkenwarscheinlichkeit"
+        );
+        $this->RegisterVariableInteger("Temperatur", "Temperatur");
 
         // Timer registrieren
-        $this->RegisterTimer("Timer_Influx", 0, 'IPS_RequestAction(' . $this->InstanceID . ', "GetAction", "");');
+        $this->RegisterTimer(
+            "Timer_Influx",
+            0,
+            "IPS_RequestAction(" . $this->InstanceID . ', "GetAction", "");'
+        );
     }
 
     public function ApplyChanges()
@@ -32,11 +45,8 @@ class Belevo_Server_Kommunikation extends IPSModule
 
         if ($InfluxJaNein) {
             // Timer auf 5 Minuten setzen
-            $this->SetTimerInterval("Timer_Influx", 5000); // Alle 5 Minuten -> 5*60*1000=300000
+            $this->SetTimerInterval("Timer_Influx", 300000); // Alle 5 Minuten -> 5*60*1000=300000
             IPS_LogMessage("Belevo_Server_Kommunikation", "Influx Ja");
-    
-            
-            
         } else {
             // Timer stoppen
             $this->SetTimerInterval("Timer_Influx", 0);
@@ -44,49 +54,95 @@ class Belevo_Server_Kommunikation extends IPSModule
         }
     }
 
+    public function getWetter($bn, $pw, $loc)
+    {
+        // URL mit Parametern zusammenstellen
+        $url =
+            "https://brain.belevo.ch/v2wetter?loc=" .
+            urlencode($loc) .
+            "&nr=" .
+            urlencode($bn);
+
+        // HTTP-Anfrage-Header einstellen
+        $headers = ["id: $pw"];
+
+        // cURL-Initialisierung
+        $ch = curl_init();
+        curl_setopt($ch, CURLOPT_URL, $url);
+        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
+
+        // HTTP-Anfrage ausführen und Antwort erhalten
+        $response = curl_exec($ch);
+        curl_close($ch);
+
+        // Antwort in ein Array dekodieren
+        $data = json_decode($response, true);
+
+        // Überprüfen, ob die benötigten Felder vorhanden sind und zurückgeben
+        if (
+            isset($data["forecast"]["forecastday"][0]["hour"][5]["temp_c"]) &&
+            isset($data["forecast"]["forecastday"][0]["hour"][8]["cloud"])
+        ) {
+            return [
+                "temp" =>
+                    $data["forecast"]["forecastday"][0]["hour"][5]["temp_c"],
+                "cloud" =>
+                    $data["forecast"]["forecastday"][0]["hour"][8]["cloud"],
+            ];
+        }
+
+        // Fehlerbehandlung
+        return null;
+    }
+
     private function ProcessZusatzVariablen()
     {
         // Abrufen der ZusatzVariablen-Liste
-        $zusatzVariablen = json_decode($this->ReadPropertyString("ZusatzVariablen"), true); // JSON decodieren
+        $zusatzVariablen = json_decode(
+            $this->ReadPropertyString("ZusatzVariablen"),
+            true
+        ); // JSON decodieren
 
         // Array für die Ausgabe erstellen
-        $output = array();
+        $output = [];
 
         // Verarbeitung der Variablen
         if (!empty($zusatzVariablen)) {
             foreach ($zusatzVariablen as $variable) {
                 // Überprüfen, ob der Variablenname gesetzt ist
-                if (isset($variable['Variablenname'])) {
+                if (isset($variable["Variablenname"])) {
-                    $variablenname = $variable['Variablenname'];
+                    $variablenname = $variable["Variablenname"];
                 } else {
-                    IPS_LogMessage("Belevo_Server_Kommunikation", "Variablenname nicht gesetzt für die Variable: " . json_encode($variable));
+                    IPS_LogMessage(
+                        "Belevo_Server_Kommunikation",
+                        "Variablenname nicht gesetzt für die Variable: " .
+                            json_encode($variable)
+                    );
                     continue; // Mit der nächsten Variable fortfahren
                 }
 
-                $variableID = $variable['Variable'];
+                $variableID = $variable["Variable"];
 
                 // Überprüfen, ob die Variable existiert
                 if (IPS_VariableExists($variableID)) {
                     $wert = GetValue($variableID); // Den aktuellen Wert der Zusatzvariable abrufen
 
-    
                     // Wert dem Variablenname zuweisen
                     $output[$variablenname] = $wert;
                 } else {
-                    IPS_LogMessage("Belevo_Server_Kommunikation", "Variable mit ID $variableID existiert nicht.");
+                    IPS_LogMessage(
+                        "Belevo_Server_Kommunikation",
+                        "Variable mit ID $variableID existiert nicht."
+                    );
                 }
             }
         }
 
-        // Optional: Ausgabe im JSON-Format protokollieren
-        IPS_LogMessage("Belevo_Server_Kommunikation", json_encode($output));
-    
         // Wenn gewünscht, kannst du das JSON zurückgeben oder speichern
         return json_encode($output);
     }
 
-
-
     public function RequestAction($Ident, $Value)
     {
         switch ($Ident) {
@@ -98,7 +154,8 @@ class Belevo_Server_Kommunikation extends IPSModule
         }
     }
 
-    public function GetAction() {
+    public function GetAction()
+    {
         $output = $this->ProcessZusatzVariablen();
         $json = $this->MakeJson($output);
         // Verarbeite die Zusatzvariablen
@@ -107,50 +164,78 @@ class Belevo_Server_Kommunikation extends IPSModule
 
         $anlagenummer = $this->ReadPropertyString("Anlagenummer");
 
+        $answer = $this->getWetter(
+            $anlagenummer,
+            $this->ReadPropertyString("Gerätenummer"),
+            $this->ReadPropertyString("Ortschaft")
+        );
+
+        //$this->SetValue("Temperatur", $answer['temp']);
+        //$this->SetValue("Wolkenwarscheinlichkeit", $answer['cloud']);
+        if (isset($answer["temp"])) {
+            $this->SetValue("Temperatur", $answer["temp"]);
+        } else {
+            IPS_LogMessage(
+                "Belevo_Server_Kommunikation",
+                "Temperatur-Wert ist nicht vorhanden."
+            );
+        }
+
+        if (isset($answer["cloud"])) {
+            $this->SetValue("Wolkenwarscheinlichkeit", $answer["cloud"]);
+        } else {
+            IPS_LogMessage(
+                "Belevo_Server_Kommunikation",
+                "Wolkenwarscheinlichkeit-Wert ist nicht vorhanden."
+            );
+        }
+
         if (!empty($json)) {
             // Kombiniere die URL mit der Anlagenummer
             $fullURL = $baseURL;
             $this->SendJsonToInfluxDB($fullURL, $json);
         } else {
-            IPS_LogMessage("Belevo_Server_Kommunikation", "Keine Aufzeichnung im Influx: Anlagenummer oder JSON-Daten fehlen->GetAction()");
+            IPS_LogMessage(
+                "Belevo_Server_Kommunikation",
+                "Keine Aufzeichnung im Influx: Anlagenummer oder JSON-Daten fehlen"
+            );
         }
     }
 
-// Werte in ein Array packen
     public function MakeJson($json)
     {
         $an_nummer = $this->ReadPropertyString("Anlagenummer"); // Anlagenummer lesen
         $InfluxJaNein = $this->ReadPropertyBoolean("InfluxJaNein");
 
         // Werte in ein Array packen
-    $influxData = array(
+        $influxData = [
-        "Value" => array(
+            "Value" => [
-            "InfluxAllowed" => $InfluxJaNein // Setze InfluxAllowed
+                "InfluxAllowed" => $InfluxJaNein, // Setze InfluxAllowed
-        ),
+            ],
-        "Parameter" => array(
+            "Parameter" => [
-            "Influxadr" => $an_nummer 
+                "Influxadr" => $an_nummer,
-        ),
+            ],
-        "Tracker" => $json // Initialisiere Tracker als leeres Array
+            "Tracker" => $json, // Initialisiere Tracker als leeres Array
-    );
+        ];
-
-
 
         // Array in JSON konvertieren
         $json = json_encode($influxData);
-    IPS_LogMessage("Belevo_Server_Kommunikation", "Erstelltes JSON: " . $json);
 
         // JSON zurückgeben oder weiterverarbeiten
         return $json;
     }
 
-
+    private function SendJsonToInfluxDB($url, $jsonData)
-
+    {
-private function SendJsonToInfluxDB($url, $jsonData) {
         $pw = $this->ReadPropertyString("Gerätenummer");
         if (empty($pw)) {
-        IPS_LogMessage("Belevo_Server_Kommunikation", "Fehler: Gerätenummer ist leer.");
+            IPS_LogMessage(
+                "Belevo_Server_Kommunikation",
+                "Fehler: Gerätenummer ist leer."
+            );
             return;
         }
+
         // cURL Initialisieren
         $curl = curl_init();
         // Optionen für cURL-Request definieren
@@ -159,30 +244,28 @@ private function SendJsonToInfluxDB($url, $jsonData) {
             CURLOPT_RETURNTRANSFER => true,
             CURLOPT_POST => true, // POST-Methode verwenden
             CURLOPT_HTTPHEADER => [
-            'Content-Type: application/json', // Header für JSON-Daten setzen
+                "Content-Type: application/json", // Header für JSON-Daten setzen
-            'Accept: application/json',
+                "Accept: application/json",
-            'id:'.$pw
+                "id:" . $pw,
             ],
-        CURLOPT_POSTFIELDS => $jsonData // JSON-Daten als POST-Feld senden
+            CURLOPT_POSTFIELDS => $jsonData, // JSON-Daten als POST-Feld senden
         ]);
 
         // cURL-Request ausführen
         $result = curl_exec($curl);
+
         $error = curl_error($curl);
         $httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
         // cURL beenden
         curl_close($curl);
 
         if ($error) {
-        IPS_LogMessage("Belevo_Server_Kommunikation", "Fehler beim Senden an Influx: " . $error);
+            IPS_LogMessage(
-    } else {
+                "Belevo_Server_Kommunikation",
-        IPS_LogMessage("Belevo_Server_Kommunikation", "HTTP-Status: " . $httpCode);
+                "Fehler beim Senden an Influx: " . $error
-        IPS_LogMessage("Belevo_Server_Kommunikation", "Antwort von Influx: " . $result);
+            );
         }
     }
-
-
-
 }
 
 ?>

Boiler_2_Stufig_Mit_Fueler/locale.json

@@ -1,7 +0,0 @@
-{
-    "translations": {
-        "de": {
-
-        }
-    }
-}

Boiler_2_Stufig_Mit_Fueler/module.php

@@ -1,8 +1,9 @@
 <?php
 
-class Boiler_2_Stufig_Mit_Fueler extends IPSModule {
+class Boiler_2_Stufig_Mit_Fueler extends IPSModule
-
+{
-    public function Create() {
+    public function Create()
+    {
         parent::Create();
 
         // Prioritäten
@@ -39,12 +40,14 @@ class Boiler_2_Stufig_Mit_Fueler extends IPSModule {
         $this->SetValue("Idle", true);
     }
 
-    public function ApplyChanges() {
+    public function ApplyChanges()
+    {
         parent::ApplyChanges();
     }
 
     // Aktionen verarbeiten
-    public function RequestAction($Ident, $Value) {
+    public function RequestAction($Ident, $Value)
+    {
         switch ($Ident) {
             case "SetCurrentPower":
                 $this->SetCurrentPower($Value);
@@ -57,12 +60,15 @@ class Boiler_2_Stufig_Mit_Fueler extends IPSModule {
     }
 
     // Methode zum Setzen des aktuellen Stromverbrauchs
-    public function SetCurrentPower(int $power) {
+    public function SetCurrentPower(int $power)
+    {
         // Schalte Kontakt Teillast und Vollast entsprechend der Power-Einstellung
         if ($power == $this->ReadPropertyInteger("BoilerLeistungVolllast")) {
             SetValue($this->ReadPropertyInteger("Kontakt_Volllast"), true);
             SetValue($this->ReadPropertyInteger("Kontakt_Teillast"), false);
-        } elseif ($power == $this->ReadPropertyInteger("BoilerLeistungTeillast")) {
+        } elseif (
+            $power == $this->ReadPropertyInteger("BoilerLeistungTeillast")
+        ) {
             SetValue($this->ReadPropertyInteger("Kontakt_Volllast"), false);
             SetValue($this->ReadPropertyInteger("Kontakt_Teillast"), true);
         } else {
@@ -74,7 +80,10 @@ class Boiler_2_Stufig_Mit_Fueler extends IPSModule {
         $lastPower = GetValue($this->GetIDForIdent("CurrentPower"));
         if ($power != $lastPower) {
             $this->SetValue("Idle", false);
-            $this->SetValue("IdleCounter", $this->ReadPropertyInteger("IdleCounterMax"));
+            $this->SetValue(
+                "IdleCounter",
+                $this->ReadPropertyInteger("IdleCounterMax")
+            );
         }
 
         // Setze die neue CurrentPower
@@ -84,10 +93,9 @@ class Boiler_2_Stufig_Mit_Fueler extends IPSModule {
         $this->ProcessIdleCounter();
     }
 
-
     // Methode zum Abrufen der aktuellen Daten
-    public function GetCurrentData(bool $Peak) {
+    public function GetCurrentData(bool $Peak)
-
+    {
         $LegioCounter = $this->GetValue("LegioCounter");
 
         $boilerTemp = GetValue($this->ReadPropertyInteger("Boilertemperatur"));
@@ -97,69 +105,73 @@ class Boiler_2_Stufig_Mit_Fueler extends IPSModule {
         $teilLeistung = $this->ReadPropertyInteger("BoilerLeistungTeillast");
         $vollLeistung = $this->ReadPropertyInteger("BoilerLeistungVolllast");
 
-        $AktuelleVollast = GetValue($this->ReadPropertyInteger("Kontakt_Volllast")); 
+        $AktuelleVollast = GetValue(
-        $AktuelleTeillast = GetValue($this->ReadPropertyInteger("Kontakt_Teillast")); 
+            $this->ReadPropertyInteger("Kontakt_Volllast")
+        );
+        $AktuelleTeillast = GetValue(
+            $this->ReadPropertyInteger("Kontakt_Teillast")
+        );
 
         if ($boilerTemp > $LegioTemp) {
             $LegioCounter = 0;
-            IPS_LogMessage("im1", $LegioCounter);
-
         } else {
             $LegioCounter = $LegioCounter + 1;
-            IPS_LogMessage("im2", $LegioCounter);
- 
         }
         if ($LegioCounter > 69120) {
             $maxTemp = $LegioTemp;
-            IPS_LogMessage("im3", $LegioCounter);
-
-        
         }
-        if(($LegioCounter>120960) && ($this->ist_nachts())){
+        if ($LegioCounter > 120960 && $this->ist_nachts()) {
             $minTemp = $LegioTemp;
-            IPS_LogMessage("im4", $LegioCounter);
-
         }
 
         $this->SetValue("LegioCounter", $LegioCounter);
 
-
         if ($Peak) {
             if ($boilerTemp < $minTemp) {
-                $this->SetValue("PowerSteps", json_encode([0, $teilLeistung, $vollLeistung]));
+                $this->SetValue(
-
+                    "PowerSteps",
-            } elseif ($boilerTemp < ($minTemp + 5) && ($AktuelleVollast || $AktuelleTeillast)) {
+                    json_encode([0, $teilLeistung, $vollLeistung])
-
+                );
-                $this->SetValue("PowerSteps", json_encode([0, $teilLeistung, $vollLeistung]));
+            } elseif (
-            }
+                $boilerTemp < $minTemp + 5 &&
-            else {
+                ($AktuelleVollast || $AktuelleTeillast)
+            ) {
+                $this->SetValue(
+                    "PowerSteps",
+                    json_encode([0, $teilLeistung, $vollLeistung])
+                );
+            } else {
                 $this->SetValue("PowerSteps", json_encode([0]));
-
             }
         } else {
             if ($boilerTemp < $minTemp) {
                 $this->SetValue("PowerSteps", json_encode([$vollLeistung]));
-
+            } elseif (
-            } elseif ($boilerTemp < ($minTemp + 5) && ($AktuelleVollast || $AktuelleTeillast)) {
+                $boilerTemp < $minTemp + 5 &&
+                ($AktuelleVollast || $AktuelleTeillast)
+            ) {
                 $this->SetValue("PowerSteps", json_encode([$vollLeistung]));
-
+            } elseif ($boilerTemp < $maxTemp - 5) {
-            }
+                $this->SetValue(
-            elseif ($boilerTemp < ($maxTemp-5)) {
+                    "PowerSteps",
-
+                    json_encode([0, $teilLeistung, $vollLeistung])
-                $this->SetValue("PowerSteps", json_encode([0, $teilLeistung, $vollLeistung]));
+                );
-            } 
+            } elseif (
-            elseif ($boilerTemp < ($maxTemp) && ($AktuelleVollast || $AktuelleTeillast)) {
+                $boilerTemp < $maxTemp &&
-
+                ($AktuelleVollast || $AktuelleTeillast)
-                $this->SetValue("PowerSteps", json_encode([0, $teilLeistung, $vollLeistung]));
+            ) {
-            }
+                $this->SetValue(
-            else {
+                    "PowerSteps",
-
+                    json_encode([0, $teilLeistung, $vollLeistung])
+                );
+            } else {
                 $this->SetValue("PowerSteps", json_encode([0]));
             }
         }
     }
 
-    private function ProcessIdleCounter() {
+    private function ProcessIdleCounter()
+    {
         // IdleCounter auslesen und verarbeiten
         $idleCounter = $this->GetValue("IdleCounter");
         if ($idleCounter > 0) {
@@ -170,11 +182,15 @@ class Boiler_2_Stufig_Mit_Fueler extends IPSModule {
         }
     }
 
-    private function CheckIdle($power) {
+    private function CheckIdle($power)
+    {
         $lastpower = GetValue("CurrentPower");
         if ($lastpower != GetValue("CurrentPower")) {
             $this->SetValue("Idle", false);
-            $this->SetValue("IdleCounter", $this->ReadPropertyInteger("IdleCounterMax"));
+            $this->SetValue(
+                "IdleCounter",
+                $this->ReadPropertyInteger("IdleCounterMax")
+            );
         }
         // IdleCounter auslesen und verarbeiten
         $idleCounter = $this->GetValue("IdleCounter");
@@ -186,13 +202,13 @@ class Boiler_2_Stufig_Mit_Fueler extends IPSModule {
         }
     }
 
+    private function ist_nachts()
+    {
+        date_default_timezone_set("Europe/Berlin"); // Setze hier deine Zeitzone
 
-    private function ist_nachts() {
+        $aktuelle_zeit = strtotime(date("H:i")); // Aktuelle Zeit in Stunden und Minuten umwandeln
-        date_default_timezone_set('Europe/Berlin'); // Setze hier deine Zeitzone
+        $start_nacht = strtotime("22:00"); // Startzeit der Nacht (22 Uhr)
-        
+        $ende_nacht = strtotime("07:00"); // Endzeit der Nacht (7 Uhr)
-        $aktuelle_zeit = strtotime(date('H:i')); // Aktuelle Zeit in Stunden und Minuten umwandeln
-        $start_nacht = strtotime('22:00'); // Startzeit der Nacht (22 Uhr)
-        $ende_nacht = strtotime('07:00'); // Endzeit der Nacht (7 Uhr)
 
         if ($aktuelle_zeit >= $start_nacht || $aktuelle_zeit < $ende_nacht) {
             return true;

CC100_HW/locale.json

@@ -1,9 +0,0 @@
-
-{
-    "translations": {
-        "de": {
-            "Translation 1": "Übersetzung 1",
-            "Translation 2": "Übersetzung 2"
-        }
-    }
-}

CC100_HW/module.php

@@ -2,41 +2,53 @@
 
 class CC100_HW extends IPSModule
 {
-    private $DigOutPID = '/sys/kernel/dout_drv/DOUT_DATA';
+    private $DigOutPID = "/sys/kernel/dout_drv/DOUT_DATA";
-    private $PT1PID = '/sys/bus/iio/devices/iio:device2/in_voltage13_raw';
+    private $PT1PID = "/sys/bus/iio/devices/iio:device2/in_voltage13_raw";
-    private $PT2PID = '/sys/bus/iio/devices/iio:device2/in_voltage1_raw';
+    private $PT2PID = "/sys/bus/iio/devices/iio:device2/in_voltage1_raw";
+    private $DIN_FILE = "/sys/bus/iio/devices/iio:device2/in_voltage1_raw";
     private $waitingTime = 1; // Waiting time (in ms) for a new attempt to write a digital output (if file is blocked)
     private $maxTime = 5000; // Max time (in ms) for the writing process
 
     public function Create()
     {
         parent::Create();
-        $this->RegisterPropertyString('FilePath', $this->DigOutPID);
+        $this->RegisterPropertyString("FilePath", $this->DigOutPID);
-        $this->RegisterVariableBoolean('Bit1', 'DO 1', '~Switch', 1);
+        $this->RegisterVariableBoolean("Bit1", "DO 1", "~Switch", 1);
-        $this->RegisterVariableBoolean('Bit2', 'DO 2', '~Switch', 2);
+        $this->RegisterVariableBoolean("Bit2", "DO 2", "~Switch", 2);
-        $this->RegisterVariableBoolean('Bit3', 'DO 3', '~Switch', 3);
+        $this->RegisterVariableBoolean("Bit3", "DO 3", "~Switch", 3);
-        $this->RegisterVariableBoolean('Bit4', 'DO 4', '~Switch', 4);
+        $this->RegisterVariableBoolean("Bit4", "DO 4", "~Switch", 4);
+
+        $this->RegisterVariableBoolean("DI1", "DI1");
+        $this->RegisterVariableBoolean("DI2", "DI2");
+        $this->RegisterVariableBoolean("DI3", "DI3");
+        $this->RegisterVariableBoolean("DI4", "DI4");
+        $this->RegisterVariableBoolean("DI5", "DI5");
+        $this->RegisterVariableBoolean("DI6", "DI6");
+        $this->RegisterVariableBoolean("DI7", "DI7");
+        $this->RegisterVariableBoolean("DI8", "DI8");
+
         $this->RegisterVariableFloat('PT1', 'PT1 Temperatur', '~Temperature', 5);
         $this->RegisterVariableFloat('PT2', 'PT2 Temperatur', '~Temperature', 6);
-        $this->EnableAction('Bit1');
+        $this->EnableAction("Bit1");
-        $this->EnableAction('Bit2');
+        $this->EnableAction("Bit2");
-        $this->EnableAction('Bit3');
+        $this->EnableAction("Bit3");
-        $this->EnableAction('Bit4');
+        $this->EnableAction("Bit4");
 
+        // Timer für PT1 und PT2 einrichten
         // Timer für PT1 und PT2 einrichten
         $this->RegisterTimer("ReadPTValues", 30000, 'IPS_RequestAction(' . $this->InstanceID . ', "DOUT_ReadPTValues", "");');
-        $this->RegisterTimer("WriteBits", 1000, 'IPS_RequestAction(' . $this->InstanceID . ', "UpdateFile", "");');
+        $this->RegisterTimer("WriteBits", 2000, 'IPS_RequestAction(' . $this->InstanceID . ', "UpdateFile", "");');
-
     }
 
     public function ApplyChanges()
     {
         parent::ApplyChanges();
         // Timer aktivieren
-        $this->SetTimerInterval('ReadPTValues', 30000);
+        $this->SetTimerInterval("ReadPTValues", 30000);
     }
 
-    public function RequestAction($Ident, $Value) {
+    public function RequestAction($Ident, $Value)
+    {
         switch ($Ident) {
             case "DOUT_ReadPTValues":
                 $this->DOUT_ReadPTValues();
@@ -51,37 +63,92 @@ class CC100_HW extends IPSModule
 
     private function UpdateFile()
     {
-        $starttime = microtime(true) * 1000;
+        $starttime = microtime(true) * 2000;
         $this->TryWriteFile($starttime);
     }
 
+    private function readAndConvertToBools($filePath)
+    {
+        // Inhalt der Datei auslesen
+        $content = @file_get_contents($filePath);
+
+        if ($content === false) {
+            throw new Exception("Fehler beim Lesen der Datei $filePath.");
+        }
+
+        // Die gelesene Zahl bereinigen (Leerzeichen oder Zeilenumbrüche entfernen)
+        $number = trim($content);
+
+        // Sicherstellen, dass die Zahl gültig ist
+        if (!ctype_digit($number)) {
+            throw new Exception(
+                "Der Inhalt der Datei ist keine gültige Zahl: $number"
+            );
+        }
+
+        // Die Zahl in einen Integer umwandeln
+        $intValue = (int) $number;
+
+        // Sicherstellen, dass die Zahl zwischen 0 und 255 liegt
+        if ($intValue < 0 || $intValue > 255) {
+            throw new Exception(
+                "Die Zahl muss zwischen 0 und 255 liegen: $intValue"
+            );
+        }
+
+        // In einen 8-Bit-Binärstring umwandeln
+        $binaryString = str_pad(decbin($intValue), 8, "0", STR_PAD_LEFT);
+
+        // Binärwerte in ein Array von booleschen Werten umwandeln
+        $boolValues = array_map(
+            fn($bit) => $bit === "1",
+            str_split($binaryString)
+        );
+
+        $this->SetValue("DI1", $boolValues[7]);
+        $this->SetValue("DI2", $boolValues[6]);
+        $this->SetValue("DI3", $boolValues[5]);
+        $this->SetValue("DI4", $boolValues[4]);
+        $this->SetValue("DI5", $boolValues[3]);
+        $this->SetValue("DI6", $boolValues[2]);
+        $this->SetValue("DI7", $boolValues[1]);
+        $this->SetValue("DI8", $boolValues[0]);
+        return $boolValues;
+    }
+
     private function TryWriteFile($starttime)
     {
-        $currentTime = microtime(true) * 1000;
+        $this->readAndConvertToBools($DIN_FILE);
-        if (($currentTime - $starttime) <= $this->maxTime) {
-            $file = $this->ReadPropertyString('FilePath');
-            if (is_writable($file)) {
-                $bit1 = GetValueBoolean($this->GetIDForIdent('Bit1'));
-                $bit2 = GetValueBoolean($this->GetIDForIdent('Bit2'));
-                $bit3 = GetValueBoolean($this->GetIDForIdent('Bit3'));
-                $bit4 = GetValueBoolean($this->GetIDForIdent('Bit4'));
 
-                $value = ($bit4 ? 8 : 0) + ($bit3 ? 4 : 0) + ($bit2 ? 2 : 0) + ($bit1 ? 1 : 0);
+        $currentTime = microtime(true) * 1000;
+        if ($currentTime - $starttime <= $this->maxTime) {
+            $file = $this->ReadPropertyString("FilePath");
+            if (is_writable($file)) {
+                $bit1 = GetValueBoolean($this->GetIDForIdent("Bit1"));
+                $bit2 = GetValueBoolean($this->GetIDForIdent("Bit2"));
+                $bit3 = GetValueBoolean($this->GetIDForIdent("Bit3"));
+                $bit4 = GetValueBoolean($this->GetIDForIdent("Bit4"));
+
+                $value =
+                    ($bit4 ? 8 : 0) +
+                    ($bit3 ? 4 : 0) +
+                    ($bit2 ? 2 : 0) +
+                    ($bit1 ? 1 : 0);
 
                 if (@file_put_contents($file, $value) === false) {
-                    IPS_LogMessage("DOUTModule", "Fehler: Datei $file konnte nicht beschrieben werden. Möglicherweise gesperrt.");
-                    usleep($this->waitingTime * 1000);
-                    $this->TryWriteFile($starttime);
-                } else {
-                    IPS_LogMessage("DOUTModule", "Wert $value erfolgreich in die Datei $file geschrieben.");
-                }
-            } else {
-                IPS_LogMessage("DOUTModule", "Fehler: Datei $file ist nicht schreibbar.");
                     usleep($this->waitingTime * 1000);
                     $this->TryWriteFile($starttime);
                 } 
             } else {
-            IPS_LogMessage("DOUTModule", "Fehler: Schreibvorgang für Datei $file hat zu lange gedauert.");
+
+                usleep($this->waitingTime * 1000);
+                $this->TryWriteFile($starttime);
+            }
+        } else {
+            IPS_LogMessage(
+                "DOUTModule",
+                "Fehler: Schreibvorgang für Datei $file hat zu lange gedauert."
+            );
         }
     }
 
@@ -90,8 +157,8 @@ class CC100_HW extends IPSModule
         $pt1Value = $this->ReadPTValue($this->PT1PID);
         $pt2Value = $this->ReadPTValue($this->PT2PID);
 
-        SetValue($this->GetIDForIdent('PT1'), $pt1Value);
+        SetValue($this->GetIDForIdent("PT1"), $pt1Value);
-        SetValue($this->GetIDForIdent('PT2'), $pt2Value);
+        SetValue($this->GetIDForIdent("PT2"), $pt2Value);
     }
 
     private function ReadPTValue($file)
@@ -101,21 +168,35 @@ class CC100_HW extends IPSModule
             if ($data !== false) {
                 $data = intval($data);
                 $scale = 0;
-                if ($data >= 600 && $data < 3600) { $scale = 37;}
+                if ($data >= 600 && $data < 3600) {
-                else if ($data >= 3600 && $data < 6700) { $scale = 43;}
+                    $scale = 37;
-                else if ($data >= 6700 && $data < 9750) { $scale = 45;}
+                } elseif ($data >= 3600 && $data < 6700) {
-                else if ($data >= 9750 && $data < 12740) { $scale = 49;}
+                    $scale = 43;
-                else if ($data >= 12740 && $data < 15700) { $scale = 50.6;}
+                } elseif ($data >= 6700 && $data < 9750) {
-                else if ($data >= 15700 && $data < 21000) { $scale = 52.4;}
+                    $scale = 45;
-                else if ($data > 21000) { $scale = 53.7;}
+                } elseif ($data >= 9750 && $data < 12740) {
+                    $scale = 49;
+                } elseif ($data >= 12740 && $data < 15700) {
+                    $scale = 50.6;
+                } elseif ($data >= 15700 && $data < 21000) {
+                    $scale = 52.4;
+                } elseif ($data > 21000) {
+                    $scale = 53.7;
+                }
 
                 $numb = $data / $scale - 200;
                 return round($numb, 1);
             } else {
-                IPS_LogMessage("DOUTModule", "Fehler: Datei $file konnte nicht gelesen werden.");
+                IPS_LogMessage(
+                    "DOUTModule",
+                    "Fehler: Datei $file konnte nicht gelesen werden."
+                );
             }
         } else {
-            IPS_LogMessage("DOUTModule", "Fehler: Datei $file existiert nicht.");
+            IPS_LogMessage(
+                "DOUTModule",
+                "Fehler: Datei $file existiert nicht."
+            );
         }
         return 0;
     }

Ladestation_Universal/locale.json

@@ -1,8 +0,0 @@
-{
-    "translations": {
-        "de": {
-            "Translation 1": "Übersetzung 1",
-            "Translation 2": "Übersetzung 2"
-        }
-    }
-}

Ladestation_Universal/module.php

@@ -1,8 +1,9 @@
 <?php
 
-class Ladestation_Universal extends IPSModule {
+class Ladestation_Universal extends IPSModule
-
+{
-public function Create() {
+    public function Create()
+    {
         parent::Create();
 
         // Prioritäten
@@ -34,8 +35,6 @@ public function Create() {
         $this->RegisterVariableInteger("Lademodus", "Lademodus", "", 0);
         $this->RegisterVariableFloat("Ladeleistung_Effektiv", "Ladeleistung_Effektiv", "", 0);
 
-
-
         $this->RegisterVariableBoolean("Peak", "Peak", "", 0);
 
         $this->RegisterVariableInteger("Ladestrom", "Ladestrom");
@@ -45,13 +44,15 @@ public function Create() {
         $this->SetValue("Idle", true);
     }
 
-public function ApplyChanges() {
+    public function ApplyChanges()
+    {
         parent::ApplyChanges();
         // Zusätzliche Anpassungen nach Bedarf
     }
 
     // Aktionen verarbeiten
-public function RequestAction($Ident, $Value) {
+    public function RequestAction($Ident, $Value)
+    {
         switch ($Ident) {
             case "SetCurrentPower":
                 $this->SetCurrentPower($Value);
@@ -64,7 +65,8 @@ public function RequestAction($Ident, $Value) {
         }
     }
 
-public function SetCurrentPower(int $power) {
+    public function SetCurrentPower(int $power)
+    {
         $internalPower = GetValue($this->GetIDForIdent("CurrentPower"));
         // Aktuelle Leistungsvorgabe setzen
         SetValue($this->GetIDForIdent("CurrentPower"), $power);
@@ -73,7 +75,10 @@ public function SetCurrentPower(int $power) {
 
             // Idle für 4 Zyklen auf false setzen
             SetValue($this->GetIDForIdent("Idle"), false);
-        SetValue($this->GetIDForIdent("IdleCounter"), $this->ReadPropertyInteger("IdleCounterMax"));
+            SetValue(
+                $this->GetIDForIdent("IdleCounter"),
+                $this->ReadPropertyInteger("IdleCounterMax")
+            );
         } else {
             // IdleCallCounter herunterzählen, wenn power == interne Leistungsvorgabe
             $idleCounter = GetValue($this->GetIDForIdent("IdleCounter"));
@@ -86,80 +91,78 @@ public function SetCurrentPower(int $power) {
             }
         }
 
-
-
         // Ladeleistung setzen
         $peak = GetValue($this->GetIDForIdent("Peak"));
         $solarladen = GetValue($this->GetIDForIdent("Solarladen"));
         $Ladebereit = GetValue($this->GetIDForIdent("Ladebereit"));
         if (!$Ladebereit) {
-
             $this->sendPowerToStation(0);
             SetValue($this->GetIDForIdent("Ladeleistung"), 0);
             SetValue($this->GetIDForIdent("Ladestrom"), 0);
-
+        } elseif (!$peak && !$solarladen) {
-    }
-    elseif (!$peak && !$solarladen) {
             // Wenn weder Peak noch Solarladen aktiv sind, setze Ladeleistung auf MaxLeistung
-        SetValue($this->GetIDForIdent("Ladeleistung"), $this->ReadPropertyInteger("MaxLeistung"));
+            SetValue(
+                $this->GetIDForIdent("Ladeleistung"),
+                $this->ReadPropertyInteger("MaxLeistung")
+            );
 
             if (GetValue($this->GetIDForIdent("Lademodus")) == 0) {
-
+                SetValue(
-            SetValue($this->GetIDForIdent("Ladestrom"), $this->ReadPropertyInteger("MaxLeistung_1ph") / 240);
+                    $this->GetIDForIdent("Ladestrom"),
-            $this->sendPowerToStation($this->ReadPropertyInteger("MaxLeistung_1ph"));
+                    $this->ReadPropertyInteger("MaxLeistung_1ph") / 240
-
+                );
+                $this->sendPowerToStation(
+                    $this->ReadPropertyInteger("MaxLeistung_1ph")
+                );
             } elseif (GetValue($this->GetIDForIdent("Lademodus")) == 1) {
-            
+                SetValue(
-            SetValue($this->GetIDForIdent("Ladestrom"), $this->ReadPropertyInteger("MaxLeistung") / 400 / sqrt(3));
+                    $this->GetIDForIdent("Ladestrom"),
-            $this->sendPowerToStation($this->ReadPropertyInteger("MaxLeistung"));
+                    $this->ReadPropertyInteger("MaxLeistung") / 400 / sqrt(3)
-
+                );
+                $this->sendPowerToStation(
+                    $this->ReadPropertyInteger("MaxLeistung")
+                );
             }
-
         } else {
             // Ansonsten setze Ladeleistung auf die aktuelle Leistungsvorgabe (CurrentPower)
             SetValue($this->GetIDForIdent("Ladeleistung"), $power);
 
             if (GetValue($this->GetIDForIdent("Lademodus")) == 0) {
-
                 SetValue($this->GetIDForIdent("Ladestrom"), $power / 240);
-
             } elseif (GetValue($this->GetIDForIdent("Lademodus")) == 1) {
-            
+                SetValue(
-            SetValue($this->GetIDForIdent("Ladestrom"), $power / 400 / sqrt(3));
+                    $this->GetIDForIdent("Ladestrom"),
-
+                    $power / 400 / sqrt(3)
+                );
             }
 
             $this->sendPowerToStation($power);
         }
     }
 
-
     // Methode zum Abrufen der aktuellen Daten
-public function GetCurrentData(bool $Peak) {
+    public function GetCurrentData(bool $Peak)
+    {
         // Aktuelle Properties abrufen
         $ladebereit = GetValue($this->GetIDForIdent("Ladebereit"));
         $solarladen = GetValue($this->GetIDForIdent("Solarladen"));
 
-
         if (GetValue($this->GetIDForIdent("Lademodus")) == 0) {
-
             $minLeistung = $this->ReadPropertyInteger("MinLeistung_1ph");
             $maxLeistung = $this->ReadPropertyInteger("MaxLeistung_1ph");
-
         } elseif (GetValue($this->GetIDForIdent("Lademodus")) == 1) {
-        
             $minLeistung = $this->ReadPropertyInteger("MinLeistung");
             $maxLeistung = $this->ReadPropertyInteger("MaxLeistung");
         }
 
-
-
-
-
         $ch = curl_init();
 
         // Setze die URL
-    curl_setopt($ch, CURLOPT_URL, "http://" . $this->ReadPropertyString("IP_Adresse") . "/api/status");
+        curl_setopt(
+            $ch,
+            CURLOPT_URL,
+            "http://" . $this->ReadPropertyString("IP_Adresse") . "/api/status"
+        );
 
         // Setze die Option, die Antwort als String zurückzugeben
         curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
@@ -176,29 +179,24 @@ public function GetCurrentData(bool $Peak) {
             $data = json_decode($response, true);
 
             // Überprüfe, ob das JSON-Dekodieren erfolgreich war und der Schlüssel "car" existiert
-        if (json_last_error() === JSON_ERROR_NONE && isset($data['car'])) {
+            if (json_last_error() === JSON_ERROR_NONE && isset($data["car"])) {
                 // Speichere den Wert von "car" in der Variable $status
 
+                SetValue(
+                    $this->GetIDForIdent("Ladeleistung_Effektiv"),
+                    $data["nrg"][11]
+                );
 
-            SetValue($this->GetIDForIdent("Ladeleistung_Effektiv"), $data['nrg'][11]);
+                SetValue($this->GetIDForIdent("Fahrzeugstatus"), $data["car"]);
 
-            SetValue($this->GetIDForIdent("Fahrzeugstatus"), $data['car']);
+                if ($data["nrg"][6] > 1 && $data["car"] == 2) {
-
-
-            if($data['nrg'][6]>1 && $data['car']==2){
                     SetValue($this->GetIDForIdent("Lademodus"), 1);
-
+                } elseif ($data["nrg"][6] <= 1 && $data["car"] == 2) {
-            }elseif($data['nrg'][6]<=1 && $data['car']==2){
                     SetValue($this->GetIDForIdent("Lademodus"), 0);
-
                 }
             }
         }
 
-
-
-
-
         // Peak-Wert speichern
         $this->SetValue("Peak", $Peak);
 
@@ -209,19 +207,25 @@ public function GetCurrentData(bool $Peak) {
             // Konfiguration des powerSteps-Arrays basierend auf den Properties
             if (!$ladebereit) {
                 $powerSteps = [0];
-
             } elseif (!$Peak && !$solarladen) {
-
                 $powerSteps = [$maxLeistung];
             } elseif (!$Peak && $solarladen) {
-            $powerSteps = array_merge($powerSteps, $this->getRangeLimits($minLeistung, $maxLeistung, GetValue($this->GetIDForIdent("Lademodus"))));
+                $powerSteps = array_merge(
-
+                    $powerSteps,
+                    $this->getRangeLimits(
+                        $minLeistung,
+                        $maxLeistung,
+                        GetValue($this->GetIDForIdent("Lademodus"))
+                    )
+                );
             } elseif ($solarladen && $Peak) {
                 $powerSteps = [0];
-
             } else {
-            $powerSteps += $this->getRangeLimits($minLeistung, $maxLeistung, GetValue($this->GetIDForIdent("Lademodus")));        
+                $powerSteps += $this->getRangeLimits(
-
+                    $minLeistung,
+                    $maxLeistung,
+                    GetValue($this->GetIDForIdent("Lademodus"))
+                );
             }
         }
         // PowerSteps in der RegisterVariable speichern
@@ -231,12 +235,16 @@ public function GetCurrentData(bool $Peak) {
         return $powerSteps;
     }
 
-
+    public function sendPowerToStation($value)
-public function sendPowerToStation($value) {
+    {
         // Base URL
-    $baseUrl = "http://" . $this->ReadPropertyString("IP_Adresse") . "/api/set?";
+        $baseUrl =
+            "http://" . $this->ReadPropertyString("IP_Adresse") . "/api/set?";
         IPS_LogMessage("Ladestation", "Aufgerufene ip" . $baseUrl);
-    $value = $this->convertPowerToCurrent($value, GetValue($this->GetIDForIdent("Lademodus"))); 
+        $value = $this->convertPowerToCurrent(
+            $value,
+            GetValue($this->GetIDForIdent("Lademodus"))
+        );
         // Initialize a cURL session
         $ch = curl_init();
 
@@ -261,7 +269,7 @@ public function sendPowerToStation($value) {
             // Check for errors
             if (curl_errno($ch)) {
                 curl_close($ch);
-            return 'Error:' . curl_error($ch);
+                return "Error:" . curl_error($ch);
             }
 
             // Second request
@@ -272,7 +280,7 @@ public function sendPowerToStation($value) {
             // Check for errors
             if (curl_errno($ch)) {
                 curl_close($ch);
-            return 'Error:' . curl_error($ch);
+                return "Error:" . curl_error($ch);
             }
 
             // Close cURL session
@@ -288,8 +296,8 @@ public function sendPowerToStation($value) {
         }
     }
 
-public function convertPowerToCurrent($value, $Lademodus) {
+    public function convertPowerToCurrent($value, $Lademodus)
-    
+    {
         if ($Lademodus == 1) {
             if ($value == 0) {
                 return 0;
@@ -349,7 +357,6 @@ public function convertPowerToCurrent($value, $Lademodus) {
                 return 32;
             }
             return 0;
-
         } elseif ($Lademodus == 0) {
             if ($value == 0) {
                 return 0;
@@ -409,12 +416,11 @@ public function convertPowerToCurrent($value, $Lademodus) {
                 return 32;
             }
             return 0;
-    
-
         }
     }
 
-public function getRangeLimits($min, $max, $Lademodus) {
+    public function getRangeLimits($min, $max, $Lademodus)
+    {
         if ($Lademodus == 1) {
             $limits = [
                 4150,
@@ -443,9 +449,9 @@ public function getRangeLimits($min, $max, $Lademodus) {
                 20100,
                 20800,
                 21500,
-        22000
+                22000,
-    ];}
+            ];
-    elseif($Lademodus==0){
+        } elseif ($Lademodus == 0) {
             $limits = [
                 1450,
                 1690,
@@ -473,7 +479,7 @@ public function getRangeLimits($min, $max, $Lademodus) {
                 6970,
                 7210,
                 7450,
-            7690
+                7690,
             ];
         }
 
@@ -487,6 +493,5 @@ public function getRangeLimits($min, $max, $Lademodus) {
 
         return $result;
     }
-
 }
 ?>

Manager/locale.json

@@ -1,8 +0,0 @@
-{
-    "translations": {
-        "de": {
-            "Translation 1": "Übersetzung 1",
-            "Translation 2": "Übersetzung 2"
-        }
-    }
-}

Manager/module.php

@@ -1,8 +1,9 @@
 <?php
 
-class Manager extends IPSModule {
+class Manager extends IPSModule
-    
+{
-    public function Create() {
+    public function Create()
+    {
         parent::Create();
 
         // Systemvariablen registrieren
@@ -12,18 +13,25 @@ class Manager extends IPSModule {
         $this->RegisterPropertyString("EnergyUserList", "[]");
 
         // Timer registrieren
-        $this->RegisterTimer("Timer_DistributeEnergy", 5000, 'IPS_RequestAction(' . $this->InstanceID . ', "DistributeEnergy", "");');
+        $this->RegisterTimer(
+            "Timer_DistributeEnergy",
+            5000,
+            "IPS_RequestAction(" .
+                $this->InstanceID .
+                ', "DistributeEnergy", "");'
+        );
     }
 
-    public function ApplyChanges() {
+    public function ApplyChanges()
+    {
         parent::ApplyChanges();
 
         // Zusätzliche Konfigurationslogik hier hinzufügen
         $energyUserList = $this->ReadPropertyString("EnergyUserList");
-        IPS_LogMessage("Manager", "EnergyUserList: " . $energyUserList);
     }
 
-    public function RequestAction($Ident, $Value) {
+    public function RequestAction($Ident, $Value)
+    {
         switch ($Ident) {
             case "DistributeEnergy":
                 $this->DistributeEnergy();
@@ -36,22 +44,21 @@ class Manager extends IPSModule {
         }
     }
 
-    
+    public function DistributeEnergy()
-    public function DistributeEnergy() {
+    {
         // Systemvariablen abrufen
-        $Netzbezug = GetValue(($this->ReadPropertyInteger('Netzbezug'))); 
+        $Netzbezug = GetValue($this->ReadPropertyInteger("Netzbezug"));
-        $Peakleistung = $this->ReadPropertyInteger('Peakleistung');
+        $Peakleistung = $this->ReadPropertyInteger("Peakleistung");
-        $Ueberschussleistung = $this->ReadPropertyInteger('Ueberschussleistung');
+        $Ueberschussleistung = $this->ReadPropertyInteger(
-        IPS_LogMessage("Leistung", $Ueberschussleistung);
+            "Ueberschussleistung"
-        IPS_LogMessage("Netzbezug", $Netzbezug);
+        );
-        IPS_LogMessage("Peak", $Peakleistung);
 
         // Fallunterscheidung
         if ($Netzbezug < ($Peakleistung - $Ueberschussleistung) / 2) {
-            $remainingPower = (-1) * ((-1 * $Ueberschussleistung) + $Netzbezug);
+            $remainingPower = -1 * (-1 * $Ueberschussleistung + $Netzbezug);
             $getCurrentDataParam = false;
         } else {
-            $remainingPower =  ($Peakleistung - $Netzbezug);
+            $remainingPower = $Peakleistung - $Netzbezug;
             $getCurrentDataParam = true;
         }
 
@@ -66,8 +73,12 @@ class Manager extends IPSModule {
 
         // Schleife, um IPS_RequestAction für alle Benutzer auszuführen
         foreach ($energyUserList as $user) {
-            if (IPS_InstanceExists($user['EnergyUser'])) {
+            if (IPS_InstanceExists($user["EnergyUser"])) {
-                IPS_RequestAction($user['EnergyUser'], 'GetCurrentData', $getCurrentDataParam);
+                IPS_RequestAction(
+                    $user["EnergyUser"],
+                    "GetCurrentData",
+                    $getCurrentDataParam
+                );
             }
         }
 
@@ -76,31 +87,29 @@ class Manager extends IPSModule {
         $totalCurrentPower = 0; // Variable zur Summierung der CurrentPower Werte
 
         foreach ($energyUserList as $user) {
-            if (!IPS_InstanceExists($user['EnergyUser'])) {
+            if (!IPS_InstanceExists($user["EnergyUser"])) {
-                IPS_LogMessage("Manager", "Instance does not exist: " . $user['EnergyUser']);
                 continue;
             }
 
             // Werte direkt von der EnergyUser-Instanz abrufen
-            $currentPower = GetValue(IPS_GetObjectIDByIdent('CurrentPower', $user['EnergyUser']));
+            $currentPower = GetValue(IPS_GetObjectIDByIdent("CurrentPower", $user["EnergyUser"]));
-            $usedEnergy = GetValue(IPS_GetObjectIDByIdent('UsedEnergy', $user['EnergyUser']));
+            $usedEnergy = GetValue(IPS_GetObjectIDByIdent("UsedEnergy", $user["EnergyUser"]));
-            $userPrio = GetValue(IPS_GetObjectIDByIdent('UserPrio', $user['EnergyUser']));
+            $userPrio = GetValue(IPS_GetObjectIDByIdent("UserPrio", $user["EnergyUser"]));
-            $lockPrio = GetValue(IPS_GetObjectIDByIdent('LockPrio', $user['EnergyUser']));
+            $lockPrio = GetValue(IPS_GetObjectIDByIdent("LockPrio", $user["EnergyUser"]));
-            $idle = GetValue(IPS_GetObjectIDByIdent('Idle', $user['EnergyUser']));
+            $idle = GetValue(IPS_GetObjectIDByIdent("Idle", $user["EnergyUser"]));
-            $powerStepsJson = GetValue(IPS_GetObjectIDByIdent('PowerSteps', $user['EnergyUser']));
+            $powerStepsJson = GetValue(IPS_GetObjectIDByIdent("PowerSteps", $user["EnergyUser"]));
             $powerSteps = json_decode($powerStepsJson, true);
-            IPS_LogMessage("Manager", "PowerSteps for EnergyUser {$user['EnergyUser']}: " . print_r($powerSteps, true));
 
             // EnergyUser-Daten zum gefilterten Array hinzufügen
             $filteredEnergyUsers[] = [
-                'EnergyUser' => $user['EnergyUser'],
+                "EnergyUser" => $user["EnergyUser"],
-                'InstanceID' => $user['EnergyUser'],
+                "InstanceID" => $user["EnergyUser"],
-                'CurrentPower' => $currentPower,
+                "CurrentPower" => $currentPower,
-                'UsedEnergy' => $usedEnergy,
+                "UsedEnergy" => $usedEnergy,
-                'UserPrio' => $userPrio,
+                "UserPrio" => $userPrio,
-                'LockPrio' => $lockPrio,
+                "LockPrio" => $lockPrio,
-                'Idle' => $idle,
+                "Idle" => $idle,
-                'PowerSteps' => $powerSteps // PowerSteps direkt hier hinzufügen
+                "PowerSteps" => $powerSteps, // PowerSteps direkt hier hinzufügen
             ];
 
             // Überprüfen, ob alle Benutzer Idle = true sind
@@ -113,10 +122,6 @@ class Manager extends IPSModule {
         }
         $remainingPower += $totalCurrentPower;
 
-        // Debug-Ausgabe der gefilterten EnergyUser-Instanzen
-        IPS_LogMessage("Manager", "Filtered Energy Users: " . print_r($filteredEnergyUsers, true));
-        IPS_LogMessage("Manager", "Remaining Power after adding CurrentPower: " . $remainingPower);
-    
         if (empty($filteredEnergyUsers)) {
             return;
         }
@@ -124,99 +129,145 @@ class Manager extends IPSModule {
         // Wenn nicht alle Benutzer Idle = true sind, rufe SetCurrentPower mit CurrentPower Werten auf
         if (!$allIdle) {
             foreach ($filteredEnergyUsers as $user) {
-                IPS_RequestAction($user['InstanceID'], 'SetCurrentPower', $user['CurrentPower']);
+                IPS_RequestAction(
-                IPS_LogMessage("Manager", "SetCurrentPower for instance {$user['InstanceID']} to {$user['CurrentPower']} (Idle = false)");
+                    $user["InstanceID"],
+                    "SetCurrentPower",
+                    $user["CurrentPower"]
+                );
             }
             return;
         }
 
         // Sortiere die EnergyUser nach Priorität basierend auf dem Parameter
-    usort($filteredEnergyUsers, function($a, $b) use ($getCurrentDataParam) {
+        usort($filteredEnergyUsers, function ($a, $b) use (
-        $primaryKey = $getCurrentDataParam ? 'LockPrio' : 'UserPrio';
+            $getCurrentDataParam
+        ) {
+            $primaryKey = $getCurrentDataParam ? "LockPrio" : "UserPrio";
 
             if ($a[$primaryKey] == $b[$primaryKey]) {
-            return $a['UsedEnergy'] <=> $b['UsedEnergy'];
+                return $a["UsedEnergy"] <=> $b["UsedEnergy"];
             }
 
             return $a[$primaryKey] <=> $b[$primaryKey];
         });
 
         // Primärschlüssel für die Priorität basierend auf dem Parameter auswählen
-        $priorityKey = $getCurrentDataParam ? 'LockPrio' : 'UserPrio';
+        $priorityKey = $getCurrentDataParam ? "LockPrio" : "UserPrio";
 
         // Schleife durch alle Prioritäten
-$priorities = array_unique(array_column($filteredEnergyUsers, $priorityKey));
+        $priorities = array_unique(
+            array_column($filteredEnergyUsers, $priorityKey)
+        );
+        $groupedUsers = [];
+
         foreach ($priorities as $priority) {
-    // EnergyUser mit gleicher Priorität sammeln
+            $groupedUsers[$priority] = array_filter(
-    $samePriorityUsers = array_filter($filteredEnergyUsers, function ($user) use ($priority, $priorityKey) {
+                $filteredEnergyUsers,
+                function ($user) use ($priority, $priorityKey) {
                     return $user[$priorityKey] == $priority;
-    });
+                }
+            );
+        }
+        // Jetzt kannst du die Benutzer gruppenweise verarbeiten
+        foreach ($groupedUsers as $priority => $users) {
+            // EnergyUser mit gleicher Priorität sammeln
+            $samePriorityUsers = isset($groupedUsers[$priority])
+                ? $groupedUsers[$priority]
+                : [];
 
             // Wenn keine EnergyUser mit gleicher Priorität vorhanden sind, überspringen
             if (empty($samePriorityUsers)) {
                 continue;
             }
+            $withZero = [];
+            $withoutZero = [];
+            // Verbraucher die nicht 0 Annhemen können, bekommen einfach den tiefsten wert
+            foreach ($samePriorityUsers as $entry) {
+                if (in_array(0, $entry["PowerSteps"])) {
+                    $withZero[] = $entry;
+                } else {
+                    $withoutZero[] = $entry;
+                }
+            }
+            // Methode für alle im withoutZero-Array aufrufen
+            if (!empty($withoutZero)) {
+                foreach ($withoutZero as $entry) {
+                    $instanceID = $entry["InstanceID"];
+                    $minPowerStep = min($entry["PowerSteps"]);
 
+                    // Simulierte Methode (Debug-Ausgabe)
+                    IPS_RequestAction(
+                        $instanceID,
+                        "SetCurrentPower",
+                        $minPowerStep
+                    );
+                    $remainingPower -= $entry["CurrentPower"];
+                }
+            }
+            $samePriorityUsers = $withZero;
             // Array für die verteilte Energie pro User erstellen
-    $userEnergyProv = array_fill_keys(array_column($samePriorityUsers, 'InstanceID'), 0); // Initialisierung für jeden Benutzer auf 0 setzen
+            $userEnergyProv = [];
+            $userEnergyProv = array_fill_keys(
+                array_column($samePriorityUsers, "InstanceID"),
+                0
+            ); // Initialisierung für jeden Benutzer auf 0 setzen
 
             // Alle Schritte der Benutzer in einem Array sammeln
             $allSteps = [];
             foreach ($samePriorityUsers as $user) {
-        foreach ($user['PowerSteps'] as $step) {
+                foreach ($user["PowerSteps"] as $step) {
-            $allSteps[] = ['user' => $user['InstanceID'], 'step' => $step];
+                    $allSteps[] = [
+                        "user" => $user["InstanceID"],
+                        "step" => $step,
+                    ];
                 }
             }
 
             // Sortiere die Schritte nach Größe
             usort($allSteps, function ($a, $b) {
-        return $a['step'] <=> $b['step'];
+                return $a["step"] <=> $b["step"];
             });
-    IPS_LogMessage("Allesteps", "Alle Steps :" . print_r($allSteps, true));
 
             // Iteriere durch alle Schritte
             foreach ($allSteps as $entry) {
-                $user = $entry['user'];
+                $user = $entry["user"];
-                $powerstep = $entry['step'];
+                $powerstep = $entry["step"];
 
                 // Überprüfe, ob noch genügend verbleibende Energie für den nächsten Schritt vorhanden ist
                 if ($remainingPower >= $powerstep - $userEnergyProv[$user]) {
                     // Aktualisiere die verbleibende Energie und die bereitgestellte Energie für den Benutzer
-                    $remainingPower -= ($powerstep - $userEnergyProv[$user]);
+                    $remainingPower -= $powerstep - $userEnergyProv[$user];
                     $userEnergyProv[$user] = $powerstep;
                 } //else {
                 // Wenn nicht genug Energie vorhanden ist, setze die verbleibende Energie
-                    // Test dieses break rauszunehmen ...   break;
                 //}
             }
 
             // Energie für jeden EnergyUser verbrauchen und loggen
             foreach ($userEnergyProv as $userInstanceID => $energy) {
-
+                $weui = min(
-                $weui = min(array_column(array_filter($allSteps, function($entry) use ($userInstanceID) {
+                    array_column(
-                    return $entry['user'] == $userInstanceID;
+                        array_filter($allSteps, function ($entry) use (
-                }), 'step'));
+                            $userInstanceID
-                ;
+                        ) {
-                IPS_LogMessage("Neuerlog", "aktuell ist energy $energy und powersteps min ist $weui und powersteps ist ");
+                            return $entry["user"] == $userInstanceID;
+                        }),
+                        "step"
+                    )
+                );
 
                 $energy = max($energy, $weui); // Testzeile
-                IPS_LogMessage("Neuerlog", "nun ist energy $energy ");
 
                 // Methode SetCurrentPower für jeden EnergyUser aufrufen
                 if (IPS_InstanceExists($userInstanceID)) {
-                    IPS_RequestAction($userInstanceID, 'SetCurrentPower', $energy); // Annahme: SetCurrentPower wird über eine Aktionsanfrage ausgeführt
+                    IPS_RequestAction(
-                    IPS_LogMessage("Manager", "SetCurrentPower for instance $userInstanceID to $energy");
+                        $userInstanceID,
+                        "SetCurrentPower",
+                        $energy
+                    ); // Annahme: SetCurrentPower wird über eine Aktionsanfrage ausgeführt
                 }
             }
-        }    // Debug-Ausgabe von allSteps und userEnergyProv
-        IPS_LogMessage("Manager", "Final allSteps: " . print_r($allSteps, true));
-        IPS_LogMessage("Manager", "Final userEnergyProv: " . print_r($userEnergyProv, true));
-    
-        // Debug-Ausgabe des Endzustands
-        foreach ($filteredEnergyUsers as $user) {
-            IPS_LogMessage("Manager", "Final state for instance {$user['InstanceID']}: CurrentPower = {$user['CurrentPower']}, UsedEnergy = {$user['UsedEnergy']}");
         }
     }
-    
 }
 ?>

Michisplayground/README.md

@@ -1,67 +0,0 @@
-# Manager_1
-Beschreibung des Moduls.
-
-### Inhaltsverzeichnis
-
-1. [Funktionsumfang](#1-funktionsumfang)
-2. [Voraussetzungen](#2-voraussetzungen)
-3. [Software-Installation](#3-software-installation)
-4. [Einrichten der Instanzen in IP-Symcon](#4-einrichten-der-instanzen-in-ip-symcon)
-5. [Statusvariablen und Profile](#5-statusvariablen-und-profile)
-6. [WebFront](#6-webfront)
-7. [PHP-Befehlsreferenz](#7-php-befehlsreferenz)
-
-### 1. Funktionsumfang
-
-*
-
-### 2. Voraussetzungen
-
-- IP-Symcon ab Version 7.1
-
-### 3. Software-Installation
-
-* Über den Module Store das 'Manager_1'-Modul installieren.
-* Alternativ über das Module Control folgende URL hinzufügen
-
-### 4. Einrichten der Instanzen in IP-Symcon
-
- Unter 'Instanz hinzufügen' kann das 'Manager_1'-Modul mithilfe des Schnellfilters gefunden werden.  
-	- Weitere Informationen zum Hinzufügen von Instanzen in der [Dokumentation der Instanzen](https://www.symcon.de/service/dokumentation/konzepte/instanzen/#Instanz_hinzufügen)
-
-__Konfigurationsseite__:
-
-Name     | Beschreibung
--------- | ------------------
-         |
-         |
-
-### 5. Statusvariablen und Profile
-
-Die Statusvariablen/Kategorien werden automatisch angelegt. Das Löschen einzelner kann zu Fehlfunktionen führen.
-
-#### Statusvariablen
-
-Name   | Typ     | Beschreibung
------- | ------- | ------------
-       |         |
-       |         |
-
-#### Profile
-
-Name   | Typ
------- | -------
-       |
-       |
-
-### 6. WebFront
-
-Die Funktionalität, die das Modul im WebFront bietet.
-
-### 7. PHP-Befehlsreferenz
-
-`boolean GEF_BeispielFunktion(integer $InstanzID);`
-Erklärung der Funktion.
-
-Beispiel:
-`GEF_BeispielFunktion(12345);`

Michisplayground/form.json

@@ -1,20 +0,0 @@
-{
-    "elements": [
-        {
-            "type": "Label",
-            "caption": "Verwende die Buttons, um den Zähler zu steuern."
-        },
-        {
-            "type": "Button",
-            "caption": "Addierer",
-            "onClick": "ZAEHL_AdditionMethode($id);"
-        },
-        {
-            "type": "Button",
-            "caption": "Zähler zurücksetzen",
-            "onClick": "ZAEHL_Subtraktionsmethode($id);"
-        }
-
-    ],
-    "actions": []
-}

Michisplayground/locale.json

@@ -1,7 +0,0 @@
-{
-    "translations": {
-        "de": {
-
-        }
-    }
-}

Michisplayground/module.json

@@ -1,11 +0,0 @@
-{
-    "id": "{{097D2D9F-2144-C47B-7755-6A0F93B24325}}",
-    "name": "Michisplayground",
-    "type": 3,
-    "vendor": "Belevo AG",
-    "parentRequirements": [],
-    "childRequirements": [],
-    "implemented": [],
-    "url": "",
-    "prefix": "ZAEHL"
-}

Michisplayground/module.php

@@ -1,48 +0,0 @@
-<?php
-
-class Michisplayground extends IPSModule {
-
-        // Konstruktor
-        public function __construct($InstanceID)
-        {
-            parent::__construct($InstanceID);
-        }
-    
-        public function ApplyChanges()
-    {
-        parent::ApplyChanges();
-        
-        // Registriere die Zählervariable, wenn sie nicht bereits existiert
-        if (!IPS_VariableExists($this->GetIDForIdent("Counter"))) {
-            $this->RegisterVariableInteger("Counter", "Zähler", "", 1);
-            SetValue($this->GetIDForIdent("Counter"), 0); // Setze den Zähler auf 0
-        }
-    }
-
-     // Methode zum Erhöhen des Zählers
-     public function AdditionMethode()
-     {
-         $currentValue = GetValue($this->GetIDForIdent("Counter"));
-         $newValue = $currentValue + 1;
-         SetValue($this->GetIDForIdent("Counter"), $newValue);
-         IPS_LogMessage("ErweiterterZaehlerModul", "Zähler erhöht: " . $newValue);
-     }
- 
-     // Methode zum Zurücksetzen des Zählers
-     public function Subtraktionsmethode()
-     {
-         SetValue($this->GetIDForIdent("Counter"), 0);
-         IPS_LogMessage("ErweiterterZaehlerModul", "Zähler zurückgesetzt.");
-     }
- 
-     // Methode zum Abfragen des Zählers
-     public function GetCounter()
-     {
-         $currentValue = GetValue($this->GetIDForIdent("Counter"));
-         IPS_LogMessage("ErweiterterZaehlerModul", "Aktueller Zählerstand: " . $currentValue);
-         return $currentValue; // Gibt den aktuellen Zählerstand zurück
-     }
-
-}
-
-?>

Verbraucher_1_Stufig/locale.json

@@ -1,8 +0,0 @@
-{
-    "translations": {
-        "de": {
-            "Translation 1": "Übersetzung 1",
-            "Translation 2": "Übersetzung 2"
-        }
-    }
-}

Verbraucher_1_Stufig/module.php

@@ -1,9 +1,10 @@
 <?php
-class Verbraucher_1_Stufig extends IPSModule {
+class Verbraucher_1_Stufig extends IPSModule
-
+{
     private $timerID;
 
-    public function Create() {
+    public function Create()
+    {
         parent::Create();
 
         // Prioritäten
@@ -33,20 +34,26 @@ class Verbraucher_1_Stufig extends IPSModule {
         $this->RegisterPropertyInteger("Schaltkontakt1", 0);
 
         // Timer für Zeit_Zwischen_Zustandswechseln
-        $this->RegisterTimer("ZustandswechselTimer", 0, 'IPS_RequestAction(' . $this->InstanceID . ', "ResetPowerSteps", "");');
+        $this->RegisterTimer(
-
+            "ZustandswechselTimer",
-
+            0,
+            "IPS_RequestAction(" .
+                $this->InstanceID .
+                ', "ResetPowerSteps", "");'
+        );
 
         //Initialisieren
         $this->SetValue("Idle", true);
     }
 
-    public function ApplyChanges() {
+    public function ApplyChanges()
+    {
         parent::ApplyChanges();
     }
 
     // Aktionen verarbeiten
-    public function RequestAction($Ident, $Value) {
+    public function RequestAction($Ident, $Value)
+    {
         switch ($Ident) {
             case "SetCurrentPower":
                 $this->SetCurrentPower($Value);
@@ -62,25 +69,31 @@ class Verbraucher_1_Stufig extends IPSModule {
         }
     }
 
-
     // Methode zum Setzen der PowerSteps und Timer starten
-    public function SetTimerOn() {
+    public function SetTimerOn()
-
+    {
         // Timer setzen, der nach "Zeit_Zwischen_Zustandswechseln" abläuft
-            $zeitZwischenZustandswechseln = $this->ReadPropertyInteger("Zeit_Zwischen_Zustandswechseln");
+        $zeitZwischenZustandswechseln = $this->ReadPropertyInteger(
-            $this->SetTimerInterval("ZustandswechselTimer", $zeitZwischenZustandswechseln * 60000); // Timer in Millisekunden
+            "Zeit_Zwischen_Zustandswechseln"
+        );
+        $this->SetTimerInterval(
+            "ZustandswechselTimer",
+            $zeitZwischenZustandswechseln * 60000
+        ); // Timer in Millisekunden
         IPS_LogMessage("Verbraucher", "In Set Methode");
 
         // Timer-Status auf true setzen
         $this->SetValue("IsTimerActive", true);
-        
     }
 
     // Methode zum Zurücksetzen von PowerSteps nach Ablauf des Timers
-    public function ResetPowerSteps() {
+    public function ResetPowerSteps()
+    {
         // PowerSteps wieder auf den ursprünglichen Zustand setzen (wie vorherige Funktionalität)
-        $this->SetValue("PowerSteps", json_encode([$this->GetValue("CurrentPower")]));
+        $this->SetValue(
-        IPS_LogMessage("Verbraucher", "In Reset Methode");
+            "PowerSteps",
+            json_encode([$this->GetValue("CurrentPower")])
+        );
 
         // Timer stoppen
         $this->SetTimerInterval("ZustandswechselTimer", 0);
@@ -89,7 +102,8 @@ class Verbraucher_1_Stufig extends IPSModule {
         $this->SetValue("IsTimerActive", false);
     }
     // Methode zum Setzen des aktuellen Stromverbrauchs
-    public function SetCurrentPower(float $power) {
+    public function SetCurrentPower(float $power)
+    {
         $this->CheckIdle($power);
         if ($this->GetValue("CurrentPower") != $power) {
             $this->SetTimerOn();
@@ -110,7 +124,10 @@ class Verbraucher_1_Stufig extends IPSModule {
         $currentStatus = GetValue($this->ReadPropertyInteger("Schaltkontakt1"));
 
         // Schaltkontaktstatus ändern
-        SetValue($this->ReadPropertyInteger("Schaltkontakt1"), $schaltkontaktStatus);
+        SetValue(
+            $this->ReadPropertyInteger("Schaltkontakt1"),
+            $schaltkontaktStatus
+        );
 
         if ($schaltkontaktStatus) {
             $this->SetValue("DailyOnTime", $this->GetValue("DailyOnTime") + 1);
@@ -118,7 +135,8 @@ class Verbraucher_1_Stufig extends IPSModule {
     }
 
     // Methode zum Abrufen der aktuellen Daten
-    public function GetCurrentData(bool $Peak) {
+    public function GetCurrentData(bool $Peak)
+    {
         $IstNacht = $this->GetValue("IstNacht");
         $NeuesIstNacht = $this->ist_nachts();
 
@@ -129,17 +147,27 @@ class Verbraucher_1_Stufig extends IPSModule {
         $this->SetValue("IstNacht", $NeuesIstNacht);
 
         $DailyOnTime = $this->GetValue("DailyOnTime");
-        $Mindestlaufzeit = $this->ReadPropertyInteger("Mindesttlaufzeit") * 60 * 12;
+        $Mindestlaufzeit =
+            $this->ReadPropertyInteger("Mindesttlaufzeit") * 60 * 12;
 
         // Überprüfen, ob der Timer aktiv ist
         if ($this->GetValue("IsTimerActive")) {
             // Timer ist aktiv, PowerSteps setzen
-            $this->SetValue("PowerSteps", json_encode([$this->GetValue("CurrentPower")]));
+            $this->SetValue(
+                "PowerSteps",
+                json_encode([$this->GetValue("CurrentPower")])
+            );
         }
         // Wenn Nacht und Mindestlaufzeit nicht erreicht ist
-        else if($NeuesIstNacht && ($DailyOnTime < $Mindestlaufzeit)) {
+        elseif ($NeuesIstNacht && $DailyOnTime < $Mindestlaufzeit) {
             if ($Peak) {
-                $this->SetValue("PowerSteps", json_encode([0, $this->ReadPropertyInteger("BoilerLeistung")]));
+                $this->SetValue(
+                    "PowerSteps",
+                    json_encode([
+                        0,
+                        $this->ReadPropertyInteger("BoilerLeistung"),
+                    ])
+                );
             } else {
                 $this->SetValue("PowerSteps",json_encode([$this->ReadPropertyInteger("BoilerLeistung")]));
             }
@@ -149,12 +177,14 @@ class Verbraucher_1_Stufig extends IPSModule {
             if ($Peak) {
                 $this->SetValue("PowerSteps", json_encode([0]));
             } else {
-                $this->SetValue("PowerSteps", json_encode([0, $this->ReadPropertyInteger("BoilerLeistung")]));
+                $this->SetValue("PowerSteps",json_encode([0,$this->ReadPropertyInteger("BoilerLeistung"),])
+                );
             }
         }
     }
 
-    public function CheckIdle($power){
+    public function CheckIdle($power)
+    {
         $lastpower = GetValue($this->GetIDForIdent("CurrentPower"));
         if ($lastpower != $power) {
             $this->SetValue("Idle", false);
@@ -170,12 +200,13 @@ class Verbraucher_1_Stufig extends IPSModule {
         }
     }
 
-    private function ist_nachts() {
+    private function ist_nachts()
-        date_default_timezone_set('Europe/Berlin'); // Setze hier deine Zeitzone
+    {
+        date_default_timezone_set("Europe/Berlin"); // Setze hier deine Zeitzone
 
-        $aktuelle_zeit = strtotime(date('H:i')); // Aktuelle Zeit in Stunden und Minuten umwandeln
+        $aktuelle_zeit = strtotime(date("H:i")); // Aktuelle Zeit in Stunden und Minuten umwandeln
-        $start_nacht = strtotime('22:00'); // Startzeit der Nacht (22 Uhr)
+        $start_nacht = strtotime("22:00"); // Startzeit der Nacht (22 Uhr)
-        $ende_nacht = strtotime('07:00'); // Endzeit der Nacht (7 Uhr)
+        $ende_nacht = strtotime("07:00"); // Endzeit der Nacht (7 Uhr)
 
         if ($aktuelle_zeit >= $start_nacht || $aktuelle_zeit < $ende_nacht) {
             return true;

WP_Steuerung/form.json

@@ -0,0 +1,71 @@
+{
+    "elements": [
+        {
+            "type": "Label",
+            "caption": "Einstellungen für Wärmepumpe"
+        },
+
+        {
+            "type": "NumberSpinner",
+            "name": "Wolkenschwellwert",
+            "caption": "Wolkenschwellwert für Sperre",
+            "suffix": ""
+        },        
+        {
+            "type": "SelectVariable",
+            "name": "Wolkenwert",
+            "caption": "Variable mit der Wolkenprognose",
+            "test": true
+        },
+        {
+            "type": "SelectVariable",
+            "name": "Aussentemperatur",
+            "caption": "Variable mit der Aussentemperatur",
+            "test": true
+        },
+        {
+            "type": "NumberSpinner",
+            "name": "WP_Leistung",
+            "caption": "Leistung Wärmepumpe",
+            "suffix": ""
+        },
+        {
+            "type": "SelectVariable",
+            "name": "Referenzzeit",
+            "caption": "Referenzzeit für Sonnenaufgang (von Standort Modul)",
+            "test": true
+        },
+        {
+            "type": "SelectVariable",
+            "name": "Sperrkontakt",
+            "caption": "Zu schaltenden Kontakt für WP-Sperre",
+            "test": true
+        },
+        {
+            "type": "SelectVariable",
+            "name": "Kontakt_Erhoeung",
+            "caption": "Zu schaltenden Kontakt für WP-Erhöhung",
+            "test": true
+        },
+        
+        {
+            "type": "CheckBox",
+            "name": "Schwellwert_Anwenden",
+            "caption": "Schwellwert zum Entsperren Aktiv",
+            "test": true
+        },        
+        {
+            "type": "NumberSpinner",
+            "name": "Schwellwert",
+            "caption": "Warmwassertemperatur auf welche der Schwellwert angewendet wird.",
+            "test": true
+        },  
+        {
+            "type": "SelectVariable",
+            "name": "WW_Temp",
+            "caption": "Variable mit der Aktuellen Warmwassertemperatur",
+            "test": true
+        }
+
+    ]
+}

WP_Steuerung/module.json

@@ -0,0 +1,12 @@
+{
+    "id": "{9DAC29C7-F381-F2A4-7CE2-F391C4FBAF38}",
+    "name": "WP_Steuerung",
+    "type": 3,
+    "vendor": "Belevo AG",
+    "aliases": [],
+    "parentRequirements": [],
+    "childRequirements": [],
+    "implemented": [],
+    "prefix": "GEF",
+    "url": ""
+}

WP_Steuerung/module.php

@@ -0,0 +1,289 @@
+<?php
+class WP_Steuerung extends IPSModule
+{
+    public function Create()
+    {
+        parent::Create();
+
+        // Prioritäten
+        $this->RegisterVariableInteger("LockPrio", "LockPrio");
+        $this->RegisterVariableInteger("UserPrio", "UserPrio");
+
+        // Energiehandling
+        $this->RegisterVariableBoolean("Idle", "Idle", "", true);
+        $this->RegisterVariableInteger("CurrentPower", "CurrentPower", "", 0);
+        $this->RegisterVariableBoolean("Sperrzeit", "Sperrzeit", "", false);
+        $this->RegisterVariableFloat("UsedEnergy", "UsedEnergy", "", 0);
+        $this->RegisterVariableString("PowerSteps", "PowerSteps"); // PowerSteps-Variable registrieren
+
+        // Trägheit
+        $this->RegisterPropertyInteger("IdleCounterMax", 4);
+        $this->RegisterVariableInteger("IdleCounter", "IdleCounter", "", 0);
+        $this->SetValue("IdleCounter", 0);
+
+        $this->RegisterVariableInteger("Mindestlaufzeit", "IdleCounter", "", 0);
+
+        $this->RegisterVariableInteger("Zustand_WP", "Zustand_WP", "", 1);
+
+        $this->RegisterVariableInteger("WP_Laufzeit_Zahler", "WP_Laufzeit_Zahler", "", 20*12);
+        $this->RegisterVariableBoolean("LetzterPeakwert", "LetzterPeakwert", "", false);
+        $this->RegisterVariableBoolean("LetzterPeakwert_Aenderung", "LetzterPeakwert_Aenderung", "", false);
+
+        $this->RegisterPropertyInteger("WP_Leistung", 6000);
+        $this->RegisterPropertyInteger("Wolkenschwellwert", 60);
+        $this->RegisterPropertyInteger("Wolkenwert", 0);
+        $this->RegisterPropertyInteger("Aussentemperatur", 0);
+        $this->RegisterPropertyInteger("Referenzzeit", 0);
+        $this->RegisterPropertyInteger("Sperrkontakt", 0);
+        $this->RegisterPropertyInteger("Kontakt_Erhoeung", 0);
+        $this->RegisterPropertyBoolean("Schwellwert_Anwenden", false);
+        $this->RegisterPropertyInteger("Schwellwert", 0);
+        $this->RegisterPropertyInteger("WW_Temp", 1);
+
+        //Initialisieren
+        $this->SetValue("Idle", true);
+    }
+
+    public function ApplyChanges()
+    {
+        parent::ApplyChanges();
+    }
+
+    // Aktionen verarbeiten
+    public function RequestAction($Ident, $Value)
+    {
+        switch ($Ident) {
+            case "SetCurrentPower":
+                $this->SetCurrentPower($Value);
+                break;
+            case "GetCurrentData":
+                return $this->GetCurrentData($Value);
+                break;
+            case "ResetPowerSteps":
+                $this->ResetPowerSteps($Value);
+                break;
+            default:
+                throw new Exception("Invalid Ident");
+        }
+    }
+
+    // Methode zum Setzen des aktuellen Stromverbrauchs
+    public function SetCurrentPower(float $power)
+    {
+        $sperrzei_abs =
+            ((60 *
+                60 *
+                (GetValue($this->ReadPropertyInteger("Aussentemperatur")) +
+                    10)) /
+                25) *
+            6;
+
+        if ($sperrzei_abs > 6 * 60 * 60) {
+            $sperrzei_abs = 6 * 60 * 60;
+        }
+        if (
+            $this->ReadPropertyInteger("Wolkenschwellwert") <
+                GetValue($this->ReadPropertyInteger("Wolkenwert")) ||
+            $sperrzei_abs < 0
+        ) {
+            $sperrzei_abs = 0;
+        }
+        $sperrzeit = (GetValue($this->ReadPropertyInteger("Referenzzeit")) % 86400) - $sperrzei_abs;
+        $entsperrzeit = GetValue($this->ReadPropertyInteger("Referenzzeit")) % 86400;
+        $aktuellezeit = time() % 86400;
+
+        $this->CheckIdle($power);
+
+        $its_lock_time = $this->GetValue("Sperrzeit");
+        if (
+            $aktuellezeit > $sperrzeit &&
+            $aktuellezeit < $entsperrzeit &&
+            $this->GetValue("WP_Laufzeit_Zahler") > 240
+        ) {
+            $this->SetValue("Sperrzeit", true);
+        } elseif ($this->GetValue("WP_Laufzeit_Zahler") > 240) {
+            $this->SetValue("Sperrzeit", false);
+        }
+
+        $newlocktime = $this->GetValue("Sperrzeit");
+
+        if (
+            $newlocktime == true &&
+            $its_lock_time == false &&
+            $this->GetValue("WP_Laufzeit_Zahler") > 240
+        ) {
+            $this->SetValue("WP_Laufzeit_Zahler", 0);
+            SetValue($this->ReadPropertyInteger("Sperrkontakt"), true);
+        } elseif (
+            $newlocktime == false &&
+            $its_lock_time == true &&
+            $this->GetValue("WP_Laufzeit_Zahler") > 240
+        ) {
+            $this->SetValue("WP_Laufzeit_Zahler", 0);
+            SetValue($this->ReadPropertyInteger("Sperrkontakt"), false);
+        } elseif (
+            $this->GetValue("CurrentPower") != $power ||
+            ($this->GetValue("WP_Laufzeit_Zahler") > 240 &&
+                $this->GetValue("LetzterPeakwert") !=
+                    $this->GetValue("LetzterPeakwert_Aenderung"))
+        ) {
+            $this->SetValue("WP_Laufzeit_Zahler", 0);
+
+            $LastPeak = $this->GetValue("LetzterPeakwert");
+            $this->SetValue("LetzterPeakwert_Aenderung", $LastPeak);
+            $state = $this->GetValue("Zustand_WP");
+
+            if ($state == 0) {
+                $this->SetValue("Zustand_WP", 1);
+                SetValue($this->ReadPropertyInteger("Sperrkontakt"), false);
+                SetValue($this->ReadPropertyInteger("Kontakt_Erhoeung"), false);
+            } elseif ($state == 1) {
+                // Normalbetrieb
+                if (
+                    $LastPeak &&
+                    $power == $this->ReadPropertyInteger("WP_Leistung")
+                ) {
+                    $this->SetValue("Zustand_WP", 1);
+                    $this->SetValue(
+                        "CurrentPower",
+                        $this->ReadPropertyInteger("WP_Leistung")
+                    );
+                } elseif ($LastPeak && $power == 0) {
+                    $this->SetValue("Zustand_WP", 2);
+                    $this->SetValue("CurrentPower", 0);
+                } elseif (
+                    $LastPeak == false &&
+                    $power == $this->ReadPropertyInteger("WP_Leistung")
+                ) {
+                    $this->SetValue("Zustand_WP", 3);
+                    $this->SetValue(
+                        "CurrentPower",
+                        $this->ReadPropertyInteger("WP_Leistung")
+                    );
+                } elseif ($LastPeak == false && $power == 0) {
+                    $this->SetValue("Zustand_WP", 1);
+                    $this->SetValue("CurrentPower", 0);
+                }
+            } elseif ($state == 2) {
+                // Sperre
+                if (
+                    $LastPeak &&
+                    $power == $this->ReadPropertyInteger("WP_Leistung")
+                ) {
+                    $this->SetValue("Zustand_WP", 1);
+                    $this->SetValue(
+                        "CurrentPower",
+                        $this->ReadPropertyInteger("WP_Leistung")
+                    );
+                } elseif ($LastPeak && $power == 0) {
+                    $this->SetValue("Zustand_WP", 2);
+                    $this->SetValue("CurrentPower", 0);
+                } elseif (
+                    $LastPeak == false &&
+                    $power == $this->ReadPropertyInteger("WP_Leistung")
+                ) {
+                    $this->SetValue("Zustand_WP", 3);
+                    $this->SetValue(
+                        "CurrentPower",
+                        $this->ReadPropertyInteger("WP_Leistung")
+                    );
+                } elseif ($LastPeak == false && $power == 0) {
+                    $this->SetValue("Zustand_WP", 1);
+                    $this->SetValue("CurrentPower", 0);
+                }
+            } elseif ($state == 3) {
+                // Erhöht
+                if (
+                    $LastPeak &&
+                    $power == $this->ReadPropertyInteger("WP_Leistung")
+                ) {
+                    $this->SetValue("Zustand_WP", 1);
+                    $this->SetValue(
+                        "CurrentPower",
+                        $this->ReadPropertyInteger("WP_Leistung")
+                    );
+                } elseif ($LastPeak && $power == 0) {
+                    $this->SetValue("Zustand_WP", 2);
+                    $this->SetValue("CurrentPower", 0);
+                } elseif (
+                    $LastPeak == false &&
+                    $power == $this->ReadPropertyInteger("WP_Leistung")
+                ) {
+                    $this->SetValue("Zustand_WP", 3);
+                    $this->SetValue(
+                        "CurrentPower",
+                        $this->ReadPropertyInteger("WP_Leistung")
+                    );
+                } elseif ($LastPeak == false && $power == 0) {
+                    $this->SetValue("Zustand_WP", 1);
+                    $this->SetValue("CurrentPower", 0);
+                }
+            } else {
+                $this->SetValue("Zustand_WP", 1);
+            }
+
+            $newState = $this->GetValue("Zustand_WP");
+
+            if ($newState == 0) {
+                SetValue($this->ReadPropertyInteger("Sperrkontakt"), false);
+                SetValue($this->ReadPropertyInteger("Kontakt_Erhoeung"), false);
+            } elseif ($newState == 1) {
+                SetValue($this->ReadPropertyInteger("Sperrkontakt"), false);
+                SetValue($this->ReadPropertyInteger("Kontakt_Erhoeung"), false);
+            } elseif ($newState == 2) {
+                SetValue($this->ReadPropertyInteger("Sperrkontakt"), true);
+                SetValue($this->ReadPropertyInteger("Kontakt_Erhoeung"), false);
+            } elseif ($newState == 3) {
+                SetValue($this->ReadPropertyInteger("Sperrkontakt"), false);
+                SetValue($this->ReadPropertyInteger("Kontakt_Erhoeung"), true);
+            } else {
+                SetValue($this->ReadPropertyInteger("Sperrkontakt"), false);
+                SetValue($this->ReadPropertyInteger("Kontakt_Erhoeung"), false);
+            }
+        } else {
+            $newCount = $this->GetValue("WP_Laufzeit_Zahler");
+            $this->SetValue("WP_Laufzeit_Zahler", $newCount + 1);
+        }
+    }
+
+    // Methode zum Abrufen der aktuellen Daten
+    public function GetCurrentData(bool $Peak)
+    {
+        // tagessperrzeit berechnen
+
+        $this->SetValue("LetzterPeakwert", $Peak);
+
+        if($this->GetValue("WP_Laufzeit_Zahler")<(20*12)){
+
+            $this->SetValue("PowerSteps", json_encode([$this->GetValue("CurrentPower")]));
+
+        }elseif($this->ReadPropertyBoolean("Schwellwert_Anwenden")==true && ($this->ReadPropertyInteger("Schwellwert")>GetValue($this->ReadPropertyInteger("WW_Temp"))) ){
+            
+            $this->SetValue("PowerSteps", json_encode([$this->ReadPropertyInteger("WP_Leistung")]));
+        }
+        else{
+            $this->SetValue("PowerSteps", json_encode([0, $this->ReadPropertyInteger("WP_Leistung")]));
+        }
+    }
+
+    public function CheckIdle($power)
+    {
+        $lastpower = GetValue($this->GetIDForIdent("CurrentPower"));
+        if ($lastpower != $power) {
+            $this->SetValue("Idle", false);
+            $this->SetValue(
+                "IdleCounter",
+                $this->ReadPropertyInteger("IdleCounterMax")
+            );
+        }
+        // IdleCounter auslesen und verarbeiten
+        $idleCounter = $this->GetValue("IdleCounter");
+        if ($idleCounter > 0) {
+            $this->SetValue("Idle", false);
+            $this->SetValue("IdleCounter", $idleCounter - 1);
+        } else {
+            $this->SetValue("Idle", true);
+        }
+    }
+}
+?>

library.json

@@ -6,7 +6,7 @@
     "compatibility": {
         "version": "7.1"
     },
-    "version": "0.88",
+    "version": "0.156",
     "build": 0,
     "date": 0
 }