no message

Batterie/module.php

@@ -99,44 +99,72 @@ class Batterie extends IPSModule
 
 private function GeneratePowerSteps($additionalValue)
 {
-        $maxleistung = GetValue($this->ReadPropertyInteger("MaxBatterieleistung"));
-        $stepSize = 250;       // Schrittgröße
-        $stepSizeSmall = 50;   // Kleine Schrittgröße
+    $maxleistung_raw = GetValue($this->ReadPropertyInteger("MaxBatterieleistung"));
+    $nachladen_raw   = GetValue($this->ReadPropertyInteger("MaxNachladen"));
 
-        // Array direkt als Range erzeugen (schneller als Schleife)
-        $array_powersteps = range(-$maxleistung, $maxleistung, $stepSize);
+    $stepSize = 250;       // Grobe Schrittgröße
+    $stepSizeSmall = 50;   // Feine Schrittgröße
 
-        // Nächstgelegenen Wert direkt bestimmen (rundet auf den nächsten Step)
-        $closestValue = round($additionalValue / $stepSize) * $stepSize;
+    // 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
+    $array_powersteps = range($minleistung, $maxleistung, $stepSize);
+
+    // Zusätzlichen Wert auf 50er abrunden (floor, nicht round!)
+    // (wichtig: floor bei negativen Zahlen geht "weiter runter", daher extra Logik)
+    $closestValue = (int)(floor($additionalValue / $stepSizeSmall) * $stepSizeSmall);
+
+    // Clamp in den Bereich
+    if ($closestValue < $minleistung) $closestValue = $minleistung;
+    if ($closestValue > $maxleistung) $closestValue = $maxleistung;
+
+    // Prüfen ob der Wert im Array existiert (bei 250er Raster oft NICHT)
+    $index = array_search($closestValue, $array_powersteps, true);
+
+    // Wenn nicht vorhanden: an der richtigen Stelle einsortieren
+    if ($index === false) {
+        $index = 0;
+        $count = count($array_powersteps);
+        while ($index < $count && $array_powersteps[$index] < $closestValue) {
+            $index++;
+        }
+        // $index ist jetzt Einfügeposition
+    }
+
+    // Feine Werte um closestValue herum (±4 * 50)
+    $newValues = [];
+    for ($i = -4; $i <= 4; $i++) {
+        $v = $closestValue + ($i * $stepSizeSmall);
+        if ($v >= $minleistung && $v <= $maxleistung) {
+            $newValues[] = $v;
+        }
+    }
+
+    // Duplikate vermeiden (falls schon Werte vorhanden sind)
+    $newValues = array_values(array_unique($newValues));
+
+    // Wenn closestValue exakt im Grundarray war: diesen einen ersetzen
+    // sonst: feinwerte einfach an der Einfügestelle einfügen
+    if (array_search($closestValue, $array_powersteps, true) !== false) {
+        $existingIndex = array_search($closestValue, $array_powersteps, true);
+        array_splice($array_powersteps, $existingIndex, 1, $newValues);
+    } else {
+        array_splice($array_powersteps, $index, 0, $newValues);
+    }
+
+    // Am Ende sortieren + Duplikate killen (sicher ist sicher)
+    $array_powersteps = array_values(array_unique($array_powersteps));
+    sort($array_powersteps, SORT_NUMERIC);
 
-        // Falls der Wert nicht im Bereich liegt, abbrechen
-        if (!in_array($closestValue, $array_powersteps)) {
     return $array_powersteps;
 }
 
-        // Index des gefundenen Werts suchen
-        $index = array_search($closestValue, $array_powersteps);
-    
-        // Zusätzliche Werte berechnen und auf MaxLeistung begrenzen
-        $newValues = array_filter([
-            $closestValue - 4 * $stepSizeSmall,
-            $closestValue - 3 * $stepSizeSmall,
-            $closestValue - 2 * $stepSizeSmall,
-            $closestValue - $stepSizeSmall,
-            $closestValue,
-            $closestValue + $stepSizeSmall,
-            $closestValue + 2 * $stepSizeSmall,
-            $closestValue + 3 * $stepSizeSmall,
-            $closestValue + 4 * $stepSizeSmall,
-        ], function ($value) use ($maxleistung) {
-            return $value >= -$maxleistung && $value <= $maxleistung;
-        });
-    
-        // Effizienteres Einfügen der Werte (direkt an der Stelle)
-        array_splice($array_powersteps, $index, 1, $newValues);
-    
-        return $array_powersteps;
-    }