433 lines
14 KiB
PHP
433 lines
14 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
require_once __DIR__ . '/libs/VGTRegler.php';
|
|
|
|
use Belevo\EnelixUtils\VGTRegler;
|
|
|
|
class VGTSchnittstelle extends IPSModule
|
|
{
|
|
private const STATUS_AKTIV = 102;
|
|
private const STATUS_KONFIGURATION_UNGUELTIG = 201;
|
|
private const STATUS_AUSGABE_FEHLER = 202;
|
|
|
|
public function Create(): void
|
|
{
|
|
parent::Create();
|
|
|
|
$this->RegisterPropertyInteger(
|
|
'Geraeteart',
|
|
VGTRegler::GERAETEART_PV
|
|
);
|
|
$this->RegisterPropertyString('TopicSuffix', '');
|
|
$this->RegisterPropertyInteger('ReqActionID', 0);
|
|
$this->RegisterPropertyInteger('PowerProductionID', 0);
|
|
$this->RegisterPropertyInteger('SoCID', 0);
|
|
$this->RegisterPropertyFloat('TargetSoC', 50.0);
|
|
$this->RegisterPropertyInteger('ChargePower', 2500);
|
|
$this->RegisterPropertyInteger('DischargePower', 2500);
|
|
$this->RegisterPropertyInteger('MaxPowerSetpoint', 10000);
|
|
$this->RegisterPropertyBoolean('LoggingEin', false);
|
|
|
|
$this->RegisterVariableBoolean('IsReady', 'Is Ready', '', 10);
|
|
$this->RegisterVariableBoolean('IsRunning', 'Is Running', '', 20);
|
|
$this->RegisterVariableFloat('MinSoC', 'Min SoC', '', 30);
|
|
$this->EnableAction('MinSoC');
|
|
$this->RegisterVariableFloat('MaxSoC', 'Max SoC', '', 40);
|
|
$this->EnableAction('MaxSoC');
|
|
$this->RegisterVariableInteger(
|
|
'PowerSetpoint',
|
|
'Power Setpoint',
|
|
'',
|
|
50
|
|
);
|
|
$this->EnableAction('PowerSetpoint');
|
|
$this->RegisterVariableString('Strategy', 'Strategy', '', 60);
|
|
$this->EnableAction('Strategy');
|
|
$this->RegisterVariableString(
|
|
'LastReadResponse',
|
|
'Letzte Lese-Antwort',
|
|
'',
|
|
70
|
|
);
|
|
$this->RegisterVariableString(
|
|
'LastWriteResponse',
|
|
'Letzte Steuer-Antwort',
|
|
'',
|
|
80
|
|
);
|
|
$this->RegisterVariableBoolean('Stoerung', 'Stoerung', '~Switch', 90);
|
|
$this->RegisterVariableString('Stoertext', 'Stoertext', '', 100);
|
|
|
|
$this->RegisterAttributeString('PublishQueue', '[]');
|
|
$this->RegisterAttributeFloat('LetzterZielwert', 0.0);
|
|
$this->RegisterAttributeBoolean('SoCGrenzenInitialisiert', false);
|
|
|
|
$this->ConnectParent('{F7A0DD2E-7684-95C0-64C2-D2A9DC47577B}');
|
|
$this->RegisterTimer(
|
|
'PublishDelay',
|
|
0,
|
|
'ENLVGT_DoDelayedPublish($_IPS["TARGET"]);'
|
|
);
|
|
$this->RegisterTimer(
|
|
'BatteryControlTimer',
|
|
0,
|
|
'ENLVGT_RunControl($_IPS["TARGET"]);'
|
|
);
|
|
}
|
|
|
|
public function ApplyChanges(): void
|
|
{
|
|
parent::ApplyChanges();
|
|
|
|
try {
|
|
if (!$this->ReadAttributeBoolean('SoCGrenzenInitialisiert')) {
|
|
$this->SetValue('MinSoC', 0.0);
|
|
$this->SetValue('MaxSoC', 100.0);
|
|
$this->WriteAttributeBoolean('SoCGrenzenInitialisiert', true);
|
|
}
|
|
$this->pruefeKonfiguration();
|
|
$suffix = $this->ReadPropertyString('TopicSuffix');
|
|
$filter = '.*"Topic":"(feedback-request|remote-control-request)\\/'
|
|
. preg_quote($suffix, '/')
|
|
. '".*';
|
|
$this->SetReceiveDataFilter($filter);
|
|
$this->SetTimerInterval('BatteryControlTimer', 3000);
|
|
$this->SetValue('IsReady', true);
|
|
$this->setzeFehler('');
|
|
$this->SetStatus(self::STATUS_AKTIV);
|
|
$this->RunControl();
|
|
} catch (Throwable $fehler) {
|
|
$this->SetTimerInterval('BatteryControlTimer', 0);
|
|
$this->SetValue('IsReady', false);
|
|
$this->SetValue('IsRunning', false);
|
|
$this->setzeFehler($fehler->getMessage());
|
|
$this->SetStatus(self::STATUS_KONFIGURATION_UNGUELTIG);
|
|
}
|
|
}
|
|
|
|
public function RequestAction($ident, $wert): void
|
|
{
|
|
switch ($ident) {
|
|
case 'PowerSetpoint':
|
|
$begrenzt = VGTRegler::begrenzeSetpoint(
|
|
$this->ReadPropertyInteger('Geraeteart'),
|
|
(float) $wert,
|
|
(float) $this->ReadPropertyInteger('MaxPowerSetpoint')
|
|
);
|
|
$this->SetValue('PowerSetpoint', (int) round($begrenzt));
|
|
$this->RunControl();
|
|
return;
|
|
|
|
case 'Strategy':
|
|
$this->SetValue('Strategy', trim((string) $wert));
|
|
$this->RunControl();
|
|
return;
|
|
|
|
case 'MinSoC':
|
|
$this->SetValue(
|
|
'MinSoC',
|
|
min(100.0, max(0.0, (float) $wert))
|
|
);
|
|
$this->RunControl();
|
|
return;
|
|
|
|
case 'MaxSoC':
|
|
$this->SetValue(
|
|
'MaxSoC',
|
|
min(100.0, max(0.0, (float) $wert))
|
|
);
|
|
$this->RunControl();
|
|
return;
|
|
}
|
|
|
|
throw new InvalidArgumentException('Unbekannte Aktion: ' . $ident);
|
|
}
|
|
|
|
public function RunControl(): void
|
|
{
|
|
try {
|
|
$this->pruefeKonfiguration();
|
|
$geraeteart = $this->ReadPropertyInteger('Geraeteart');
|
|
$strategie = (string) $this->GetValue('Strategy');
|
|
if ($geraeteart === VGTRegler::GERAETEART_PV
|
|
&& !in_array($strategie, ['activate', 'stop'], true)
|
|
) {
|
|
$this->SetValue('IsReady', true);
|
|
$this->SetValue('IsRunning', false);
|
|
$this->setzeFehler('');
|
|
$this->SetStatus(self::STATUS_AKTIV);
|
|
return;
|
|
}
|
|
|
|
$ladezustand = $geraeteart === VGTRegler::GERAETEART_BATTERIE
|
|
? $this->leseNumerisch($this->ReadPropertyInteger('SoCID'))
|
|
: 0.0;
|
|
$zielwert = VGTRegler::zielwert(
|
|
$geraeteart,
|
|
$strategie,
|
|
(float) $this->GetValue('PowerSetpoint'),
|
|
(float) $this->ReadPropertyInteger('MaxPowerSetpoint'),
|
|
$ladezustand,
|
|
$this->ReadPropertyFloat('TargetSoC'),
|
|
(float) $this->ReadPropertyInteger('ChargePower'),
|
|
(float) $this->ReadPropertyInteger('DischargePower'),
|
|
(float) $this->GetValue('MinSoC'),
|
|
(float) $this->GetValue('MaxSoC')
|
|
);
|
|
|
|
RequestAction(
|
|
$this->ReadPropertyInteger('ReqActionID'),
|
|
$zielwert
|
|
);
|
|
$this->WriteAttributeFloat('LetzterZielwert', $zielwert);
|
|
$this->SetValue('IsReady', true);
|
|
$this->SetValue('IsRunning', abs($zielwert) >= 0.5);
|
|
$this->setzeFehler('');
|
|
$this->SetStatus(self::STATUS_AKTIV);
|
|
$this->protokolliere('Zielwert', $zielwert);
|
|
} catch (Throwable $fehler) {
|
|
$this->SetValue('IsRunning', false);
|
|
$this->setzeFehler($fehler->getMessage());
|
|
$this->SetStatus(self::STATUS_AUSGABE_FEHLER);
|
|
$this->protokolliere('Steuerfehler', $fehler->getMessage());
|
|
}
|
|
}
|
|
|
|
public function BuildReadResponse(): string
|
|
{
|
|
$data = [
|
|
'power_production' => $this->leseOptionalNumerisch(
|
|
$this->ReadPropertyInteger('PowerProductionID')
|
|
),
|
|
'is_ready' => (bool) $this->GetValue('IsReady'),
|
|
'is_running' => (bool) $this->GetValue('IsRunning'),
|
|
];
|
|
|
|
if ($this->ReadPropertyInteger('Geraeteart')
|
|
=== VGTRegler::GERAETEART_BATTERIE
|
|
) {
|
|
$data['state_of_charge'] = $this->leseOptionalNumerisch(
|
|
$this->ReadPropertyInteger('SoCID')
|
|
);
|
|
$data['min_soc'] = (float) $this->GetValue('MinSoC');
|
|
$data['max_soc'] = (float) $this->GetValue('MaxSoC');
|
|
}
|
|
|
|
$json = json_encode($data, JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR);
|
|
$this->SetValue('LastReadResponse', $json);
|
|
|
|
return $json;
|
|
}
|
|
|
|
public function HandleRemoteControlJSON(string $payload): ?string
|
|
{
|
|
if ($payload === '') {
|
|
return null;
|
|
}
|
|
|
|
$data = json_decode($payload, true);
|
|
if (!is_array($data)) {
|
|
return null;
|
|
}
|
|
|
|
if (array_key_exists('power_setpoint', $data)) {
|
|
$wert = VGTRegler::begrenzeSetpoint(
|
|
$this->ReadPropertyInteger('Geraeteart'),
|
|
(float) $data['power_setpoint'],
|
|
(float) $this->ReadPropertyInteger('MaxPowerSetpoint')
|
|
);
|
|
$this->SetValue('PowerSetpoint', (int) round($wert));
|
|
}
|
|
if (array_key_exists('strategy', $data)) {
|
|
$this->SetValue('Strategy', (string) $data['strategy']);
|
|
}
|
|
|
|
$this->RunControl();
|
|
|
|
$antwort = [
|
|
'power_setpoint' => (int) $this->GetValue('PowerSetpoint'),
|
|
'strategy' => (string) $this->GetValue('Strategy'),
|
|
];
|
|
$json = json_encode(
|
|
$antwort,
|
|
JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR
|
|
);
|
|
$this->SetValue('LastWriteResponse', $json);
|
|
|
|
return $json;
|
|
}
|
|
|
|
public function ReceiveData($jsonString): void
|
|
{
|
|
$data = json_decode((string) $jsonString, true);
|
|
if (!is_array($data)
|
|
|| (int) ($data['PacketType'] ?? 0) !== 3
|
|
|| !isset($data['Topic'])
|
|
) {
|
|
return;
|
|
}
|
|
|
|
$topic = (string) $data['Topic'];
|
|
$payload = (string) ($data['Payload'] ?? '');
|
|
$suffix = $this->ReadPropertyString('TopicSuffix');
|
|
$this->protokolliere('ReceiveData', $jsonString);
|
|
|
|
if ($topic === 'feedback-request/' . $suffix) {
|
|
$this->QueuePublish(
|
|
'feedback-response/' . $suffix,
|
|
$this->BuildReadResponse()
|
|
);
|
|
return;
|
|
}
|
|
|
|
if ($topic === 'remote-control-request/' . $suffix) {
|
|
$antwort = $this->HandleRemoteControlJSON($payload);
|
|
if ($antwort !== null) {
|
|
$this->QueuePublish(
|
|
'remote-control-response/' . $suffix,
|
|
$antwort
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
public function QueuePublish(string $topic, string $payload): void
|
|
{
|
|
$queue = json_decode(
|
|
$this->ReadAttributeString('PublishQueue'),
|
|
true
|
|
);
|
|
if (!is_array($queue)) {
|
|
$queue = [];
|
|
}
|
|
$queue[] = ['Topic' => $topic, 'Payload' => $payload];
|
|
if (count($queue) > 100) {
|
|
array_shift($queue);
|
|
}
|
|
$this->WriteAttributeString(
|
|
'PublishQueue',
|
|
json_encode($queue, JSON_THROW_ON_ERROR)
|
|
);
|
|
$this->SetTimerInterval('PublishDelay', 50);
|
|
}
|
|
|
|
public function DoDelayedPublish(): void
|
|
{
|
|
$queue = json_decode(
|
|
$this->ReadAttributeString('PublishQueue'),
|
|
true
|
|
);
|
|
if (!is_array($queue) || $queue === []) {
|
|
$this->SetTimerInterval('PublishDelay', 0);
|
|
return;
|
|
}
|
|
|
|
$eintrag = array_shift($queue);
|
|
$this->WriteAttributeString(
|
|
'PublishQueue',
|
|
json_encode($queue, JSON_THROW_ON_ERROR)
|
|
);
|
|
$this->SendDataToParent(json_encode([
|
|
'DataID' => '{043EA491-0325-4ADD-8FC2-A30C8EEB4D3F}',
|
|
'PacketType' => 3,
|
|
'QualityOfService' => 0,
|
|
'Retain' => false,
|
|
'Topic' => (string) $eintrag['Topic'],
|
|
'Payload' => (string) $eintrag['Payload'],
|
|
], JSON_THROW_ON_ERROR));
|
|
|
|
$this->SetTimerInterval('PublishDelay', $queue === [] ? 0 : 50);
|
|
}
|
|
|
|
private function pruefeKonfiguration(): void
|
|
{
|
|
VGTRegler::begrenzeSetpoint(
|
|
$this->ReadPropertyInteger('Geraeteart'),
|
|
0.0,
|
|
(float) $this->ReadPropertyInteger('MaxPowerSetpoint')
|
|
);
|
|
if (trim($this->ReadPropertyString('TopicSuffix')) === '') {
|
|
throw new InvalidArgumentException(
|
|
'TopicSuffix ist nicht eingerichtet.'
|
|
);
|
|
}
|
|
$this->pruefeAktionsvariable(
|
|
$this->ReadPropertyInteger('ReqActionID'),
|
|
'ReqActionID'
|
|
);
|
|
if ($this->ReadPropertyInteger('Geraeteart')
|
|
=== VGTRegler::GERAETEART_BATTERIE
|
|
) {
|
|
$this->pruefeNumerischeVariable(
|
|
$this->ReadPropertyInteger('SoCID'),
|
|
'SoCID'
|
|
);
|
|
}
|
|
}
|
|
|
|
private function pruefeAktionsvariable(int $id, string $name): void
|
|
{
|
|
$this->pruefeNumerischeVariable($id, $name);
|
|
$variable = IPS_GetVariable($id);
|
|
if ((int) ($variable['VariableAction'] ?? 0) <= 0
|
|
&& (int) ($variable['VariableCustomAction'] ?? 0) <= 0
|
|
) {
|
|
throw new InvalidArgumentException(
|
|
$name . ' benoetigt eine Variablenaktion.'
|
|
);
|
|
}
|
|
}
|
|
|
|
private function pruefeNumerischeVariable(int $id, string $name): void
|
|
{
|
|
if ($id <= 0 || !IPS_VariableExists($id)) {
|
|
throw new InvalidArgumentException($name . ' ist nicht eingerichtet.');
|
|
}
|
|
$variable = IPS_GetVariable($id);
|
|
if (!in_array((int) $variable['VariableType'], [1, 2], true)) {
|
|
throw new InvalidArgumentException(
|
|
$name . ' muss numerisch sein.'
|
|
);
|
|
}
|
|
}
|
|
|
|
private function leseNumerisch(int $id): float
|
|
{
|
|
$this->pruefeNumerischeVariable($id, 'Messvariable');
|
|
return (float) GetValue($id);
|
|
}
|
|
|
|
private function leseOptionalNumerisch(int $id): float
|
|
{
|
|
if ($id <= 0 || !IPS_VariableExists($id)) {
|
|
return 0.0;
|
|
}
|
|
$variable = IPS_GetVariable($id);
|
|
if (!in_array((int) $variable['VariableType'], [1, 2], true)) {
|
|
return 0.0;
|
|
}
|
|
|
|
return (float) GetValue($id);
|
|
}
|
|
|
|
private function setzeFehler(string $text): void
|
|
{
|
|
$this->SetValue('Stoerung', $text !== '');
|
|
$this->SetValue('Stoertext', $text);
|
|
}
|
|
|
|
/** @param mixed $daten */
|
|
private function protokolliere(string $titel, $daten): void
|
|
{
|
|
if (!$this->ReadPropertyBoolean('LoggingEin')) {
|
|
return;
|
|
}
|
|
$text = is_string($daten)
|
|
? $daten
|
|
: json_encode($daten, JSON_THROW_ON_ERROR);
|
|
$this->SendDebug($titel, $text, 0);
|
|
}
|
|
}
|