ENELIX/Enelix-EMS
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(manager): Regelung und Energiefluss korrigieren
Tests / test (push) Successful in 48s
Details

Browse Source
This commit is contained in:
dh
2026-09-29 16:17:49 +00:00
parent cae14cf399
commit 393969594e
7 changed files with 345 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libs/ManagerEnergieTrait.php
+210 -9
View File
@@ -256,12 +256,73 @@ trait ManagerEnergieTrait
IPS_SetName($instanzID, 'Energiefluss');
IPS_SetPosition($instanzID, 540);
IPS_SetHidden($instanzID, false);
$profil = $this->energieflussLeistungsprofil();
$pvID = $this->energieflussLeistungsvariable(
'EnergieflussPV',
'Energiefluss PV',
$profil,
600
);
$netzID = $this->energieflussLeistungsvariable(
'EnergieflussNetz',
'Energiefluss Netz',
$profil,
610
);
$hausID = $this->energieflussLeistungsvariable(
'EnergieflussHaus',
'Energiefluss Hausverbrauch',
$profil,
620
);
$batterieID = $this->energieflussLeistungsvariable(
'EnergieflussBatterie',
'Energiefluss Batteriespeicher',
$profil,
630
);
$verbraucher = $this->energieflussVerbraucher();
$knoten = [
$this->energieflussKnoten('PVLeistungArchiv', 'PV-Anlage', 'solar'),
$this->energieflussKnoten('NetzleistungArchiv', 'Stromnetz', 'grid'),
$this->energieflussKnoten('HausverbrauchLeistungArchiv', 'Hausverbrauch', 'consumer'),
$this->energieflussKnoten('BatterieleistungArchiv', 'Batteriespeicher', 'battery'),
$this->energieflussKnoten($pvID, 'PV-Anlage', 'solar'),
$this->energieflussKnoten($netzID, 'Stromnetz', 'grid'),
$this->energieflussKnoten($hausID, 'Hausverbrauch', 'consumer'),
];
$hatBatterieverbraucher = false;
$position = 640;
foreach ($verbraucher as $eintrag) {
$istID = $this->energieflussLeistungsvariable(
'EnergieflussIst_' . $eintrag['InstanzID'],
$eintrag['Name'] . ' Istleistung',
$profil,
$position
);
$sollID = $this->energieflussLeistungsvariable(
'EnergieflussSoll_' . $eintrag['InstanzID'],
$eintrag['Name'] . ' Sollleistung',
$profil,
$position + 1
);
$knoten[] = $this->energieflussKnoten(
$istID,
$eintrag['Name'],
$eintrag['Typ'],
true,
$sollID
);
$hatBatterieverbraucher = $hatBatterieverbraucher
|| $eintrag['Typ'] === 'storage';
$position += 10;
}
if (!$hatBatterieverbraucher) {
$knoten[] = $this->energieflussKnoten(
$batterieID,
'Batteriespeicher',
'storage'
);
}
IPS_SetProperty($instanzID, 'Calculation', true);
IPS_SetProperty(
$instanzID,
@@ -271,26 +332,166 @@ trait ManagerEnergieTrait
IPS_SetProperty($instanzID, 'EnableLimits', false);
IPS_SetProperty($instanzID, 'Restrictions', '[]');
IPS_ApplyChanges($instanzID);
$this->aktualisiereEnergieflusswerte($verbraucher);
return 'Der Energiefluss wurde erstellt oder aktualisiert.';
}
/** @return array<string, mixed> */
private function energieflussKnoten(string $ident, string $name, string $typ): array
{
private function energieflussKnoten(
int $variableID,
string $name,
string $typ,
bool $gruppiert = false,
int $infoVariableID = 1
): array {
return [
'VariableConfigType' => 0,
'VariableID' => $this->GetIDForIdent($ident),
'VariableID' => $variableID,
'SecondaryVariableID' => 1,
'Name' => $name,
'Type' => $typ,
'Grouped' => false,
'Grouped' => $gruppiert,
'CalculationType' => 0,
'InfoVariableID' => 1,
'InfoVariableID' => $infoVariableID,
'Invert' => false,
];
}
private function energieflussLeistungsprofil(): string
{
if ($this->ReadPropertyInteger('EnergieflussLeistungseinheit') !== 1) {
return '~Power';
}
$profil = 'Enelix.Power.kW';
if (!IPS_VariableProfileExists($profil)) {
IPS_CreateVariableProfile($profil, 2);
IPS_SetVariableProfileValues($profil, -1000000.0, 1000000.0, 0.001);
IPS_SetVariableProfileDigits($profil, 3);
IPS_SetVariableProfileText($profil, '', ' kW');
}
return $profil;
}
private function energieflussLeistungsvariable(
string $ident,
string $name,
string $profil,
int $position
): int {
$this->RegisterVariableFloat($ident, $name, $profil, $position);
$variableID = $this->GetIDForIdent($ident);
IPS_SetHidden($variableID, true);
return $variableID;
}
/**
* @return list<array{
* InstanzID: int,
* Name: string,
* Typ: string,
* Istleistung_W: float,
* Sollleistung_W: float
* }>
*/
private function energieflussVerbraucher(): array
{
$cache = $this->leseJsonAttribut('VerbraucherCache');
$ergebnis = [];
foreach ($this->konfigurierteAktiveVerbraucherIDs() as $instanzID) {
if (!IPS_InstanceExists($instanzID)) {
continue;
}
$daten = $cache[(string) $instanzID]['Daten'] ?? null;
$istleistung = 0.0;
$sollleistung = 0.0;
if (is_array($daten)) {
$istleistung = $this->verbraucherleistung($daten);
$sollleistung = (float) (ManagerRegler::angenommenerSollwert($daten) ?? 0);
}
$modulID = strtoupper(
(string) IPS_GetInstance($instanzID)['ModuleInfo']['ModuleID']
);
$katalog = self::VERBRAUCHER_LIZENZEN[$modulID]['Katalog'] ?? '';
$ergebnis[] = [
'InstanzID' => $instanzID,
'Name' => IPS_GetName($instanzID),
'Typ' => match ($katalog) {
'battery' => 'storage',
'ev_charger' => 'wallbox',
default => 'consumer',
},
'Istleistung_W' => $istleistung,
'Sollleistung_W' => $sollleistung,
];
}
return $ergebnis;
}
/**
* @param list<array<string, mixed>>|null $verbraucher
*/
private function aktualisiereEnergieflusswerte(?array $verbraucher = null): void
{
if (!$this->ReadPropertyBoolean('EnergieflussAnzeigen')) {
return;
}
$verbraucher = $verbraucher ?? $this->energieflussVerbraucher();
$verbraucherleistung = 0.0;
$hatBatterieverbraucher = false;
foreach ($verbraucher as $eintrag) {
$this->setzeEnergieflussLeistungswert(
'EnergieflussIst_' . $eintrag['InstanzID'],
(float) $eintrag['Istleistung_W']
);
$this->setzeEnergieflussLeistungswert(
'EnergieflussSoll_' . $eintrag['InstanzID'],
(float) $eintrag['Sollleistung_W']
);
if ($eintrag['Typ'] === 'storage') {
$hatBatterieverbraucher = true;
} else {
$verbraucherleistung += max(0.0, (float) $eintrag['Istleistung_W']);
}
}
try {
$leistungen = $this->leseMessleistungen();
} catch (Throwable $fehler) {
$this->protokolliere('Energiefluss', $fehler->getMessage());
return;
}
$this->setzeEnergieflussLeistungswert('EnergieflussPV', $leistungen['PV']);
$this->setzeEnergieflussLeistungswert('EnergieflussNetz', $leistungen['Netz']);
$this->setzeEnergieflussLeistungswert(
'EnergieflussHaus',
max(0.0, $leistungen['Haus'] - $verbraucherleistung)
);
if (!$hatBatterieverbraucher) {
$this->setzeEnergieflussLeistungswert(
'EnergieflussBatterie',
$leistungen['Batterie']
);
}
}
private function setzeEnergieflussLeistungswert(string $ident, float $watt): void
{
$variableID = @IPS_GetObjectIDByIdent($ident, $this->InstanceID);
if (!is_int($variableID) || $variableID <= 0 || !IPS_VariableExists($variableID)) {
return;
}
$faktor = $this->ReadPropertyInteger('EnergieflussLeistungseinheit') === 1
? 0.001
: 1.0;
SetValue($variableID, $watt * $faktor);
}
private function erstelleEnergiediagramme(): string
{
$leistung = [
libs/ManagerRegler.php
+32 -14
View File
@@ -128,7 +128,8 @@ final class ManagerRegler
}
$festwert = self::istFestwert($daten['Leistungswerte_W']);
if ($festwert) {
$festgehalten = !$daten['AenderungMoeglich'];
if ($festwert || $festgehalten) {
$nichtSteuerbar += $leistung;
}
@@ -144,6 +145,8 @@ final class ManagerRegler
'Energiegruppe' => (int) round((float) $energie / 2000.0),
'Leistungswerte_W' => $daten['Leistungswerte_W'],
'Festwert' => $festwert,
'Festgehalten' => $festgehalten,
'Sollwert' => self::angenommenerSollwert($daten),
];
}
@@ -160,6 +163,7 @@ final class ManagerRegler
});
$verteilbudget = (int) round($aktuelleLeistung + $zielnetzleistung - $netzleistung);
$positiveRichtung = $verteilbudget - $nichtSteuerbar >= 0;
$sollwerte = [];
$ausgangssumme = 0;
foreach ($steuerbar as $eintrag) {
@@ -169,26 +173,41 @@ final class ManagerRegler
);
continue;
}
if ($eintrag['Festgehalten']) {
if ($eintrag['Sollwert'] !== null) {
$sollwerte[$eintrag['InstanzID']] = $eintrag['Sollwert'];
}
continue;
}
$ausgangswert = self::neutralerLeistungswert($eintrag['Leistungswerte_W']);
$ausgangswert = self::richtungsneutralerLeistungswert(
$eintrag['Leistungswerte_W'],
$positiveRichtung
);
$sollwerte[$eintrag['InstanzID']] = $ausgangswert;
$ausgangssumme += $ausgangswert;
}
$rest = $verteilbudget - $nichtSteuerbar - $ausgangssumme;
foreach ($steuerbar as $eintrag) {
if ($eintrag['Festwert']) {
if ($eintrag['Festwert'] || $eintrag['Festgehalten']) {
continue;
}
$instanzID = $eintrag['InstanzID'];
$ausgangswert = $sollwerte[$instanzID];
if ($rest >= 0) {
if ($positiveRichtung) {
if ($rest <= 0) {
continue;
}
$neuerSollwert = self::groessterLeistungswertBis(
$eintrag['Leistungswerte_W'],
$ausgangswert + $rest
);
} else {
if ($rest >= 0) {
continue;
}
$neuerSollwert = self::kleinsterLeistungswertAb(
$eintrag['Leistungswerte_W'],
$ausgangswert + $rest
@@ -200,7 +219,7 @@ final class ManagerRegler
$zugeteilt = $nichtSteuerbar;
foreach ($steuerbar as $eintrag) {
if (!$eintrag['Festwert']) {
if (!$eintrag['Festwert'] && !$eintrag['Festgehalten']) {
$zugeteilt += $sollwerte[$eintrag['InstanzID']];
}
}
@@ -274,8 +293,10 @@ final class ManagerRegler
/**
* @param list<int|array{Von_W: int, Bis_W: int}> $leistungswerte
*/
private static function neutralerLeistungswert(array $leistungswerte): int
{
private static function richtungsneutralerLeistungswert(
array $leistungswerte,
bool $positiveRichtung
): int {
$negativ = null;
$positiv = null;
foreach ($leistungswerte as $eintrag) {
@@ -298,14 +319,11 @@ final class ManagerRegler
: $positiv;
}
if ($negativ === null) {
return $positiv;
}
if ($positiv === null) {
return $negativ;
if ($positiveRichtung) {
return $positiv ?? $negativ;
}
return abs($negativ) <= abs($positiv) ? $negativ : $positiv;
return $negativ ?? $positiv;
}
/**
@@ -361,6 +379,6 @@ final class ManagerRegler
return max($eintrag['Von_W'], $untergrenze);
}
return self::neutralerLeistungswert($leistungswerte);
return self::richtungsneutralerLeistungswert($leistungswerte, false);
}
}