chore(release): erste Beta vorbereiten

.gitea/workflows/ci.yml

@@ -21,6 +21,14 @@ jobs:
       - name: Abhaengigkeiten installieren
         run: composer install --no-interaction --no-progress --prefer-dist
 
-      - name: Pruefungen ausfuehren
+      - name: Composer-Metadaten pruefen
+        run: composer validate --strict
+
+      - name: Abhaengigkeiten auf Sicherheitsmeldungen pruefen
+        run: |
+          composer audit --no-interaction
+          composer audit --working-dir=Verbrauchskostenreport/libs --locked --no-interaction
+
+      - name: Unit-Tests und Syntaxpruefung ausfuehren
         run: composer check
 

.gitignore

@@ -1,3 +1,4 @@
 /vendor/
 /.phpunit.cache/
 /.phpunit.result.cache
+/build/

CC100Hardware/README.md

@@ -0,0 +1,136 @@
+# CC100 Hardware
+
+> Status: Implementiert fuer den WAGO Compact Controller 100, Artikel 751-9301,
+> mit IP-Symcon ab Version 8.0.
+
+Das Modul bindet die komplette Onboard-I/O des CC100 direkt ueber die von WAGO
+dokumentierten Linux-Schnittstellen an:
+
+- 8 digitale Eingaenge (DI)
+- 4 digitale Ausgaenge (DO)
+- 2 analoge Eingaenge 0 bis 10 V (AI)
+- 2 analoge Ausgaenge 0 bis 10 V (AO)
+- 2 PT1000-Temperatureingaenge (PT)
+
+## Kanalauswahl
+
+Die Property 'Kanalauswahl' enthaelt alle 18 Kanaele. Pro Zeile werden
+Aktivierung, Typ, Kanalnummer, Anzeigename und Abfrageintervall festgelegt.
+Nur aktive Kanaele werden als IP-Symcon-Variablen angelegt. Wird ein Kanal
+deaktiviert, entfernt das Modul seine dynamische Variable beim naechsten
+Uebernehmen der Konfiguration.
+
+DO- und AO-Variablen sind bedienbar. DI, AI und PT sind reine Messwerte.
+AI und AO werden in Volt dargestellt, PT in Grad Celsius.
+
+## Properties
+
+| Property | Standard | Bedeutung |
+| --- | --- | --- |
+| 'Kanalauswahl' | alle Kanaele inaktiv | Sichtbare und abgefragte Kanaele |
+| 'DigitalInputPath' | WAGO-DI-Sammelpfad | 8-Bit-Eingangswert, LSB ist DI1 |
+| 'DigitalOutputPath' | '/sys/kernel/dout_drv/DOUT_DATA' | 4-Bit-Ausgangswert, LSB ist DO1 |
+| 'CalibrationPath' | '/etc/calib' | WAGO-Zweipunktkalibrierung |
+| 'AI1Path', 'AI2Path' | WAGO-IIO-Pfade | Analoge Eingangswerte |
+| 'AO1ValuePath', 'AO2ValuePath' | WAGO-IIO-Pfade | Analoge Ausgangswerte |
+| 'AO1PowerPath', 'AO2PowerPath' | WAGO-IIO-Pfade | Freigabe der analogen Ausgaenge |
+| 'PT1Path', 'PT2Path' | WAGO-IIO-Pfade | PT1000-Rohwerte |
+| 'Debug' | 'false' | Zusaetzliche Diagnose im Debug-Log |
+
+Die Hardwarepfade sind im Konfigurationsformular unter **Erweiterte
+Hardwarepfade** sichtbar. Dadurch koennen Firmwarevarianten angepasst werden,
+ohne den Modulcode zu aendern.
+
+## Aktualisierung
+
+Die CC100-Treiber stellen die Onboard-I/O als lesbare beziehungsweise
+schreibbare Systemdateien bereit. Fuer diese Dateien ist von WAGO kein
+zuverlaessiger Aenderungs-Eventkanal dokumentiert. Das Modul verwendet deshalb
+einen gemeinsamen Timer:
+
+1. Das kleinste aktive Kanalintervall bestimmt den Timer.
+2. Pro Lauf werden nur faellige Kanaele verarbeitet.
+3. DI beziehungsweise DO werden je Lauf nur einmal als Sammelwert gelesen.
+4. IP-Symcon-Werte werden nur bei einer echten Wertaenderung geschrieben.
+
+Das Intervall kann pro Kanal zwischen 100 ms und 3 600 000 ms eingestellt
+werden. Kurze Intervalle erhoehen CPU- und I/O-Last.
+
+## Kalibrierung
+
+AI, AO und PT verwenden die individuellen Zweipunktwerte aus '/etc/calib'.
+Das Modul akzeptiert die WAGO-Bezeichnungen 'AO1'/'AO2' sowie die in der
+WAGO-Beispieldatei vorkommenden Schreibweisen 'A01'/'A02'.
+
+- AI-Rohwerte werden kalibriert und von mV nach V umgerechnet.
+- AO-Sollwerte werden von V nach mV und danach invers in den Rohwert umgerechnet.
+- PT-Rohwerte werden zuerst in Ohm und anschliessend mit der
+  Callendar-Van-Dusen-Kennlinie in Grad Celsius umgerechnet.
+
+## Ausgangssicherheit
+
+'ApplyChanges()' schreibt keine Ausgaenge. Beim Start werden DO und AO nur
+eingelesen. Ein DO-Schaltbefehl liest zuerst den gesamten Ausgangswert, aendert
+genau das gewaehlte Bit und erhaelt die anderen Ausgaenge. AO akzeptiert nur
+Werte von 0 bis 10 V und schreibt zuerst die WAGO-Freigabe, danach den
+kalibrierten Rohwert.
+
+Die rekursive Schreibschleife des Enelix-1-Moduls wurde verworfen. Ein
+fehlgeschlagener Schreibzugriff blockiert IP-Symcon nicht bis zu fuenf Sekunden,
+sondern liefert sofort Status '203' und einen Stoertext.
+
+## Variablen
+
+| Ident | Typ | Zugriff |
+| --- | --- | --- |
+| 'DI1' bis 'DI8' | Boolean | Anzeige, nur wenn aktiviert |
+| 'DO1' bis 'DO4' | Boolean | Bedienbar, nur wenn aktiviert |
+| 'AI1', 'AI2' | Float / V | Anzeige, nur wenn aktiviert |
+| 'AO1', 'AO2' | Float / V | Bedienbar, nur wenn aktiviert |
+| 'PT1', 'PT2' | Float / Grad Celsius | Anzeige, nur wenn aktiviert |
+| 'Hardwarestatus' | Integer | '0' unkonfiguriert, '1' bereit, '2' Lesefehler, '3' Fehler |
+| 'Stoertext' | String | Letzter zusammengefasster Fehler |
+
+## Migration aus Enelix 1
+
+### Unveraendert uebernommen
+
+- vier DO, acht DI und zwei PT-Kanaele
+- Bitreihenfolge mit DI1 beziehungsweise DO1 als LSB
+- die vorhandenen WAGO-Systempfade als Standardwerte
+
+### Angepasst
+
+- getrennte feste Timer durch einen gruppierten, kanalspezifischen Poller ersetzt
+- DO-Aktionen lesen den Sammelwert und aendern nur das gewaehlte Bit
+- PT-Auswertung verwendet die individuelle Kalibrierung und Kennlinie
+
+### Neu implementiert
+
+- beide AI- und AO-Kanaele
+- frei waehlbare Kanaele und dynamische Variablen
+- konfigurierbare Intervalle und ueberschreibbare Hardwarepfade
+- Status-, Fehler- und Debugdiagnose
+
+### Verworfen
+
+- rekursives Schreiben mit bis zu fuenf Sekunden Blockierzeit
+- zyklisches Neuschreiben aller DO ohne neuen Schaltbefehl
+- feste PT-Rohwertbereiche und nicht kalibrierte Skalierungsfaktoren
+
+Das alte Modul kann nicht in-place aktualisiert werden. Fuer die Umstellung:
+
+1. Vorhandene Ausgangszustaende und verwendete Kanaele dokumentieren.
+2. Eine neue Instanz 'CC100 Hardware' anlegen.
+3. Benoetigte Kanaele aktivieren und Anzeigenamen vergeben.
+4. Hardwarepfade und Kalibrierdatei pruefen.
+5. Zuerst nur Eingaenge testen.
+6. Ausgaenge einzeln und unter Aufsicht freigeben.
+
+## RS-485
+
+RS-485 gehoert nicht zur Onboard-I/O-Abbildung dieses Moduls. Der CC100 stellt
+die Schnittstelle als '/dev/ttySTM1' bereit. Protokoll, Teilnehmeradressen,
+Baudrate, Paritaet, Registerbereiche und Zeitvorgaben gehoeren in eine separate
+serielle beziehungsweise Modbus-Instanz. So bleibt die I/O-Abfrage unabhaengig
+von langsamen oder fehlerhaften Busteilnehmern.

CC100Hardware/form.json

@@ -0,0 +1,153 @@
+{
+  "elements": [
+    {
+      "type": "Label",
+      "caption": "WAGO CC100 751-9301: Nur aktivierte Kanaele werden als Variablen angelegt."
+    },
+    {
+      "type": "List",
+      "name": "Kanalauswahl",
+      "caption": "Onboard-I/O",
+      "add": true,
+      "delete": true,
+      "sortable": false,
+      "columns": [
+        {
+          "caption": "Aktiv",
+          "name": "Aktiv",
+          "width": "10%",
+          "add": false,
+          "edit": {
+            "type": "CheckBox"
+          }
+        },
+        {
+          "caption": "Typ",
+          "name": "Typ",
+          "width": "12%",
+          "add": "DI",
+          "edit": {
+            "type": "Select",
+            "options": [
+              { "caption": "Digitaler Eingang", "value": "DI" },
+              { "caption": "Digitaler Ausgang", "value": "DO" },
+              { "caption": "Analoger Eingang", "value": "AI" },
+              { "caption": "Analoger Ausgang", "value": "AO" },
+              { "caption": "PT1000", "value": "PT" }
+            ]
+          }
+        },
+        {
+          "caption": "Kanal",
+          "name": "Kanal",
+          "width": "10%",
+          "add": 1,
+          "edit": {
+            "type": "NumberSpinner",
+            "minimum": 1,
+            "maximum": 8
+          }
+        },
+        {
+          "caption": "Anzeigename",
+          "name": "Anzeigename",
+          "width": "38%",
+          "add": "",
+          "edit": {
+            "type": "ValidationTextBox"
+          }
+        },
+        {
+          "caption": "Polling (ms)",
+          "name": "Abfrageintervall",
+          "width": "20%",
+          "add": 1000,
+          "edit": {
+            "type": "NumberSpinner",
+            "minimum": 100,
+            "maximum": 3600000
+          }
+        }
+      ]
+    },
+    {
+      "type": "ExpansionPanel",
+      "caption": "Erweiterte Hardwarepfade",
+      "expanded": false,
+      "items": [
+        {
+          "type": "ValidationTextBox",
+          "name": "DigitalInputPath",
+          "caption": "Digitale Eingaenge"
+        },
+        {
+          "type": "ValidationTextBox",
+          "name": "DigitalOutputPath",
+          "caption": "Digitale Ausgaenge"
+        },
+        {
+          "type": "ValidationTextBox",
+          "name": "CalibrationPath",
+          "caption": "Kalibrierdatei"
+        },
+        {
+          "type": "ValidationTextBox",
+          "name": "AI1Path",
+          "caption": "AI1 Rohwert"
+        },
+        {
+          "type": "ValidationTextBox",
+          "name": "AI2Path",
+          "caption": "AI2 Rohwert"
+        },
+        {
+          "type": "ValidationTextBox",
+          "name": "AO1ValuePath",
+          "caption": "AO1 Rohwert"
+        },
+        {
+          "type": "ValidationTextBox",
+          "name": "AO1PowerPath",
+          "caption": "AO1 Freigabe"
+        },
+        {
+          "type": "ValidationTextBox",
+          "name": "AO2ValuePath",
+          "caption": "AO2 Rohwert"
+        },
+        {
+          "type": "ValidationTextBox",
+          "name": "AO2PowerPath",
+          "caption": "AO2 Freigabe"
+        },
+        {
+          "type": "ValidationTextBox",
+          "name": "PT1Path",
+          "caption": "PT1 Rohwert"
+        },
+        {
+          "type": "ValidationTextBox",
+          "name": "PT2Path",
+          "caption": "PT2 Rohwert"
+        }
+      ]
+    },
+    {
+      "type": "CheckBox",
+      "name": "Debug",
+      "caption": "Debug-Logging aktivieren"
+    }
+  ],
+  "actions": [
+    {
+      "type": "Button",
+      "caption": "Kanaele jetzt einlesen",
+      "onClick": "IPS_RequestAction($id, 'Poll', true);"
+    }
+  ],
+  "status": [
+    { "code": 201, "icon": "error", "caption": "Konfiguration ungueltig" },
+    { "code": 202, "icon": "error", "caption": "Hardware nicht lesbar" },
+    { "code": 203, "icon": "error", "caption": "Hardware konnte nicht geschrieben werden" }
+  ]
+}

CC100Hardware/libs/CC100ChannelModel.php

@@ -0,0 +1,277 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Belevo\EnelixUtils\CC100;
+
+use InvalidArgumentException;
+use RuntimeException;
+
+final class CC100ChannelModel
+{
+    /** @var array<string, int> */
+    private const CHANNEL_COUNTS = [
+        'DI' => 8,
+        'DO' => 4,
+        'AI' => 2,
+        'AO' => 2,
+        'PT' => 2,
+    ];
+
+    /** @var array<string, int> */
+    private const DEFAULT_INTERVALS = [
+        'DI' => 500,
+        'DO' => 500,
+        'AI' => 5000,
+        'AO' => 5000,
+        'PT' => 5000,
+    ];
+
+    /**
+     * @return list<array{Aktiv: bool, Typ: string, Kanal: int, Anzeigename: string, Abfrageintervall: int}>
+     */
+    public static function defaultSelection(): array
+    {
+        $selection = [];
+        foreach (self::CHANNEL_COUNTS as $type => $count) {
+            for ($channel = 1; $channel <= $count; $channel++) {
+                $selection[] = [
+                    'Aktiv' => false,
+                    'Typ' => $type,
+                    'Kanal' => $channel,
+                    'Anzeigename' => self::defaultName($type, $channel),
+                    'Abfrageintervall' => self::DEFAULT_INTERVALS[$type],
+                ];
+            }
+        }
+
+        return $selection;
+    }
+
+    /**
+     * @return list<array{
+     *   key: string,
+     *   type: string,
+     *   channel: int,
+     *   name: string,
+     *   active: bool,
+     *   pollInterval: int
+     * }>
+     */
+    public static function normalizeSelection(string $json): array
+    {
+        try {
+            $rows = json_decode($json, true, 512, JSON_THROW_ON_ERROR);
+        } catch (\JsonException $exception) {
+            throw new InvalidArgumentException('Kanalauswahl ist kein gueltiges JSON.', 0, $exception);
+        }
+
+        if (!is_array($rows)) {
+            throw new InvalidArgumentException('Kanalauswahl muss eine Liste sein.');
+        }
+
+        $result = [];
+        $keys = [];
+        foreach ($rows as $index => $row) {
+            if (!is_array($row)) {
+                throw new InvalidArgumentException('Kanalzeile ' . ($index + 1) . ' ist ungueltig.');
+            }
+
+            $type = strtoupper(trim((string) ($row['Typ'] ?? '')));
+            $channel = filter_var($row['Kanal'] ?? null, FILTER_VALIDATE_INT);
+            if ($channel === false || !isset(self::CHANNEL_COUNTS[$type])) {
+                throw new InvalidArgumentException('Kanalzeile ' . ($index + 1) . ' hat einen ungueltigen Typ oder Kanal.');
+            }
+            if ($channel < 1 || $channel > self::CHANNEL_COUNTS[$type]) {
+                throw new InvalidArgumentException(
+                    sprintf('%s erlaubt nur die Kanaele 1 bis %d.', $type, self::CHANNEL_COUNTS[$type])
+                );
+            }
+
+            $key = $type . $channel;
+            if (isset($keys[$key])) {
+                throw new InvalidArgumentException('Kanal ' . $key . ' ist doppelt konfiguriert.');
+            }
+            $keys[$key] = true;
+
+            $name = trim((string) ($row['Anzeigename'] ?? ''));
+            if ($name === '') {
+                $name = self::defaultName($type, $channel);
+            }
+            if (strlen($name) > 80) {
+                throw new InvalidArgumentException('Der Anzeigename von ' . $key . ' ist zu lang.');
+            }
+
+            $pollInterval = filter_var($row['Abfrageintervall'] ?? null, FILTER_VALIDATE_INT);
+            if ($pollInterval === false || $pollInterval < 100 || $pollInterval > 3600000) {
+                throw new InvalidArgumentException(
+                    'Das Abfrageintervall von ' . $key . ' muss zwischen 100 und 3600000 ms liegen.'
+                );
+            }
+
+            $result[] = [
+                'key' => $key,
+                'type' => $type,
+                'channel' => $channel,
+                'name' => $name,
+                'active' => (bool) ($row['Aktiv'] ?? false),
+                'pollInterval' => $pollInterval,
+            ];
+        }
+
+        return $result;
+    }
+
+    /**
+     * @return array{variableType: int, profile: string, writable: bool, position: int}
+     */
+    public static function definition(string $type, int $channel): array
+    {
+        $type = strtoupper($type);
+        if (!isset(self::CHANNEL_COUNTS[$type]) || $channel < 1 || $channel > self::CHANNEL_COUNTS[$type]) {
+            throw new InvalidArgumentException('Unbekannter CC100-Kanal.');
+        }
+
+        $offsets = ['DI' => 100, 'DO' => 200, 'AI' => 300, 'AO' => 400, 'PT' => 500];
+
+        return [
+            'variableType' => in_array($type, ['DI', 'DO'], true) ? 0 : 2,
+            'profile' => match ($type) {
+                'DO' => '~Switch',
+                'AI', 'AO' => '~Volt',
+                'PT' => '~Temperature',
+                default => '',
+            },
+            'writable' => in_array($type, ['DO', 'AO'], true),
+            'position' => $offsets[$type] + $channel,
+        ];
+    }
+
+    public static function defaultName(string $type, int $channel): string
+    {
+        return match ($type) {
+            'DI' => 'Digitaler Eingang ' . $channel,
+            'DO' => 'Digitaler Ausgang ' . $channel,
+            'AI' => 'Analoger Eingang ' . $channel,
+            'AO' => 'Analoger Ausgang ' . $channel,
+            'PT' => 'PT1000 Temperatur ' . $channel,
+            default => $type . $channel,
+        };
+    }
+
+    /**
+     * @return array<string, array{x1: float, y1: float, x2: float, y2: float}>
+     */
+    public static function parseCalibration(string $content): array
+    {
+        $lines = preg_split('/\R/', trim($content)) ?: [];
+        $lines = array_values(array_filter(array_map('trim', $lines), static fn (string $line): bool => $line !== ''));
+        if (count($lines) < 2) {
+            throw new InvalidArgumentException('Kalibrierdatei ist leer oder unvollstaendig.');
+        }
+
+        $headers = preg_split('/\s+/', array_shift($lines)) ?: [];
+        $calibration = [];
+        foreach ($headers as $index => $header) {
+            if (!isset($lines[$index])) {
+                throw new InvalidArgumentException('Kalibrierwert fuer ' . $header . ' fehlt.');
+            }
+
+            $key = strtoupper($header);
+            if ($key === 'A01') {
+                $key = 'AO1';
+            } elseif ($key === 'A02') {
+                $key = 'AO2';
+            }
+
+            $values = preg_split('/\s+/', $lines[$index]) ?: [];
+            if (count($values) !== 4 || count(array_filter($values, 'is_numeric')) !== 4) {
+                throw new InvalidArgumentException('Kalibrierwert fuer ' . $key . ' ist ungueltig.');
+            }
+
+            [$x1, $y1, $x2, $y2] = array_map('floatval', $values);
+            if ($x1 === $x2 || $y1 === $y2) {
+                throw new InvalidArgumentException('Kalibrierpunkte fuer ' . $key . ' sind nicht eindeutig.');
+            }
+            $calibration[$key] = compact('x1', 'y1', 'x2', 'y2');
+        }
+
+        return $calibration;
+    }
+
+    /** @param array{x1: float, y1: float, x2: float, y2: float} $calibration */
+    public static function rawToEngineering(float $raw, array $calibration): float
+    {
+        return (($calibration['y2'] - $calibration['y1']) / ($calibration['x2'] - $calibration['x1']))
+            * ($raw - $calibration['x1'])
+            + $calibration['y1'];
+    }
+
+    /** @param array{x1: float, y1: float, x2: float, y2: float} $calibration */
+    public static function engineeringToRaw(float $value, array $calibration): int
+    {
+        $raw = (($calibration['x2'] - $calibration['x1']) / ($calibration['y2'] - $calibration['y1']))
+            * ($value - $calibration['y1'])
+            + $calibration['x1'];
+
+        return (int) round($raw);
+    }
+
+    public static function pt1000Temperature(float $resistance): float
+    {
+        if (!is_finite($resistance) || $resistance < 760.0 || $resistance > 2300.0) {
+            throw new InvalidArgumentException('PT1000-Widerstand liegt ausserhalb des unterstuetzten Bereichs.');
+        }
+
+        $low = -60.0;
+        $high = 350.0;
+        for ($iteration = 0; $iteration < 50; $iteration++) {
+            $middle = ($low + $high) / 2.0;
+            if (self::pt1000Resistance($middle) < $resistance) {
+                $low = $middle;
+            } else {
+                $high = $middle;
+            }
+        }
+
+        return round(($low + $high) / 2.0, 1);
+    }
+
+    public static function parseInteger(string $content): int
+    {
+        $value = trim($content);
+        if (!preg_match('/^-?\d+$/', $value)) {
+            throw new RuntimeException('Hardwarewert ist keine ganze Zahl.');
+        }
+
+        return (int) $value;
+    }
+
+    public static function bitState(int $aggregate, int $channel): bool
+    {
+        if ($channel < 1 || $channel > 8) {
+            throw new InvalidArgumentException('Bitkanal muss zwischen 1 und 8 liegen.');
+        }
+
+        return ($aggregate & (1 << ($channel - 1))) !== 0;
+    }
+
+    public static function withBitState(int $aggregate, int $channel, bool $state): int
+    {
+        $mask = 1 << ($channel - 1);
+        return $state ? ($aggregate | $mask) : ($aggregate & ~$mask);
+    }
+
+    private static function pt1000Resistance(float $temperature): float
+    {
+        $a = 3.9083e-3;
+        $b = -5.775e-7;
+        $c = -4.183e-12;
+        $factor = 1.0 + ($a * $temperature) + ($b * $temperature * $temperature);
+        if ($temperature < 0.0) {
+            $factor += $c * ($temperature - 100.0) * $temperature * $temperature * $temperature;
+        }
+
+        return 1000.0 * $factor;
+    }
+}

CC100Hardware/module.json

@@ -0,0 +1,14 @@
+{
+  "id": "{D62EA550-68A5-48E2-BF31-1C721AA1BD4E}",
+  "name": "CC100 Hardware",
+  "type": 3,
+  "vendor": "Belevo AG",
+  "aliases": [
+    "WAGO CC100 Hardware"
+  ],
+  "parentRequirements": [],
+  "childRequirements": [],
+  "implemented": [],
+  "prefix": "CC100",
+  "url": ""
+}

CC100Hardware/module.php

@@ -0,0 +1,405 @@
+<?php
+
+declare(strict_types=1);
+
+use Belevo\EnelixUtils\CC100\CC100ChannelModel;
+
+require_once __DIR__ . '/libs/CC100ChannelModel.php';
+
+class CC100Hardware extends IPSModule
+{
+    private const STATUS_CONFIGURATION_INVALID = 201;
+    private const STATUS_HARDWARE_UNAVAILABLE = 202;
+    private const STATUS_WRITE_FAILED = 203;
+
+    public function Create()
+    {
+        parent::Create();
+
+        $this->RegisterPropertyString(
+            'Kanalauswahl',
+            json_encode(CC100ChannelModel::defaultSelection(), JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR)
+        );
+        $this->RegisterPropertyString(
+            'DigitalInputPath',
+            '/sys/devices/platform/soc/44009000.spi/spi_master/spi0/spi0.0/din'
+        );
+        $this->RegisterPropertyString('DigitalOutputPath', '/sys/kernel/dout_drv/DOUT_DATA');
+        $this->RegisterPropertyString('CalibrationPath', '/etc/calib');
+        $this->RegisterPropertyString('AI1Path', '/sys/bus/iio/devices/iio:device3/in_voltage3_raw');
+        $this->RegisterPropertyString('AI2Path', '/sys/bus/iio/devices/iio:device3/in_voltage0_raw');
+        $this->RegisterPropertyString('AO1ValuePath', '/sys/bus/iio/devices/iio:device0/out_voltage1_raw');
+        $this->RegisterPropertyString('AO1PowerPath', '/sys/bus/iio/devices/iio:device0/out_voltage1_powerdown');
+        $this->RegisterPropertyString('AO2ValuePath', '/sys/bus/iio/devices/iio:device1/out_voltage2_raw');
+        $this->RegisterPropertyString('AO2PowerPath', '/sys/bus/iio/devices/iio:device1/out_voltage2_powerdown');
+        $this->RegisterPropertyString('PT1Path', '/sys/bus/iio/devices/iio:device2/in_voltage13_raw');
+        $this->RegisterPropertyString('PT2Path', '/sys/bus/iio/devices/iio:device2/in_voltage1_raw');
+        $this->RegisterPropertyBoolean('Debug', false);
+
+        $this->RegisterAttributeString('LastPoll', '{}');
+        $this->RegisterAttributeString('Calibration', '{}');
+        $this->RegisterTimer(
+            'PollChannels',
+            0,
+            'IPS_RequestAction(' . $this->InstanceID . ', "Poll", true);'
+        );
+
+        $this->RegisterVariableInteger('Hardwarestatus', 'Hardwarestatus', '', 900);
+        $this->RegisterVariableString('Stoertext', 'Stoertext', '', 901);
+    }
+
+    public function ApplyChanges()
+    {
+        parent::ApplyChanges();
+
+        try {
+            $channels = CC100ChannelModel::normalizeSelection($this->ReadPropertyString('Kanalauswahl'));
+            $this->synchronizeVariables($channels);
+            $activeChannels = array_values(array_filter(
+                $channels,
+                static fn (array $channel): bool => $channel['active']
+            ));
+            $this->SetSummary(count($activeChannels) . ' Kanaele aktiv');
+            $this->WriteAttributeString('LastPoll', '{}');
+            $this->WriteAttributeString('Calibration', '{}');
+
+            if ($activeChannels === []) {
+                $this->SetTimerInterval('PollChannels', 0);
+                $this->setHardwareStatus(0, 'Keine Kanaele aktiviert.');
+                $this->SetStatus(IS_ACTIVE);
+                return;
+            }
+
+            $intervals = array_column($activeChannels, 'pollInterval');
+            $this->SetTimerInterval('PollChannels', min($intervals));
+            $this->PollChannels(true);
+        } catch (Throwable $exception) {
+            $this->SetTimerInterval('PollChannels', 0);
+            $this->setHardwareStatus(3, $exception->getMessage());
+            $this->SetStatus(self::STATUS_CONFIGURATION_INVALID);
+            $this->debug('Konfiguration', $exception->getMessage());
+        }
+    }
+
+    public function RequestAction($Ident, $Value)
+    {
+        if ($Ident === 'Poll') {
+            $this->PollChannels((bool) $Value);
+            return;
+        }
+
+        if (preg_match('/^(DO|AO)([1-9][0-9]*)$/', (string) $Ident, $matches) !== 1) {
+            throw new InvalidArgumentException('Unbekannte Aktion ' . $Ident . '.');
+        }
+
+        $type = $matches[1];
+        $channel = (int) $matches[2];
+        if ($type === 'DO') {
+            $this->SetDigitalOutput($channel, (bool) $Value);
+            return;
+        }
+
+        if (!is_int($Value) && !is_float($Value)) {
+            throw new InvalidArgumentException('Analoger Ausgang erwartet einen Zahlenwert in Volt.');
+        }
+        $this->SetAnalogOutput($channel, (float) $Value);
+    }
+
+    public function PollChannels(bool $force = false): void
+    {
+        try {
+            $channels = array_values(array_filter(
+                CC100ChannelModel::normalizeSelection($this->ReadPropertyString('Kanalauswahl')),
+                static fn (array $channel): bool => $channel['active']
+            ));
+        } catch (Throwable $exception) {
+            $this->setHardwareStatus(3, $exception->getMessage());
+            $this->SetStatus(self::STATUS_CONFIGURATION_INVALID);
+            return;
+        }
+
+        if ($channels === []) {
+            return;
+        }
+
+        $now = (int) round(microtime(true) * 1000);
+        $lastPoll = json_decode($this->ReadAttributeString('LastPoll'), true);
+        if (!is_array($lastPoll)) {
+            $lastPoll = [];
+        }
+
+        $due = array_values(array_filter(
+            $channels,
+            static fn (array $channel): bool => $force
+                || $now - (int) ($lastPoll[$channel['key']] ?? 0) >= $channel['pollInterval']
+        ));
+        if ($due === []) {
+            return;
+        }
+
+        $errors = [];
+        $fileCache = [];
+        foreach ($due as $channel) {
+            try {
+                $value = $this->readChannel($channel, $fileCache);
+                $this->setValueIfChanged($channel['key'], $value);
+            } catch (Throwable $exception) {
+                $errors[] = $channel['key'] . ': ' . $exception->getMessage();
+                $this->debug('Lesefehler ' . $channel['key'], $exception->getMessage());
+            }
+            $lastPoll[$channel['key']] = $now;
+        }
+        $this->WriteAttributeString(
+            'LastPoll',
+            json_encode($lastPoll, JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR)
+        );
+
+        if ($errors === []) {
+            $this->setHardwareStatus(1, '');
+            $this->SetStatus(IS_ACTIVE);
+            return;
+        }
+
+        $this->setHardwareStatus(2, implode(' | ', $errors));
+        $this->SetStatus(self::STATUS_HARDWARE_UNAVAILABLE);
+    }
+
+    public function SetDigitalOutput(int $channel, bool $state): void
+    {
+        $key = 'DO' . $channel;
+        $this->assertWritableSelected($key);
+
+        try {
+            $path = $this->ReadPropertyString('DigitalOutputPath');
+            $aggregate = CC100ChannelModel::parseInteger($this->readFile($path));
+            $newValue = CC100ChannelModel::withBitState($aggregate, $channel, $state);
+            if ($newValue !== $aggregate) {
+                $this->writeFile($path, (string) $newValue);
+            }
+            $this->setValueIfChanged($key, $state);
+            $this->PollChannels(true);
+        } catch (Throwable $exception) {
+            $this->setHardwareStatus(3, $key . ': ' . $exception->getMessage());
+            $this->SetStatus(self::STATUS_WRITE_FAILED);
+            throw $exception;
+        }
+    }
+
+    public function SetAnalogOutput(int $channel, float $voltage): void
+    {
+        $key = 'AO' . $channel;
+        $this->assertWritableSelected($key);
+        if (!is_finite($voltage) || $voltage < 0.0 || $voltage > 10.0) {
+            throw new InvalidArgumentException('Analoger Ausgang muss zwischen 0 und 10 V liegen.');
+        }
+
+        try {
+            $calibration = $this->calibrationFor($key);
+            $raw = CC100ChannelModel::engineeringToRaw($voltage * 1000.0, $calibration);
+            $this->writeFile($this->ReadPropertyString($key . 'PowerPath'), '0');
+            $this->writeFile($this->ReadPropertyString($key . 'ValuePath'), (string) $raw);
+            $this->setValueIfChanged($key, round($voltage, 3));
+            $this->PollChannels(true);
+        } catch (Throwable $exception) {
+            $this->setHardwareStatus(3, $key . ': ' . $exception->getMessage());
+            $this->SetStatus(self::STATUS_WRITE_FAILED);
+            throw $exception;
+        }
+    }
+
+    /**
+     * @param list<array{
+     *   key: string,
+     *   type: string,
+     *   channel: int,
+     *   name: string,
+     *   active: bool,
+     *   pollInterval: int
+     * }> $channels
+     */
+    private function synchronizeVariables(array $channels): void
+    {
+        $configured = [];
+        foreach ($channels as $channel) {
+            $configured[$channel['key']] = $channel;
+            if (!$channel['active']) {
+                continue;
+            }
+
+            $definition = CC100ChannelModel::definition($channel['type'], $channel['channel']);
+            if ($definition['variableType'] === 0) {
+                $this->RegisterVariableBoolean(
+                    $channel['key'],
+                    $channel['name'],
+                    $definition['profile'],
+                    $definition['position']
+                );
+            } else {
+                $this->RegisterVariableFloat(
+                    $channel['key'],
+                    $channel['name'],
+                    $definition['profile'],
+                    $definition['position']
+                );
+            }
+
+            if ($definition['writable']) {
+                $this->EnableAction($channel['key']);
+            }
+        }
+
+        foreach (CC100ChannelModel::defaultSelection() as $default) {
+            $key = $default['Typ'] . $default['Kanal'];
+            if (($configured[$key]['active'] ?? false) === true) {
+                continue;
+            }
+            if (@$this->GetIDForIdent($key) !== false) {
+                $this->UnregisterVariable($key);
+            }
+        }
+    }
+
+    /**
+     * @param array{key: string, type: string, channel: int} $channel
+     * @param array<string, int> $fileCache
+     * @return bool|float
+     */
+    private function readChannel(array $channel, array &$fileCache)
+    {
+        $type = $channel['type'];
+        $number = $channel['channel'];
+        if ($type === 'DI' || $type === 'DO') {
+            $property = $type === 'DI' ? 'DigitalInputPath' : 'DigitalOutputPath';
+            $path = $this->ReadPropertyString($property);
+            if (!array_key_exists($path, $fileCache)) {
+                $fileCache[$path] = CC100ChannelModel::parseInteger($this->readFile($path));
+            }
+
+            return CC100ChannelModel::bitState($fileCache[$path], $number);
+        }
+
+        $key = $type . $number;
+        $raw = CC100ChannelModel::parseInteger($this->readFile($this->pathFor($key)));
+        $engineering = CC100ChannelModel::rawToEngineering($raw, $this->calibrationFor($key));
+        if ($type === 'PT') {
+            return CC100ChannelModel::pt1000Temperature($engineering);
+        }
+
+        return round($engineering / 1000.0, 3);
+    }
+
+    private function pathFor(string $key): string
+    {
+        if (str_starts_with($key, 'AI') || str_starts_with($key, 'PT')) {
+            return $this->ReadPropertyString($key . 'Path');
+        }
+        if (str_starts_with($key, 'AO')) {
+            return $this->ReadPropertyString($key . 'ValuePath');
+        }
+
+        throw new InvalidArgumentException('Kein Einzelpfad fuer ' . $key . '.');
+    }
+
+    /** @return array{x1: float, y1: float, x2: float, y2: float} */
+    private function calibrationFor(string $key): array
+    {
+        $stored = json_decode($this->ReadAttributeString('Calibration'), true);
+        if (!is_array($stored) || $stored === []) {
+            $stored = CC100ChannelModel::parseCalibration(
+                $this->readFile($this->ReadPropertyString('CalibrationPath'))
+            );
+            $this->WriteAttributeString(
+                'Calibration',
+                json_encode($stored, JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR)
+            );
+        }
+
+        if (!isset($stored[$key]) || !is_array($stored[$key])) {
+            throw new RuntimeException('Kalibrierung fuer ' . $key . ' fehlt.');
+        }
+
+        return $stored[$key];
+    }
+
+    private function assertWritableSelected(string $key): void
+    {
+        $channels = CC100ChannelModel::normalizeSelection($this->ReadPropertyString('Kanalauswahl'));
+        foreach ($channels as $channel) {
+            if ($channel['key'] !== $key || !$channel['active']) {
+                continue;
+            }
+            $definition = CC100ChannelModel::definition($channel['type'], $channel['channel']);
+            if ($definition['writable']) {
+                return;
+            }
+        }
+
+        throw new RuntimeException($key . ' ist nicht als bedienbarer Kanal aktiviert.');
+    }
+
+    private function readFile(string $path): string
+    {
+        if ($path === '' || !is_readable($path)) {
+            throw new RuntimeException('Datei ist nicht lesbar: ' . $path);
+        }
+
+        $content = @file_get_contents($path);
+        if ($content === false) {
+            throw new RuntimeException('Datei konnte nicht gelesen werden: ' . $path);
+        }
+
+        return $content;
+    }
+
+    private function writeFile(string $path, string $value): void
+    {
+        if ($path === '') {
+            throw new RuntimeException('Ausgabepfad ist leer.');
+        }
+
+        $written = @file_put_contents($path, $value);
+        if ($written === false) {
+            throw new RuntimeException('Datei konnte nicht geschrieben werden: ' . $path);
+        }
+        $this->debug('Hardware schreiben', $path . ' <- ' . $value);
+    }
+
+    /** @param bool|float $value */
+    private function setValueIfChanged(string $ident, $value): void
+    {
+        $variableID = @$this->GetIDForIdent($ident);
+        if ($variableID === false) {
+            return;
+        }
+
+        $current = $this->GetValue($ident);
+        if (is_float($value)) {
+            if (is_float($current) && abs($current - $value) < 0.0001) {
+                return;
+            }
+        } elseif ($current === $value) {
+            return;
+        }
+
+        $this->SetValue($ident, $value);
+    }
+
+    private function setHardwareStatus(int $status, string $message): void
+    {
+        $this->setValueIfChanged('Hardwarestatus', $status);
+        $this->setValueIfChanged('Stoertext', $message);
+    }
+
+    /** @param mixed $message */
+    private function debug(string $title, $message): void
+    {
+        if (!$this->ReadPropertyBoolean('Debug')) {
+            return;
+        }
+        if (!is_string($message)) {
+            $message = json_encode($message, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
+        }
+
+        $this->SendDebug($title, (string) $message, 0);
+    }
+}

CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+Alle wesentlichen Aenderungen an Enelix Utils werden in dieser Datei dokumentiert.
+
+## 0.1 Build 1 - Erste Beta - 2026-09-29
+
+### Enthalten
+
+- Verbrauchskostenreport mit PDF-Ausgabe und Schweizer QR-Zahlteil nach SIX 2.3.
+- Verbrauchskostenreport mit Grundlizenz sowie Strom- und Nebenzaehlerkontingenten.
+- Virtuelle Batterie und VGT-Schnittstelle.
+- CC100 Hardware und generisches Shelly Modul.
+- Energiediagramm fuer die IP-Symcon-Kachelvisualisierung.
+
+### Beta-Aenderungen
+
+- Dezimale IP-Symcon-Farbwerte werden im Energiediagramm korrekt verarbeitet.
+- Kachelabstand fuer den Symcon-Kopf und versionsabhaengiger Vollbildmodus.
+- Vollstaendige PHP-, Struktur- und Symcon-Modultests fuer alle Module.
+- Composer-Metadaten- und Abhaengigkeitspruefung in der CI.
+
+### Hinweise
+
+- Diese Version ist fuer kontrollierte Anlagen- und Feldtests bestimmt.
+- Vor produktivem Einsatz sind Sicherung und anlagenspezifische Abnahme erforderlich.
+- Korrekturen werden vorwaerts ueber `develop` und anschliessend `beta` verteilt.

Energiediagramm/README.md

@@ -0,0 +1,63 @@
+# Energiediagramm
+
+Das Energiediagramm stellt Produktion, Hausverbrauch, Netzbezug und
+Einspeisung aus archivierten Energiezaehlern dar. Zwei Kreisdiagramme zeigen
+Eigenverbrauchsquote und Autarkiegrad.
+
+## Voraussetzungen
+
+- IP-Symcon ab Version 8.0
+- aktiviertes Archiv
+- fortlaufende Integer- oder Floatzaehler
+- Zaehlerwerte in kWh oder ein passender gemeinsamer Zaehlerfaktor
+
+## Konfiguration
+
+Produktion, Einspeisung und Netzbezug sind Pflichtquellen. Ein vorhandener
+Hausverbrauchszaehler kann optional direkt verwendet werden. Ohne diese Quelle
+wird der Hausverbrauch als Produktion minus Einspeisung plus Netzbezug
+berechnet.
+
+Der Standardzeitraum kann auf aktuellen Tag, aktuelle Woche, aktuellen Monat,
+aktuelles Jahr oder Gesamt gesetzt werden. In der Visualisierung stehen
+zusaetzlich ein frei waehlbarer inklusiver Datumsbereich und die Navigation
+durch abgeschlossene Zeitraeume zur Verfuegung.
+
+Die Farben fuer Eigenverbrauchsquote und Autarkiegrad werden mit den beiden
+Farbauswahlen in der Instanzkonfiguration festgelegt. Das Modul verarbeitet
+sowohl aktuelle Hex-Farbwerte als auch die von IP-Symcon 8.0 gespeicherten
+dezimalen Farbwerte.
+
+## Darstellung
+
+Der Inhalt beginnt unterhalb des von Symcon eingeblendeten Kachelkopfs, damit
+Zeitraum und Datum vollstaendig bedienbar bleiben. Beim Oeffnen und beim erneuten
+Sichtbarwerden wird die Darstellung aktualisiert. Das Diagrammraster wechselt
+bei geringer Breite automatisch von zwei Spalten auf eine Spalte.
+
+IP-Symcon 8.x unterstuetzt HTML-SDK-Darstellungen nur in der normalen Kachel.
+Der vom Client angebotene Vergroesserungsdialog kann deshalb leer bleiben.
+Ab IP-Symcon 9.0 aktiviert das Modul automatisch den zusaetzlichen
+HTML-SDK-Vollbildmodus.
+
+## Berechnung
+
+- Hausverbrauch: direkter Zaehler oder Produktion - Einspeisung + Netzbezug
+- Eigenverbrauch: Hausverbrauch - Netzbezug, begrenzt auf die Produktion
+- Eigenverbrauchsquote: Eigenverbrauch / Produktion
+- Autarkiegrad: Eigenverbrauch / Hausverbrauch
+
+Negative Zaehlerdifferenzen, etwa nach einem Zaehlerwechsel, werden fuer den
+betroffenen Zeitraum auf 0 kWh begrenzt.
+
+## Migration aus Enelix 1
+
+Uebernommen wurden die drei Pflichtzaehler, die Zeitraumsauswahl, die
+Datumsnavigation, die Energiebilanz und beide Kreisdiagramme. Neu sind die
+optionale direkte Hausverbrauchsquelle, der konfigurierbare Standardzeitraum,
+der freie Datumsbereich, waehlbare Farben, eingebettete Initialdaten fuer die
+vergroesserte Ansicht und das responsive Ein-/Zweispaltenlayout.
+
+Das Enelix-1-Modul wird nicht in-place aktualisiert. Es muss eine neue
+Energiediagramm-Instanz angelegt und mit den bisherigen Zaehlern konfiguriert
+werden.

Energiediagramm/form.json

@@ -0,0 +1,97 @@
+{
+  "elements": [
+    {
+      "type": "Label",
+      "caption": "Energiezaehler muessen als fortlaufende kWh-Zaehler im Archiv protokolliert werden."
+    },
+    {
+      "type": "SelectVariable",
+      "name": "ProduktionZaehlerID",
+      "caption": "Produktion"
+    },
+    {
+      "type": "SelectVariable",
+      "name": "EinspeisungZaehlerID",
+      "caption": "Einspeisung"
+    },
+    {
+      "type": "SelectVariable",
+      "name": "NetzbezugZaehlerID",
+      "caption": "Netzbezug"
+    },
+    {
+      "type": "SelectVariable",
+      "name": "VerbrauchZaehlerID",
+      "caption": "Hausverbrauch (optional)"
+    },
+    {
+      "type": "NumberSpinner",
+      "name": "Zaehlerfaktor",
+      "caption": "Zaehlerfaktor auf kWh",
+      "minimum": 0.000001,
+      "maximum": 1000000,
+      "digits": 6
+    },
+    {
+      "type": "Select",
+      "name": "Standardzeitraum",
+      "caption": "Standardzeitraum",
+      "options": [
+        { "caption": "Aktueller Tag", "value": "day" },
+        { "caption": "Aktuelle Woche", "value": "week" },
+        { "caption": "Aktueller Monat", "value": "month" },
+        { "caption": "Aktuelles Jahr", "value": "year" },
+        { "caption": "Gesamt", "value": "total" }
+      ]
+    },
+    {
+      "type": "NumberSpinner",
+      "name": "Aktualisierungsintervall",
+      "caption": "Aktualisierungsintervall",
+      "minimum": 10,
+      "maximum": 3600,
+      "suffix": " Sekunden"
+    },
+    {
+      "type": "RowLayout",
+      "items": [
+        {
+          "type": "SelectColor",
+          "name": "FarbeEigenverbrauch",
+          "caption": "Eigenverbrauchsquote",
+          "allowTransparent": false
+        },
+        {
+          "type": "SelectColor",
+          "name": "FarbeAutarkie",
+          "caption": "Autarkiegrad",
+          "allowTransparent": false
+        }
+      ]
+    },
+    {
+      "type": "CheckBox",
+      "name": "Debug",
+      "caption": "Debug-Logging aktivieren"
+    }
+  ],
+  "actions": [
+    {
+      "type": "Button",
+      "caption": "Darstellung aktualisieren",
+      "onClick": "IPS_RequestAction($id, 'Refresh', true);"
+    }
+  ],
+  "status": [
+    {
+      "code": 201,
+      "icon": "error",
+      "caption": "Konfiguration ungueltig"
+    },
+    {
+      "code": 202,
+      "icon": "error",
+      "caption": "Archiv nicht verfuegbar"
+    }
+  ]
+}

Energiediagramm/libs/EnergyChartCalculator.php

@@ -0,0 +1,144 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Belevo\EnelixUtils\Energiediagramm;
+
+use DateTimeImmutable;
+use DateTimeZone;
+use InvalidArgumentException;
+
+final class EnergyChartCalculator
+{
+    public const RANGES = ['day', 'week', 'month', 'year', 'total', 'custom'];
+
+    public static function isValidDate(string $date): bool
+    {
+        $value = DateTimeImmutable::createFromFormat('!Y-m-d', $date);
+        $errors = DateTimeImmutable::getLastErrors();
+
+        return $value !== false
+            && ($errors === false || ($errors['warning_count'] === 0 && $errors['error_count'] === 0))
+            && $value->format('Y-m-d') === $date;
+    }
+
+    /**
+     * @return array{0: int, 1: int}
+     */
+    public static function rangeBounds(
+        string $range,
+        string $date,
+        string $customStart,
+        string $customEnd,
+        ?int $now = null
+    ): array {
+        if (!in_array($range, self::RANGES, true)) {
+            throw new InvalidArgumentException('Unbekannter Zeitraum.');
+        }
+
+        $now ??= time();
+        if ($range === 'total') {
+            return [0, $now];
+        }
+
+        if ($range === 'custom') {
+            $start = self::date($customStart);
+            $end = self::date($customEnd);
+            if ($start > $end) {
+                throw new InvalidArgumentException('Das Startdatum liegt nach dem Enddatum.');
+            }
+
+            return [$start->getTimestamp(), $end->modify('+1 day')->getTimestamp()];
+        }
+
+        $base = self::date($date);
+        switch ($range) {
+            case 'day':
+                $start = $base;
+                $end = $start->modify('+1 day');
+                break;
+            case 'week':
+                $start = $base->modify('monday this week');
+                $end = $start->modify('+1 week');
+                break;
+            case 'month':
+                $start = $base->modify('first day of this month');
+                $end = $start->modify('first day of next month');
+                break;
+            case 'year':
+                $start = $base->setDate((int) $base->format('Y'), 1, 1);
+                $end = $start->modify('+1 year');
+                break;
+            default:
+                throw new InvalidArgumentException('Unbekannter Zeitraum.');
+        }
+
+        return [$start->getTimestamp(), $end->getTimestamp()];
+    }
+
+    /**
+     * @return array{
+     *   Produktion: float,
+     *   Einspeisung: float,
+     *   Netzbezug: float,
+     *   Hausverbrauch: float,
+     *   Eigenverbrauch: float,
+     *   Eigenverbrauchsquote: float,
+     *   Autarkiegrad: float
+     * }
+     */
+    public static function metrics(
+        float $production,
+        float $feedIn,
+        float $grid,
+        ?float $consumption = null
+    ): array {
+        $production = max(0.0, $production);
+        $feedIn = max(0.0, $feedIn);
+        $grid = max(0.0, $grid);
+        $house = $consumption === null
+            ? max(0.0, $production - $feedIn + $grid)
+            : max(0.0, $consumption);
+        $selfConsumption = min($production, max(0.0, $house - $grid));
+
+        return [
+            'Produktion' => $production,
+            'Einspeisung' => $feedIn,
+            'Netzbezug' => $grid,
+            'Hausverbrauch' => $house,
+            'Eigenverbrauch' => $selfConsumption,
+            'Eigenverbrauchsquote' => $production > 0.0
+                ? min(100.0, ($selfConsumption / $production) * 100.0)
+                : 0.0,
+            'Autarkiegrad' => $house > 0.0
+                ? min(100.0, ($selfConsumption / $house) * 100.0)
+                : 0.0,
+        ];
+    }
+
+    public static function normalizeColor(string $color, string $fallback): string
+    {
+        $color = trim($color);
+        if (preg_match('/^#[0-9A-Fa-f]{6}$/', $color) === 1) {
+            return strtoupper($color);
+        }
+
+        if (preg_match('/^[0-9]+$/', $color) === 1) {
+            $legacyColor = (int) $color;
+            if ($legacyColor >= 0 && $legacyColor <= 0xFFFFFF) {
+                return sprintf('#%06X', $legacyColor);
+            }
+        }
+
+        return strtoupper($fallback);
+    }
+
+    private static function date(string $date): DateTimeImmutable
+    {
+        if (!self::isValidDate($date)) {
+            throw new InvalidArgumentException('Ungültiges Datum.');
+        }
+
+        return new DateTimeImmutable($date . ' 00:00:00', new DateTimeZone(date_default_timezone_get()));
+    }
+}

Energiediagramm/module.html

@@ -0,0 +1,477 @@
+<div id="energy-app">
+  <div class="toolbar">
+    <label class="field">
+      <span>Zeitraum</span>
+      <select id="range">
+        <option value="day">Tag</option>
+        <option value="week">Woche</option>
+        <option value="month">Monat</option>
+        <option value="year">Jahr</option>
+        <option value="total">Gesamt</option>
+        <option value="custom">Datumsbereich</option>
+      </select>
+    </label>
+
+    <label id="date-field" class="field">
+      <span>Datum</span>
+      <input id="date" type="date">
+    </label>
+
+    <div id="navigation" class="button-row" aria-label="Zeitraum wechseln">
+      <button id="previous" class="icon-button" type="button" title="Vorheriger Zeitraum" aria-label="Vorheriger Zeitraum">&#8249;</button>
+      <button id="today" type="button">Heute</button>
+      <button id="next" class="icon-button" type="button" title="Nächster Zeitraum" aria-label="Nächster Zeitraum">&#8250;</button>
+    </div>
+
+    <div id="custom-range" class="custom-range" hidden>
+      <label class="field">
+        <span>Von</span>
+        <input id="custom-start" type="date">
+      </label>
+      <label class="field">
+        <span>Bis</span>
+        <input id="custom-end" type="date">
+      </label>
+      <button id="apply-range" type="button">Anzeigen</button>
+    </div>
+  </div>
+
+  <div id="period" class="period" aria-live="polite"></div>
+  <div id="message" class="message" role="status" hidden></div>
+
+  <div id="summary" class="summary"></div>
+
+  <div id="charts" class="charts">
+    <section class="chart" aria-labelledby="self-consumption-title">
+      <h3 id="self-consumption-title">Eigenverbrauchsquote</h3>
+      <div id="self-consumption-chart" class="donut"></div>
+    </section>
+    <section class="chart" aria-labelledby="autarky-title">
+      <h3 id="autarky-title">Autarkiegrad</h3>
+      <div id="autarky-chart" class="donut"></div>
+    </section>
+  </div>
+
+  <div id="error" class="error" role="alert"></div>
+</div>
+
+<style>
+  :root {
+    color-scheme: light dark;
+  }
+
+  html,
+  body {
+    min-width: 0;
+    min-height: 100%;
+    margin: 0;
+  }
+
+  #energy-app {
+    width: 100%;
+    min-height: 100%;
+    box-sizing: border-box;
+    padding: 58px 14px 14px;
+    overflow: auto;
+    font-family: system-ui, -apple-system, "Segoe UI", sans-serif;
+    color: inherit;
+    background: transparent;
+  }
+
+  .toolbar,
+  .custom-range,
+  .button-row,
+  .summary {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: end;
+    gap: 10px;
+  }
+
+  .field {
+    display: grid;
+    min-width: 128px;
+    gap: 4px;
+    font-size: 13px;
+    font-weight: 600;
+  }
+
+  select,
+  input,
+  button {
+    min-height: 36px;
+    box-sizing: border-box;
+    border: 1px solid rgba(127, 127, 127, 0.45);
+    border-radius: 6px;
+    padding: 7px 10px;
+    color: inherit;
+    background: rgba(127, 127, 127, 0.08);
+    font: inherit;
+  }
+
+  button {
+    cursor: pointer;
+    font-weight: 650;
+  }
+
+  button:focus-visible,
+  select:focus-visible,
+  input:focus-visible {
+    outline: 2px solid currentColor;
+    outline-offset: 2px;
+  }
+
+  .icon-button {
+    width: 38px;
+    padding: 0;
+    font-size: 25px;
+    line-height: 1;
+  }
+
+  .period {
+    min-height: 22px;
+    margin-top: 14px;
+    font-size: 15px;
+    font-weight: 700;
+  }
+
+  .message {
+    margin-top: 10px;
+    padding: 10px 0;
+    border-top: 1px solid rgba(127, 127, 127, 0.35);
+    border-bottom: 1px solid rgba(127, 127, 127, 0.35);
+  }
+
+  .summary {
+    align-items: stretch;
+    margin-top: 12px;
+  }
+
+  .metric {
+    min-width: 130px;
+    flex: 1 1 150px;
+    padding: 8px 0;
+    border-bottom: 2px solid rgba(127, 127, 127, 0.32);
+  }
+
+  .metric span,
+  .metric strong {
+    display: block;
+  }
+
+  .metric span {
+    font-size: 12px;
+    opacity: 0.72;
+  }
+
+  .metric strong {
+    margin-top: 3px;
+    font-size: 16px;
+  }
+
+  .charts {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(220px, 1fr));
+    gap: 22px;
+    align-items: start;
+    margin-top: 20px;
+  }
+
+  .charts.narrow {
+    grid-template-columns: minmax(0, 1fr);
+  }
+
+  .chart {
+    min-width: 0;
+    text-align: center;
+  }
+
+  .chart h3 {
+    margin: 0 0 10px;
+    font-size: 15px;
+    letter-spacing: 0;
+  }
+
+  .donut {
+    width: 176px;
+    height: 176px;
+    margin: 0 auto;
+  }
+
+  .donut svg {
+    display: block;
+    width: 176px;
+    height: 176px;
+    overflow: visible;
+  }
+
+  .donut-track {
+    stroke: rgba(127, 127, 127, 0.28);
+  }
+
+  .donut-value {
+    transition: stroke-dasharray 180ms ease;
+  }
+
+  .donut-label {
+    fill: currentColor;
+    font-size: 22px;
+    font-weight: 750;
+    text-anchor: middle;
+    dominant-baseline: middle;
+  }
+
+  .error {
+    min-height: 18px;
+    margin-top: 8px;
+    color: #d14343;
+    font-size: 13px;
+  }
+
+  [hidden] {
+    display: none !important;
+  }
+
+  @media (max-width: 560px) {
+    #energy-app {
+      padding: 58px 10px 10px;
+    }
+
+    .toolbar,
+    .custom-range {
+      align-items: stretch;
+    }
+
+    .field {
+      flex: 1 1 145px;
+    }
+
+    .charts {
+      grid-template-columns: minmax(0, 1fr);
+    }
+  }
+</style>
+
+<script>
+(function () {
+  'use strict';
+
+  const initialState = __ENELIX_INITIAL_STATE__;
+  const app = document.getElementById('energy-app');
+  const range = document.getElementById('range');
+  const date = document.getElementById('date');
+  const dateField = document.getElementById('date-field');
+  const navigation = document.getElementById('navigation');
+  const previous = document.getElementById('previous');
+  const today = document.getElementById('today');
+  const next = document.getElementById('next');
+  const customRange = document.getElementById('custom-range');
+  const customStart = document.getElementById('custom-start');
+  const customEnd = document.getElementById('custom-end');
+  const applyRange = document.getElementById('apply-range');
+  const period = document.getElementById('period');
+  const message = document.getElementById('message');
+  const summary = document.getElementById('summary');
+  const charts = document.getElementById('charts');
+  const error = document.getElementById('error');
+  const selfConsumptionChart = document.getElementById('self-consumption-chart');
+  const autarkyChart = document.getElementById('autarky-chart');
+
+  function send(action, value) {
+    if (typeof requestAction !== 'function') {
+      return;
+    }
+
+    try {
+      requestAction(action, value);
+      error.textContent = '';
+    } catch (exception) {
+      error.textContent = exception && exception.message
+        ? exception.message
+        : String(exception);
+    }
+  }
+
+  function asNumber(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+
+  function formatEnergy(value) {
+    return asNumber(value).toLocaleString('de-CH', {
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 2
+    }) + ' kWh';
+  }
+
+  function formatDate(value) {
+    const parts = String(value).split('-');
+    return parts.length === 3
+      ? parts[2] + '.' + parts[1] + '.' + parts[0]
+      : '';
+  }
+
+  function periodLabel(data) {
+    if (data.range === 'total') {
+      return 'Gesamter Zählerstand';
+    }
+    if (data.range === 'custom') {
+      return formatDate(data.customStart) + ' bis ' + formatDate(data.customEnd);
+    }
+
+    const start = new Date(asNumber(data.tStart) * 1000);
+    const end = new Date((asNumber(data.tEnd) * 1000) - 1000);
+    if (data.range === 'day') {
+      return 'Tag: ' + start.toLocaleDateString('de-CH');
+    }
+    if (data.range === 'week') {
+      return 'Woche: ' + start.toLocaleDateString('de-CH')
+        + ' bis ' + end.toLocaleDateString('de-CH');
+    }
+    if (data.range === 'month') {
+      return 'Monat: ' + start.toLocaleDateString('de-CH', {
+        month: 'long',
+        year: 'numeric'
+      });
+    }
+    if (data.range === 'year') {
+      return 'Jahr: ' + start.getFullYear();
+    }
+
+    return '';
+  }
+
+  function donut(target, percent, color) {
+    const value = Math.max(0, Math.min(100, asNumber(percent)));
+    const radius = 58;
+    const circumference = 2 * Math.PI * radius;
+    const filled = (value / 100) * circumference;
+
+    target.innerHTML = [
+      '<svg viewBox="0 0 176 176" role="img" aria-label="'
+        + value.toFixed(1) + ' Prozent">',
+      '<circle class="donut-track" cx="88" cy="88" r="' + radius
+        + '" fill="none" stroke-width="18"></circle>',
+      '<circle class="donut-value" cx="88" cy="88" r="' + radius
+        + '" fill="none" stroke="' + color + '" stroke-width="18"'
+        + ' stroke-linecap="round" transform="rotate(-90 88 88)"'
+        + ' stroke-dasharray="' + filled + ' ' + circumference + '"></circle>',
+      '<text class="donut-label" x="88" y="91">'
+        + value.toFixed(1) + '%</text>',
+      '</svg>'
+    ].join('');
+  }
+
+  function metric(label, value) {
+    return '<div class="metric"><span>' + label + '</span><strong>'
+      + formatEnergy(value) + '</strong></div>';
+  }
+
+  function render(data) {
+    if (!data || typeof data !== 'object') {
+      return;
+    }
+
+    range.value = data.range || 'day';
+    date.value = data.date || '';
+    customStart.value = data.customStart || '';
+    customEnd.value = data.customEnd || '';
+    const currentMode = range.value;
+    const custom = currentMode === 'custom';
+    const total = currentMode === 'total';
+
+    dateField.hidden = custom || total;
+    navigation.hidden = custom || total;
+    customRange.hidden = !custom;
+    period.textContent = periodLabel(data);
+
+    const values = data.values || {};
+    summary.innerHTML = [
+      metric('Produktion', values.Produktion),
+      metric('Hausverbrauch', values.Hausverbrauch),
+      metric('Netzbezug', values.Netzbezug),
+      metric('Einspeisung', values.Einspeisung)
+    ].join('');
+
+    const colors = data.colors || {};
+    donut(
+      selfConsumptionChart,
+      values.Eigenverbrauchsquote,
+      colors.selfConsumption || '#2F80ED'
+    );
+    donut(
+      autarkyChart,
+      values.Autarkiegrad,
+      colors.autarky || '#22A06B'
+    );
+
+    message.hidden = data.hasData !== false;
+    message.textContent = data.hasData === false
+      ? (data.noDataHint || 'Keine Archivwerte verfügbar.')
+      : '';
+  }
+
+  window.handleMessage = function (data) {
+    if (typeof data === 'string') {
+      try {
+        data = JSON.parse(data);
+      } catch (exception) {
+        error.textContent = 'Die Aktualisierung enthält ungültige Daten.';
+        return;
+      }
+    }
+    render(data);
+  };
+
+  range.addEventListener('change', function () {
+    send('SetRange', range.value);
+  });
+  date.addEventListener('change', function () {
+    send('SetDate', date.value);
+  });
+  previous.addEventListener('click', function () {
+    send('Prev', true);
+  });
+  next.addEventListener('click', function () {
+    send('Next', true);
+  });
+  today.addEventListener('click', function () {
+    send('Today', true);
+  });
+  applyRange.addEventListener('click', function () {
+    send('SetCustomRange', JSON.stringify({
+      start: customStart.value,
+      end: customEnd.value
+    }));
+  });
+
+  const now = new Date();
+  const currentDate = [
+    now.getFullYear(),
+    String(now.getMonth() + 1).padStart(2, '0'),
+    String(now.getDate()).padStart(2, '0')
+  ].join('-');
+  date.max = currentDate;
+  customStart.max = currentDate;
+  customEnd.max = currentDate;
+
+  if (typeof ResizeObserver === 'function') {
+    const observer = new ResizeObserver(function (entries) {
+      const width = entries[0] ? entries[0].contentRect.width : app.clientWidth;
+      charts.classList.toggle('narrow', width < 520);
+    });
+    observer.observe(app);
+  }
+
+  document.addEventListener('visibilitychange', function () {
+    if (!document.hidden) {
+      send('Refresh', true);
+    }
+  });
+
+  render(initialState);
+  window.setTimeout(function () {
+    send('Refresh', true);
+  }, 0);
+})();
+</script>

Energiediagramm/module.json

@@ -0,0 +1,14 @@
+{
+  "id": "{F73B8F8D-5E36-4B23-B379-4632A517A1D6}",
+  "name": "Energiediagramm",
+  "type": 3,
+  "vendor": "Enelix",
+  "aliases": [
+    "Energy Pie"
+  ],
+  "parentRequirements": [],
+  "childRequirements": [],
+  "implemented": [],
+  "prefix": "ENELIXENERGY",
+  "url": ""
+}

Energiediagramm/module.php

@@ -0,0 +1,485 @@
+<?php
+
+declare(strict_types=1);
+
+require_once __DIR__ . '/libs/EnergyChartCalculator.php';
+
+use Belevo\EnelixUtils\Energiediagramm\EnergyChartCalculator;
+
+class Energiediagramm extends IPSModule
+{
+    private const ARCHIVE_MODULE_ID = '{43192F0B-135B-4CE7-A0A7-1475603F3060}';
+    private const ATTR_RANGE = 'SelectedRange';
+    private const ATTR_DATE = 'SelectedDate';
+    private const ATTR_CUSTOM_START = 'CustomStart';
+    private const ATTR_CUSTOM_END = 'CustomEnd';
+    private const COLOR_SELF_CONSUMPTION = '#2F80ED';
+    private const COLOR_AUTARKY = '#22A06B';
+
+    public function Create(): void
+    {
+        parent::Create();
+
+        $this->RegisterPropertyInteger('ProduktionZaehlerID', 0);
+        $this->RegisterPropertyInteger('EinspeisungZaehlerID', 0);
+        $this->RegisterPropertyInteger('NetzbezugZaehlerID', 0);
+        $this->RegisterPropertyInteger('VerbrauchZaehlerID', 0);
+        $this->RegisterPropertyFloat('Zaehlerfaktor', 1.0);
+        $this->RegisterPropertyString('Standardzeitraum', 'day');
+        $this->RegisterPropertyInteger('Aktualisierungsintervall', 60);
+        $this->RegisterPropertyString('FarbeEigenverbrauch', self::COLOR_SELF_CONSUMPTION);
+        $this->RegisterPropertyString('FarbeAutarkie', self::COLOR_AUTARKY);
+        $this->RegisterPropertyBoolean('Debug', false);
+
+        $today = date('Y-m-d');
+        $this->RegisterAttributeString(self::ATTR_RANGE, 'day');
+        $this->RegisterAttributeString(self::ATTR_DATE, $today);
+        $this->RegisterAttributeString(self::ATTR_CUSTOM_START, $today);
+        $this->RegisterAttributeString(self::ATTR_CUSTOM_END, $today);
+
+        $visualizationType = version_compare(IPS_GetKernelVersion(), '9.0', '>=')
+            ? 2
+            : 1;
+        $this->SetVisualizationType($visualizationType);
+        $this->RegisterTimer(
+            'Refresh',
+            0,
+            'IPS_RequestAction($_IPS["TARGET"], "Refresh", true);'
+        );
+    }
+
+    public function ApplyChanges(): void
+    {
+        parent::ApplyChanges();
+
+        $today = date('Y-m-d');
+        $defaultRange = $this->ReadPropertyString('Standardzeitraum');
+        if (!in_array($defaultRange, ['day', 'week', 'month', 'year', 'total'], true)) {
+            $defaultRange = 'day';
+        }
+
+        $this->WriteAttributeString(self::ATTR_RANGE, $defaultRange);
+        $this->WriteAttributeString(self::ATTR_DATE, $today);
+        if (!$this->validStoredDate($this->ReadAttributeString(self::ATTR_CUSTOM_START))) {
+            $this->WriteAttributeString(self::ATTR_CUSTOM_START, $today);
+        }
+        if (!$this->validStoredDate($this->ReadAttributeString(self::ATTR_CUSTOM_END))) {
+            $this->WriteAttributeString(self::ATTR_CUSTOM_END, $today);
+        }
+
+        $interval = $this->ReadPropertyInteger('Aktualisierungsintervall');
+        $this->SetTimerInterval('Refresh', max(10, min(3600, $interval)) * 1000);
+
+        if ($this->requiredSourceIdsAreEmpty()) {
+            $this->SetStatus(104);
+        } elseif (!$this->configurationIsValid()) {
+            $this->SetStatus(201);
+        } elseif ($this->archiveId() === 0) {
+            $this->SetStatus(202);
+        } else {
+            $this->SetStatus(102);
+        }
+
+        $this->recalculateAndPush();
+    }
+
+    public function GetVisualizationTile(): string
+    {
+        $path = __DIR__ . '/module.html';
+        $html = @file_get_contents($path);
+        if ($html === false) {
+            return '<div style="padding:12px">Darstellung nicht verfügbar.</div>';
+        }
+
+        try {
+            $initial = json_encode(
+                $this->buildPayload(),
+                JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT | JSON_THROW_ON_ERROR
+            );
+        } catch (Throwable $error) {
+            $initial = '{"hasData":false,"noDataHint":"Darstellung konnte nicht geladen werden."}';
+        }
+
+        return str_replace('__ENELIX_INITIAL_STATE__', $initial, $html);
+    }
+
+    public function GetVisualizationPopup(): string
+    {
+        return $this->GetVisualizationTile();
+    }
+
+    public function RequestAction($Ident, $Value): void
+    {
+        try {
+            switch ((string) $Ident) {
+                case 'SetRange':
+                    $this->setRange((string) $Value);
+                    break;
+                case 'SetDate':
+                    $this->setDate((string) $Value);
+                    break;
+                case 'SetCustomRange':
+                    $this->setCustomRange((string) $Value);
+                    break;
+                case 'Prev':
+                case 'Next':
+                case 'Today':
+                    $this->shiftDate((string) $Ident);
+                    break;
+                case 'Refresh':
+                    break;
+                default:
+                    throw new InvalidArgumentException('Unbekannte Aktion.');
+            }
+
+            $this->recalculateAndPush();
+        } catch (Throwable $error) {
+            $this->debug('Aktion abgewiesen', $error->getMessage());
+        }
+    }
+
+    private function setRange(string $range): void
+    {
+        if (!in_array($range, EnergyChartCalculator::RANGES, true)) {
+            throw new InvalidArgumentException('Unbekannter Zeitraum.');
+        }
+
+        $this->WriteAttributeString(self::ATTR_RANGE, $range);
+    }
+
+    private function setDate(string $date): void
+    {
+        if (!$this->validStoredDate($date)) {
+            throw new InvalidArgumentException('Ungültiges oder zukünftiges Datum.');
+        }
+
+        $this->WriteAttributeString(self::ATTR_DATE, $date);
+    }
+
+    private function setCustomRange(string $json): void
+    {
+        try {
+            $value = json_decode($json, true, 512, JSON_THROW_ON_ERROR);
+        } catch (JsonException $error) {
+            throw new InvalidArgumentException('Ungültiger Datumsbereich.', 0, $error);
+        }
+
+        $start = is_array($value) ? (string) ($value['start'] ?? '') : '';
+        $end = is_array($value) ? (string) ($value['end'] ?? '') : '';
+        if (!$this->validStoredDate($start) || !$this->validStoredDate($end)) {
+            throw new InvalidArgumentException('Ungültiger oder zukünftiger Datumsbereich.');
+        }
+        if ($start > $end) {
+            throw new InvalidArgumentException('Das Startdatum liegt nach dem Enddatum.');
+        }
+
+        $this->WriteAttributeString(self::ATTR_CUSTOM_START, $start);
+        $this->WriteAttributeString(self::ATTR_CUSTOM_END, $end);
+        $this->WriteAttributeString(self::ATTR_RANGE, 'custom');
+    }
+
+    private function shiftDate(string $action): void
+    {
+        $range = $this->ReadAttributeString(self::ATTR_RANGE);
+        if ($range === 'total' || $range === 'custom') {
+            return;
+        }
+
+        if ($action === 'Today') {
+            $this->WriteAttributeString(self::ATTR_DATE, date('Y-m-d'));
+            return;
+        }
+
+        $date = $this->ReadAttributeString(self::ATTR_DATE);
+        $base = strtotime($date . ' 00:00:00');
+        if ($base === false) {
+            $base = strtotime(date('Y-m-d') . ' 00:00:00');
+        }
+
+        $previous = $action === 'Prev';
+        $modifier = [
+            'day' => $previous ? '-1 day' : '+1 day',
+            'week' => $previous ? '-1 week' : '+1 week',
+            'month' => $previous ? 'first day of previous month' : 'first day of next month',
+            'year' => $previous ? 'first day of january previous year' : 'first day of january next year',
+        ][$range] ?? 'today';
+
+        $shifted = strtotime($modifier, $base);
+        if ($shifted === false || $shifted > time()) {
+            $shifted = time();
+        }
+        $this->WriteAttributeString(self::ATTR_DATE, date('Y-m-d', $shifted));
+    }
+
+    private function recalculateAndPush(): void
+    {
+        try {
+            $payload = $this->buildPayload();
+            $this->UpdateVisualizationValue(json_encode($payload, JSON_THROW_ON_ERROR));
+        } catch (Throwable $error) {
+            $this->debug('Aktualisierung fehlgeschlagen', $error->getMessage());
+        }
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function buildPayload(): array
+    {
+        $range = $this->ReadAttributeString(self::ATTR_RANGE);
+        if (!in_array($range, EnergyChartCalculator::RANGES, true)) {
+            $range = $this->ReadPropertyString('Standardzeitraum');
+        }
+        if (!in_array($range, EnergyChartCalculator::RANGES, true)) {
+            $range = 'day';
+        }
+
+        $date = $this->ReadAttributeString(self::ATTR_DATE);
+        if (!$this->validStoredDate($date)) {
+            $date = date('Y-m-d');
+        }
+        $customStart = $this->ReadAttributeString(self::ATTR_CUSTOM_START);
+        $customEnd = $this->ReadAttributeString(self::ATTR_CUSTOM_END);
+        if (!$this->validStoredDate($customStart)) {
+            $customStart = date('Y-m-d');
+        }
+        if (!$this->validStoredDate($customEnd)) {
+            $customEnd = date('Y-m-d');
+        }
+
+        [$start, $end] = EnergyChartCalculator::rangeBounds(
+            $range,
+            $date,
+            $customStart,
+            $customEnd
+        );
+
+        $payload = [
+            'range' => $range,
+            'date' => $date,
+            'customStart' => $customStart,
+            'customEnd' => $customEnd,
+            'tStart' => $start,
+            'tEnd' => $end,
+            'hasData' => false,
+            'noDataHint' => 'Energiezähler konfigurieren.',
+            'colors' => [
+                'selfConsumption' => EnergyChartCalculator::normalizeColor(
+                    $this->ReadPropertyString('FarbeEigenverbrauch'),
+                    self::COLOR_SELF_CONSUMPTION
+                ),
+                'autarky' => EnergyChartCalculator::normalizeColor(
+                    $this->ReadPropertyString('FarbeAutarkie'),
+                    self::COLOR_AUTARKY
+                ),
+            ],
+            'values' => EnergyChartCalculator::metrics(0.0, 0.0, 0.0),
+        ];
+
+        if (!$this->configurationIsValid()) {
+            return $payload;
+        }
+
+        $archiveId = $this->archiveId();
+        if ($archiveId === 0) {
+            $payload['noDataHint'] = 'Das IP-Symcon-Archiv ist nicht verfügbar.';
+            return $payload;
+        }
+
+        $factor = $this->ReadPropertyFloat('Zaehlerfaktor');
+        $total = $range === 'total';
+        $production = $this->readEnergy(
+            $archiveId,
+            $this->ReadPropertyInteger('ProduktionZaehlerID'),
+            $start,
+            $end,
+            $total
+        );
+        $feedIn = $this->readEnergy(
+            $archiveId,
+            $this->ReadPropertyInteger('EinspeisungZaehlerID'),
+            $start,
+            $end,
+            $total
+        );
+        $grid = $this->readEnergy(
+            $archiveId,
+            $this->ReadPropertyInteger('NetzbezugZaehlerID'),
+            $start,
+            $end,
+            $total
+        );
+
+        $consumption = null;
+        $consumptionAvailable = true;
+        $consumptionId = $this->ReadPropertyInteger('VerbrauchZaehlerID');
+        if ($consumptionId > 0) {
+            $consumptionResult = $this->readEnergy($archiveId, $consumptionId, $start, $end, $total);
+            $consumptionAvailable = $consumptionResult['available'];
+            if ($consumptionAvailable) {
+                $consumption = $consumptionResult['value'] * $factor;
+            }
+        }
+
+        $payload['hasData'] = $production['available']
+            && $feedIn['available']
+            && $grid['available']
+            && $consumptionAvailable;
+        $payload['values'] = EnergyChartCalculator::metrics(
+            $production['value'] * $factor,
+            $feedIn['value'] * $factor,
+            $grid['value'] * $factor,
+            $consumption
+        );
+
+        if (!$payload['hasData']) {
+            $lastLog = max(
+                $this->lastLogTimestamp($archiveId, $this->ReadPropertyInteger('ProduktionZaehlerID')),
+                $this->lastLogTimestamp($archiveId, $this->ReadPropertyInteger('EinspeisungZaehlerID')),
+                $this->lastLogTimestamp($archiveId, $this->ReadPropertyInteger('NetzbezugZaehlerID')),
+                $this->lastLogTimestamp($archiveId, $consumptionId)
+            );
+            $payload['noDataHint'] = $lastLog > 0
+                ? 'Letzter Archivwert: ' . date('d.m.Y H:i', $lastLog)
+                : 'Für diesen Zeitraum sind keine Archivwerte vorhanden.';
+        } else {
+            $payload['noDataHint'] = '';
+        }
+
+        return $payload;
+    }
+
+    /**
+     * @return array{value: float, available: bool}
+     */
+    private function readEnergy(
+        int $archiveId,
+        int $variableId,
+        int $start,
+        int $end,
+        bool $total
+    ): array {
+        if (!$this->isNumericVariable($variableId)) {
+            return ['value' => 0.0, 'available' => false];
+        }
+
+        if ($total) {
+            $value = GetValue($variableId);
+            return [
+                'value' => is_numeric($value) ? max(0.0, (float) $value) : 0.0,
+                'available' => is_numeric($value),
+            ];
+        }
+
+        $before = @AC_GetLoggedValues($archiveId, $variableId, 0, $start, 1);
+        $within = @AC_GetLoggedValues($archiveId, $variableId, $start, min($end, time()), 0);
+        $before = is_array($before) ? $before : [];
+        $within = is_array($within) ? $within : [];
+        usort($before, static fn (array $left, array $right): int =>
+            ((int) $left['TimeStamp']) <=> ((int) $right['TimeStamp'])
+        );
+        usort($within, static fn (array $left, array $right): int =>
+            ((int) $left['TimeStamp']) <=> ((int) $right['TimeStamp'])
+        );
+
+        if ($before === [] && $within === []) {
+            return ['value' => 0.0, 'available' => false];
+        }
+
+        $startValue = $before !== []
+            ? (float) $before[count($before) - 1]['Value']
+            : (float) $within[0]['Value'];
+        $endValue = $within !== []
+            ? (float) $within[count($within) - 1]['Value']
+            : $startValue;
+
+        return [
+            'value' => max(0.0, $endValue - $startValue),
+            'available' => true,
+        ];
+    }
+
+    private function lastLogTimestamp(int $archiveId, int $variableId): int
+    {
+        if (!$this->isNumericVariable($variableId)) {
+            return 0;
+        }
+
+        $values = @AC_GetLoggedValues($archiveId, $variableId, 0, time(), 1);
+        return is_array($values) && isset($values[0]['TimeStamp'])
+            ? (int) $values[0]['TimeStamp']
+            : 0;
+    }
+
+    private function configurationIsValid(): bool
+    {
+        $requiredIds = [
+            $this->ReadPropertyInteger('ProduktionZaehlerID'),
+            $this->ReadPropertyInteger('EinspeisungZaehlerID'),
+            $this->ReadPropertyInteger('NetzbezugZaehlerID'),
+        ];
+        foreach ($requiredIds as $variableId) {
+            if (!$this->isNumericVariable($variableId)) {
+                return false;
+            }
+        }
+
+        $consumptionId = $this->ReadPropertyInteger('VerbrauchZaehlerID');
+        if ($consumptionId > 0 && !$this->isNumericVariable($consumptionId)) {
+            return false;
+        }
+
+        return $this->ReadPropertyFloat('Zaehlerfaktor') > 0.0
+            && $this->ReadPropertyInteger('Aktualisierungsintervall') >= 10
+            && $this->ReadPropertyInteger('Aktualisierungsintervall') <= 3600
+            && in_array(
+                $this->ReadPropertyString('Standardzeitraum'),
+                ['day', 'week', 'month', 'year', 'total'],
+                true
+            )
+            && EnergyChartCalculator::normalizeColor(
+                $this->ReadPropertyString('FarbeEigenverbrauch'),
+                ''
+            ) !== ''
+            && EnergyChartCalculator::normalizeColor(
+                $this->ReadPropertyString('FarbeAutarkie'),
+                ''
+            ) !== '';
+    }
+
+    private function requiredSourceIdsAreEmpty(): bool
+    {
+        return $this->ReadPropertyInteger('ProduktionZaehlerID') === 0
+            && $this->ReadPropertyInteger('EinspeisungZaehlerID') === 0
+            && $this->ReadPropertyInteger('NetzbezugZaehlerID') === 0;
+    }
+
+    private function archiveId(): int
+    {
+        $archives = IPS_GetInstanceListByModuleID(self::ARCHIVE_MODULE_ID);
+        return isset($archives[0]) ? (int) $archives[0] : 0;
+    }
+
+    private function isNumericVariable(int $variableId): bool
+    {
+        if ($variableId <= 0 || !IPS_VariableExists($variableId)) {
+            return false;
+        }
+
+        $variable = IPS_GetVariable($variableId);
+        return in_array((int) ($variable['VariableType'] ?? -1), [1, 2], true);
+    }
+
+    private function validStoredDate(string $date): bool
+    {
+        return EnergyChartCalculator::isValidDate($date)
+            && $date <= date('Y-m-d');
+    }
+
+    private function debug(string $title, string $message): void
+    {
+        if ($this->ReadPropertyBoolean('Debug')) {
+            $this->SendDebug($title, $message, 0);
+        }
+    }
+}

README.md

@@ -4,22 +4,86 @@ Unabhaengige Zusatzmodule fuer IP-Symcon. Dieses Repository ist nicht vom Enelix
 
 ## Status
 
-Das Repository befindet sich im Aufbau. Noch nicht gepruefte Module werden nicht als leere Platzhalter angelegt.
+Version 0.1 Build 1 ist die erste Beta fuer kontrollierte Anlagen- und
+Feldtests. Verbrauchskostenreport, Virtuelle Batterie, CC100 Hardware,
+Energiediagramm, VGT-Schnittstelle und Shelly Modul sind als installierbare
+IP-Symcon-Module enthalten. Produktiver Einsatz setzt eine anlagenspezifische
+Pruefung und Sicherung voraus.
 
-## Geplante Module
+## Module
 
-- Abrechnungsmanager
-- Virtuelle Batterie
-- CC100 Hardware
-- Energiediagramm
-- VGT-Schnittstelle
-- Shelly Modul
+- Verbrauchskostenreport (implementiert)
+- Virtuelle Batterie (implementiert)
+- CC100 Hardware (implementiert)
+- Energiediagramm (implementiert)
+- VGT-Schnittstelle (implementiert)
+- Shelly Modul (implementiert)
+
+Die vollständigen Tabellen mit Properties, Variablen, Verhalten und offenen
+Punkten stehen in der [Modulübersicht](docs/module/README.md).
+
+Prognose, Lizenzierung und Störüberwachung sind keine Module dieses
+Repositories. Die Utils-Module bleiben auch untereinander unabhängig.
+
+## Release-Hinweise
+
+Die Aenderungen der ersten Beta stehen im [Changelog](CHANGELOG.md).
 
 ## Voraussetzungen
 
 - IP-Symcon ab Version 8.0
+- Netzwerkzugriff der IP-Symcon-Installation auf das Gitea-Repository
 - PHP ab Version 8.0 fuer die Entwicklungstests
 
+## Installation in IP-Symcon
+
+Das Repository wird über die IP-Symcon-Modulverwaltung installiert:
+
+1. In der Verwaltung `Module` öffnen und ein neues Modul hinzufügen.
+2. Als Repository-URL `https://git.belevo.ch/ENELIX/Enelix-Utils.git` eintragen.
+3. Den zur Umgebung passenden Branch auswählen.
+4. Prüfen, dass `Enelix Utils` ohne Warnsymbol angezeigt wird und URL sowie
+   Branch in der Modulübersicht sichtbar sind.
+
+Zugangsdaten werden außerhalb des Repositories in der Laufzeitumgebung
+konfiguriert. Tokens oder Passwörter gehören weder in die Repository-URL noch
+in Konfigurationsdateien oder Logs.
+
+| Git-Branch | IP-Symcon-Kanal |
+| --- | --- |
+| `main` | Stable |
+| `beta` | Beta |
+| `develop` | Testing |
+
+Für Entwicklung und Integrationstests ist `develop` zu verwenden. Das
+Repository darf nicht manuell nach `data/modules/Enelix-Utils` kopiert werden,
+da IP-Symcon sonst URL, Branch und Aktualisierungsstatus nicht verwalten kann.
+
+## Aktualisierung und Prüfung
+
+Aktualisierungen werden ausschließlich über die IP-Symcon-Modulverwaltung
+bezogen. Nach einem Branchwechsel oder Update müssen alle implementierten
+Module geladen sein:
+
+- `CC100 Hardware`
+- `Energiediagramm`
+- `Shelly Modul`
+- `VGT-Schnittstelle`
+- `Verbrauchskostenreport`
+- `Virtuelle Batterie`
+
+Ein korrekter Zustand zeigt die Repository-URL, den ausgewählten Branch und
+kein Warnsymbol bei `Enelix Utils`.
+
+## Fehlerbehebung
+
+Wenn URL und Branch fehlen oder ein Warnsymbol erscheint, wurde die Bibliothek
+möglicherweise nur als Ordner kopiert. In diesem Fall vor Änderungen bestehende
+Modulinstanzen und Konfigurationen sichern. Anschließend die fehlerhafte
+Bibliothek über die Modulverwaltung entfernen und mit der oben genannten URL
+neu installieren. Das manuelle Löschen des Modulordners ist kein regulärer
+Installations- oder Aktualisierungsweg.
+
 ## Entwicklung und Tests
 
 ```bash
@@ -27,11 +91,8 @@ composer install
 composer check
 ```
 
-Neue oder geaenderte Funktionen werden zusammen mit ihren PHPUnit-Tests eingecheckt. Die CI-Pruefung muss vor der Uebernahme in einen Freigabebranch erfolgreich sein.
-
-| Git-Branch | IP-Symcon-Kanal |
-| --- | --- |
-| `main` | Stable |
-| `beta` | Beta |
-| `develop` | Testing |
-
+Neue oder geaenderte Funktionen werden zusammen mit ihren PHPUnit-Tests eingecheckt.
+Jedes Modul besitzt zusätzlich einen eigenständigen Laufzeittest für
+IP-Symcon 8.x. Einzel-, Änderungs- und Gesamtläufe sowie Cleanup und Berichte
+sind im [Testleitfaden](docs/testing/README.md) beschrieben. Die CI-Pruefung
+muss vor der Uebernahme in einen Freigabebranch erfolgreich sein.

ShellyModul/README.md

@@ -0,0 +1,106 @@
+# Shelly Modul
+
+Das Modul bindet Shelly-NG-Geräte der Generationen 2, 3 und 4 über MQTT/RPC
+in IP-Symcon ein. Es erkennt bekannte und zukünftige Komponenten dynamisch
+und benötigt keine Abhängigkeit zum Enelix EMS.
+
+## Voraussetzungen
+
+- IP-Symcon ab Version 8.0
+- ein eingerichteter IP-Symcon MQTT Server oder MQTT Client
+- ein Shelly Gen2+-Gerät mit aktivierter MQTT-Verbindung
+- aktivierte RPC-Statusmeldungen (`rpc_ntf`)
+- optional aktivierte vollständige Statusmeldungen (`status_ntf`)
+
+Shelly-Geräte der ersten Generation mit `shellies/...`-Topics verwenden ein
+anderes Protokoll und werden von diesem Modul nicht verarbeitet.
+
+## Freie MQTT-Namen
+
+MQTT-Client-ID, Brokername, Benutzername und Kennwort werden ausschliesslich
+im MQTT-Gateway beziehungsweise im Shelly konfiguriert. Das Modul wertet
+diese Werte nicht aus. Der Shelly-`topic_prefix` darf frei gewählt werden und
+auch mehrere Ebenen enthalten, zum Beispiel `symcon` oder
+`gebaeude/etage/aktor`.
+
+Das Modul erkennt die Geräte-Topics anhand ihrer Endung:
+
+| Topic | Verwendung |
+| --- | --- |
+| `<Prefix>/online` | Online-Status |
+| `<Prefix>/events/rpc` | `NotifyStatus` und `NotifyEvent` |
+| `<Prefix>/status/<Komponente>` | vollständiger Komponentenstatus |
+| `<Prefix>/status` | vollständiger Gerätestatus |
+| `<Prefix>/announce` | Geräteinformationen |
+
+Ein optionaler Topic-Filter kann in den Moduleinstellungen aktiviert werden.
+Ohne aktivierten Filter werden alle gültigen Shelly-RPC-Topics verarbeitet.
+
+## Datenpunktauswahl
+
+In der Konfiguration kann für jede Gruppe festgelegt werden, ob neue
+Variablen angelegt und vorhandene Variablen aktualisiert werden:
+
+- Online-Status und Geräteinformationen
+- Eingänge und Eingangsereignisse
+- Schaltausgänge
+- Rollladen und Beschattung
+- Licht, Dimmer und Farbe
+- Leistung, Spannung, Strom, Energie, Frequenz und Leistungsfaktor einzeln
+- Temperatur, Feuchte, Helligkeit und Batterie einzeln
+- weitere Zähler- und Sensorwerte
+- System- und Netzwerkdaten
+- unbekannte und zukünftige Komponenten
+
+Systemdaten und unbekannte Datenpunkte sind standardmässig deaktiviert, damit
+nicht unerwartet sehr viele Variablen entstehen. Bereits angelegte Variablen
+werden beim Abwählen einer Gruppe nicht gelöscht.
+
+## Dynamische Variablen
+
+Boolesche Werte werden als Boolean, Zähler und Zeitangaben als Integer,
+Messwerte als Float und Texte als String angelegt. Listen wie Fehlercodes oder
+Minutenwerte werden vollständig als JSON-String gespeichert. `null` wird
+ignoriert, da IP-Symcon keinen Null-Variablentyp besitzt.
+
+Bekannte Datenpunkte erhalten lesbare Namen und passende Standardprofile,
+sofern das Profil in IP-Symcon vorhanden ist. Unbekannte Felder werden über
+ihren Komponenten- und Datenpfad stabil und kollisionsarm identifiziert.
+
+## Ausgänge schalten
+
+Erkannte `switch:<n>.output`-Variablen bleiben bedienbar. Eine Bedienung
+veröffentlicht `Switch.Set` auf `<Prefix>/rpc`. Der Variablenwert wird erst
+mit der nächsten Gerätemeldung aktualisiert.
+
+```php
+SHELLY_SetOutput($instanceID, 'symcon', 0, true);
+SHELLY_SetOutput($instanceID, 'gebaeude/etage/aktor', 1, false);
+```
+
+Andere Komponenten werden derzeit vollständig eingelesen, aber nicht pauschal
+schreibbar gemacht. Ihre RPC-Befehle unterscheiden sich fachlich, etwa bei
+Cover-, Light-, RGB- oder Thermostat-Komponenten.
+
+## Einrichtung
+
+1. Instanz `Shelly Modul` aus Enelix Utils anlegen.
+2. Internen MQTT Server oder kompatiblen MQTT Client als Gateway verbinden.
+3. MQTT am Shelly aktivieren und RPC-Statusmeldungen einschalten.
+4. Gewünschte Datenpunktgruppen auswählen und Änderungen übernehmen.
+5. Am Gerät einen Statuswechsel auslösen.
+
+Bei einem externen MQTT-Broker muss der MQTT Client die passenden Topics
+abonnieren. Zugangsdaten gehören niemals in die Modulkonfiguration.
+
+## Migration
+
+Der bisherige Wert `DeviceTopicPrefix = shelly` bleibt erhalten, wird aber nur
+noch ausgewertet, wenn `UseDeviceTopicFilter` aktiviert ist. Bestehende
+Online-, Typ-, Input-, Output- und Temperaturvariablen werden weiterverwendet.
+
+## Diagnose
+
+Mit `Debug` protokolliert die Instanz empfangene und gesendete MQTT-Pakete
+sowie ungültige JSON-Nutzdaten. Für die Fehlersuche sollte Debug nur
+vorübergehend aktiviert werden, weil Statusmeldungen umfangreich sein können.

ShellyModul/form.json

@@ -0,0 +1,55 @@
+{
+  "elements": [
+    {
+      "type": "Label",
+      "caption": "Verarbeitet Shelly Gen2+-Daten unabhängig von MQTT-Client-ID und frei wählbarem Topic-Präfix."
+    },
+    {
+      "type": "CheckBox",
+      "name": "UseDeviceTopicFilter",
+      "caption": "Nur Geräte-Topics mit folgendem Präfix verarbeiten"
+    },
+    {
+      "type": "ValidationTextBox",
+      "name": "DeviceTopicPrefix",
+      "caption": "Optionaler Geräte-Topic-Filter"
+    },
+    {
+      "type": "ExpansionPanel",
+      "caption": "Zu erzeugende Datenpunktgruppen",
+      "items": [
+        {"type": "CheckBox", "name": "CreateOnline", "caption": "Online-Status"},
+        {"type": "CheckBox", "name": "CreateDeviceInfo", "caption": "Geräteinformationen"},
+        {"type": "CheckBox", "name": "CreateInputs", "caption": "Eingänge und Eingangsereignisse"},
+        {"type": "CheckBox", "name": "CreateSwitches", "caption": "Schaltausgänge"},
+        {"type": "CheckBox", "name": "CreateCovers", "caption": "Rollladen und Beschattung"},
+        {"type": "CheckBox", "name": "CreateLights", "caption": "Licht, Dimmer und Farbe"},
+        {"type": "CheckBox", "name": "CreatePower", "caption": "Leistung"},
+        {"type": "CheckBox", "name": "CreateVoltage", "caption": "Spannung"},
+        {"type": "CheckBox", "name": "CreateCurrent", "caption": "Strom"},
+        {"type": "CheckBox", "name": "CreateEnergy", "caption": "Energiezähler"},
+        {"type": "CheckBox", "name": "CreateFrequency", "caption": "Frequenz"},
+        {"type": "CheckBox", "name": "CreatePowerFactor", "caption": "Leistungsfaktor"},
+        {"type": "CheckBox", "name": "CreateMeterDetails", "caption": "Weitere Zählerdaten"},
+        {"type": "CheckBox", "name": "CreateTemperature", "caption": "Temperatur"},
+        {"type": "CheckBox", "name": "CreateHumidity", "caption": "Luftfeuchtigkeit"},
+        {"type": "CheckBox", "name": "CreateIlluminance", "caption": "Helligkeit und Beleuchtungsstärke"},
+        {"type": "CheckBox", "name": "CreateBattery", "caption": "Batterie und Versorgung"},
+        {"type": "CheckBox", "name": "CreateEnvironment", "caption": "Weitere Sensorwerte"},
+        {"type": "CheckBox", "name": "CreateSystem", "caption": "System- und Netzwerkdaten"},
+        {"type": "CheckBox", "name": "CreateOther", "caption": "Unbekannte und zukünftige Datenpunkte"}
+      ]
+    },
+    {
+      "type": "CheckBox",
+      "name": "Debug",
+      "caption": "Debug-Ausgaben aktivieren"
+    }
+  ],
+  "actions": [
+    {
+      "type": "Label",
+      "caption": "Nicht gewählte Gruppen werden nicht neu angelegt oder aktualisiert. Bereits vorhandene Variablen werden nicht gelöscht."
+    }
+  ]
+}

ShellyModul/libs/ShellyParser.php

@@ -0,0 +1,272 @@
+<?php
+
+declare(strict_types=1);
+
+final class ShellyParser
+{
+    /**
+     * @return null|array{deviceTopic: string, kind: string, component: ?string}
+     */
+    public static function parseTopic(string $topic): ?array
+    {
+        $topic = trim($topic, '/');
+        if ($topic === '') {
+            return null;
+        }
+
+        $patterns = [
+            'rpc' => '#^(.+)/events/rpc$#',
+            'component_status' => '#^(.+)/status/([^/]+)$#',
+            'status' => '#^(.+)/status$#',
+            'online' => '#^(.+)/online$#',
+            'announce' => '#^(.+)/announce$#',
+        ];
+
+        foreach ($patterns as $kind => $pattern) {
+            if (preg_match($pattern, $topic, $matches) !== 1) {
+                continue;
+            }
+
+            return [
+                'deviceTopic' => $matches[1],
+                'kind' => $kind,
+                'component' => $matches[2] ?? null,
+            ];
+        }
+
+        return null;
+    }
+
+    public static function extractType(string $source): string
+    {
+        if (preg_match('/^shelly([a-z0-9]+)-/i', trim($source), $matches) !== 1) {
+            return 'unknown';
+        }
+
+        return strtolower($matches[1]);
+    }
+
+    /**
+     * @return array<int, array{component: string, path: string, value: bool|int|float|string}>
+     */
+    public static function pointsFromRpc(array $rpc): array
+    {
+        $method = $rpc['method'] ?? null;
+        $params = $rpc['params'] ?? null;
+        if (!is_string($method) || !is_array($params)) {
+            return [];
+        }
+
+        if ($method === 'NotifyStatus') {
+            return self::pointsFromStatus($params);
+        }
+        if ($method === 'NotifyEvent') {
+            return self::pointsFromEvents($params);
+        }
+
+        return [];
+    }
+
+    /**
+     * @return array<int, array{component: string, path: string, value: bool|int|float|string}>
+     */
+    public static function pointsFromStatus(array $status): array
+    {
+        $points = [];
+        foreach ($status as $component => $value) {
+            if ($component === 'ts' && (is_int($value) || is_float($value))) {
+                $points[] = self::point('meta', 'ts', $value);
+                continue;
+            }
+            if (!is_string($component) || !is_array($value)) {
+                continue;
+            }
+
+            self::flatten($component, $value, '', $points);
+        }
+
+        return $points;
+    }
+
+    /**
+     * @return array<int, array{component: string, path: string, value: bool|int|float|string}>
+     */
+    public static function pointsFromComponent(string $component, array $status): array
+    {
+        $points = [];
+        self::flatten($component, $status, '', $points);
+
+        return $points;
+    }
+
+    /**
+     * @return array<int, array{component: string, path: string, value: bool|int|float|string}>
+     */
+    public static function pointsFromAnnounce(array $announce): array
+    {
+        $points = [];
+        self::flatten('device', $announce, '', $points);
+
+        return $points;
+    }
+
+    /**
+     * @return array<int, array{component: string, path: string, value: bool|int|float|string}>
+     */
+    private static function pointsFromEvents(array $params): array
+    {
+        $points = [];
+        $events = $params['events'] ?? [];
+        if (!is_array($events)) {
+            return $points;
+        }
+
+        foreach ($events as $event) {
+            if (!is_array($event)) {
+                continue;
+            }
+            $component = $event['component'] ?? 'event';
+            if (!is_string($component) || $component === '') {
+                $component = 'event';
+            }
+            unset($event['component']);
+            self::flatten($component, $event, 'event', $points);
+        }
+
+        return $points;
+    }
+
+    /**
+     * @param array<int, array{component: string, path: string, value: bool|int|float|string}> $points
+     */
+    private static function flatten(string $component, array $data, string $prefix, array &$points): void
+    {
+        foreach ($data as $key => $value) {
+            $key = (string) $key;
+            $path = $prefix === '' ? $key : $prefix . '.' . $key;
+            if ($value === null) {
+                continue;
+            }
+
+            if (is_array($value)) {
+                if (self::isList($value)) {
+                    $json = json_encode($value, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
+                    if ($json !== false) {
+                        $points[] = self::point($component, $path, $json);
+                    }
+                } else {
+                    self::flatten($component, $value, $path, $points);
+                }
+                continue;
+            }
+
+            if (is_bool($value) || is_int($value) || is_float($value) || is_string($value)) {
+                $points[] = self::point($component, $path, $value);
+            }
+        }
+    }
+
+    /**
+     * @param bool|int|float|string $value
+     * @return array{component: string, path: string, value: bool|int|float|string}
+     */
+    private static function point(string $component, string $path, $value): array
+    {
+        return ['component' => $component, 'path' => $path, 'value' => $value];
+    }
+
+    private static function isList(array $value): bool
+    {
+        $expectedKey = 0;
+        foreach ($value as $key => $_) {
+            if ($key !== $expectedKey) {
+                return false;
+            }
+            ++$expectedKey;
+        }
+
+        return true;
+    }
+
+    public static function groupForPoint(string $component, string $path): string
+    {
+        $componentType = strtolower(explode(':', $component, 2)[0]);
+        $path = strtolower($path);
+
+        if (in_array($componentType, ['meta', 'device'], true)) {
+            return 'device';
+        }
+        if ($componentType === 'input') {
+            return 'inputs';
+        }
+        if (preg_match('/(^|\.)(aenergy|ret_aenergy|energy|[a-z_]+_energy|total_act|total_act_ret)(\.|$)/', $path) === 1) {
+            return 'energy';
+        }
+        if (preg_match('/(^|\.)(apower|aprtpower|power|[a-z_]+_power)(\.|$)/', $path) === 1) {
+            return 'power';
+        }
+        if (preg_match('/(^|\.)(voltage|[a-z]_voltage)(\.|$)/', $path) === 1) {
+            return 'voltage';
+        }
+        if (preg_match('/(^|\.)(current|[a-z]_current)(\.|$)/', $path) === 1) {
+            return 'current';
+        }
+        if (preg_match('/(^|\.)(freq|[a-z]_freq)(\.|$)/', $path) === 1) {
+            return 'frequency';
+        }
+        if (preg_match('/(^|\.)(pf|[a-z]_pf)(\.|$)/', $path) === 1) {
+            return 'power_factor';
+        }
+        if (preg_match('/(^|\.)(temperature|tc|tf)(\.|$)/', $path) === 1 || $componentType === 'temperature') {
+            return 'temperature';
+        }
+        if (preg_match('/(^|\.)(humidity|rh)(\.|$)/', $path) === 1 || $componentType === 'humidity') {
+            return 'humidity';
+        }
+        if (preg_match('/(^|\.)(illuminance|lux)(\.|$)/', $path) === 1 || $componentType === 'illuminance') {
+            return 'illuminance';
+        }
+        if (preg_match('/(^|\.)(battery)(\.|$)/', $path) === 1 || $componentType === 'devicepower') {
+            return 'battery';
+        }
+        if ($componentType === 'switch') {
+            return 'switches';
+        }
+        if ($componentType === 'cover') {
+            return 'covers';
+        }
+        if (in_array($componentType, ['light', 'rgb', 'rgbw', 'cct', 'rgbcct'], true)) {
+            return 'lights';
+        }
+        if (in_array($componentType, ['pm1', 'em', 'em1', 'emdata'], true)) {
+            return 'meters';
+        }
+        if (in_array($componentType, ['smoke', 'flood', 'gas'], true)) {
+            return 'environment';
+        }
+        if (in_array($componentType, ['sys', 'wifi', 'eth', 'mqtt', 'cloud', 'ws', 'ble', 'modbus'], true)) {
+            return 'system';
+        }
+
+        return 'other';
+    }
+
+    /**
+     * @param bool|int|float|string $value
+     */
+    public static function variableType($value, string $path): int
+    {
+        if (is_bool($value)) {
+            return 0;
+        }
+        if (is_string($value)) {
+            return 3;
+        }
+        if ((is_int($value) || is_float($value))
+            && preg_match('/(^|\.)(id|ts|uptime|unixtime|[a-z_]+_ts|[a-z_]+_rev|rssi)$/i', $path) === 1) {
+            return 1;
+        }
+
+        return 2;
+    }
+}

ShellyModul/module.json

@@ -0,0 +1,18 @@
+{
+  "id": "{21D82EDB-AC8E-4F3D-9FEE-D20BCAFC1C33}",
+  "name": "Shelly Modul",
+  "type": 3,
+  "vendor": "Belevo AG",
+  "aliases": [
+    "Shelly MQTT Parser"
+  ],
+  "parentRequirements": [
+    "{043EA491-0325-4ADD-8FC2-A30C8EEB4D3F}"
+  ],
+  "childRequirements": [],
+  "implemented": [
+    "{7F7632D9-FA40-4F38-8DEA-C83CD4325A32}"
+  ],
+  "prefix": "SHELLY",
+  "url": ""
+}

ShellyModul/module.php

@@ -0,0 +1,505 @@
+<?php
+
+declare(strict_types=1);
+
+require_once __DIR__ . '/libs/ShellyParser.php';
+
+class ShellyModul extends IPSModule
+{
+    private const MQTT_SERVER_MODULE_ID = '{C6D2AEB3-6E1F-4B2E-8E69-3A1A00246850}';
+    private const MQTT_TX_DATA_ID = '{043EA491-0325-4ADD-8FC2-A30C8EEB4D3F}';
+
+    private const GROUP_PROPERTIES = [
+        'device' => 'CreateDeviceInfo',
+        'inputs' => 'CreateInputs',
+        'switches' => 'CreateSwitches',
+        'covers' => 'CreateCovers',
+        'lights' => 'CreateLights',
+        'power' => 'CreatePower',
+        'voltage' => 'CreateVoltage',
+        'current' => 'CreateCurrent',
+        'energy' => 'CreateEnergy',
+        'frequency' => 'CreateFrequency',
+        'power_factor' => 'CreatePowerFactor',
+        'meters' => 'CreateMeterDetails',
+        'temperature' => 'CreateTemperature',
+        'humidity' => 'CreateHumidity',
+        'illuminance' => 'CreateIlluminance',
+        'battery' => 'CreateBattery',
+        'environment' => 'CreateEnvironment',
+        'system' => 'CreateSystem',
+        'other' => 'CreateOther',
+    ];
+
+    public function Create()
+    {
+        parent::Create();
+
+        $this->RegisterPropertyBoolean('UseDeviceTopicFilter', false);
+        $this->RegisterPropertyString('DeviceTopicPrefix', 'shelly');
+        $this->RegisterPropertyBoolean('CreateOnline', true);
+        $this->RegisterPropertyBoolean('CreateDeviceInfo', true);
+        $this->RegisterPropertyBoolean('CreateInputs', true);
+        $this->RegisterPropertyBoolean('CreateSwitches', true);
+        $this->RegisterPropertyBoolean('CreateCovers', true);
+        $this->RegisterPropertyBoolean('CreateLights', true);
+        $this->RegisterPropertyBoolean('CreatePower', true);
+        $this->RegisterPropertyBoolean('CreateVoltage', true);
+        $this->RegisterPropertyBoolean('CreateCurrent', true);
+        $this->RegisterPropertyBoolean('CreateEnergy', true);
+        $this->RegisterPropertyBoolean('CreateFrequency', true);
+        $this->RegisterPropertyBoolean('CreatePowerFactor', true);
+        $this->RegisterPropertyBoolean('CreateMeterDetails', true);
+        $this->RegisterPropertyBoolean('CreateTemperature', true);
+        $this->RegisterPropertyBoolean('CreateHumidity', true);
+        $this->RegisterPropertyBoolean('CreateIlluminance', true);
+        $this->RegisterPropertyBoolean('CreateBattery', true);
+        $this->RegisterPropertyBoolean('CreateEnvironment', true);
+        $this->RegisterPropertyBoolean('CreateSystem', false);
+        $this->RegisterPropertyBoolean('CreateOther', false);
+        $this->RegisterPropertyBoolean('Debug', false);
+        $this->ConnectParent(self::MQTT_SERVER_MODULE_ID);
+    }
+
+    public function ApplyChanges()
+    {
+        parent::ApplyChanges();
+    }
+
+    public function ReceiveData($JSONString)
+    {
+        try {
+            $data = json_decode((string) $JSONString, true, 512, JSON_THROW_ON_ERROR);
+        } catch (JsonException $exception) {
+            $this->debug('Ungültiges MQTT-Datenpaket', $exception->getMessage());
+            return;
+        }
+
+        if (!is_array($data) || (int) ($data['PacketType'] ?? 0) !== 3) {
+            return;
+        }
+
+        $topic = $data['Topic'] ?? null;
+        $payload = $data['Payload'] ?? null;
+        if (!is_string($topic) || !is_string($payload)) {
+            return;
+        }
+
+        $topicInfo = ShellyParser::parseTopic($topic);
+        if ($topicInfo === null || !$this->isAcceptedDeviceTopic($topicInfo['deviceTopic'])) {
+            return;
+        }
+
+        $this->debug('MQTT empfangen', $topic . ' -> ' . $payload);
+        $deviceTopic = $topicInfo['deviceTopic'];
+
+        if ($topicInfo['kind'] === 'online') {
+            $this->handleOnline($deviceTopic, $payload);
+            return;
+        }
+
+        $decoded = $this->decodePayload($payload);
+        if ($decoded === null) {
+            return;
+        }
+
+        if ($topicInfo['kind'] === 'rpc') {
+            $this->handleRpc($deviceTopic, $decoded);
+        } elseif ($topicInfo['kind'] === 'component_status' && $topicInfo['component'] !== null) {
+            $this->updatePoints($deviceTopic, ShellyParser::pointsFromComponent($topicInfo['component'], $decoded));
+        } elseif ($topicInfo['kind'] === 'status') {
+            $this->updatePoints($deviceTopic, ShellyParser::pointsFromStatus($decoded));
+        } elseif ($topicInfo['kind'] === 'announce') {
+            $this->updatePoints($deviceTopic, ShellyParser::pointsFromAnnounce($decoded));
+        }
+    }
+
+    public function RequestAction($Ident, $Value)
+    {
+        $parts = explode(':', (string) $Ident, 2);
+        if (count($parts) !== 2 || !ctype_digit($parts[0])) {
+            throw new InvalidArgumentException('Ungültige Shelly-Aktion: ' . (string) $Ident);
+        }
+
+        $folderID = (int) $parts[0];
+        $variableIdent = $parts[1];
+        if (!IPS_ObjectExists($folderID) || IPS_GetParent($folderID) !== $this->InstanceID) {
+            throw new InvalidArgumentException('Der Geräteordner gehört nicht zu dieser Instanz.');
+        }
+        if (preg_match('/_output_(\d+)$/', $variableIdent, $matches) !== 1) {
+            throw new InvalidArgumentException('Unbekannter Shelly-Ausgang: ' . $variableIdent);
+        }
+
+        $variableID = @IPS_GetObjectIDByIdent($variableIdent, $folderID);
+        if ($variableID === false || !IPS_VariableExists($variableID)) {
+            throw new InvalidArgumentException('Die Ausgangsvariable wurde nicht gefunden.');
+        }
+
+        $this->SetOutput(IPS_GetName($folderID), (int) $matches[1], (bool) $Value);
+    }
+
+    public function SetOutput(string $DeviceTopic, int $Output, bool $Value): void
+    {
+        if (!$this->isAcceptedDeviceTopic($DeviceTopic)) {
+            throw new InvalidArgumentException('Das Geräte-Topic ist ungültig oder entspricht nicht dem aktiven Filter.');
+        }
+        if ($Output < 0) {
+            throw new InvalidArgumentException('Der Ausgangsindex darf nicht negativ sein.');
+        }
+
+        $payload = json_encode([
+            'id' => random_int(1, 2147483647),
+            'src' => 'enelix-symcon-' . $this->InstanceID,
+            'method' => 'Switch.Set',
+            'params' => ['id' => $Output, 'on' => $Value],
+        ], JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR);
+
+        $this->publish($DeviceTopic . '/rpc', $payload);
+    }
+
+    private function decodePayload(string $payload): ?array
+    {
+        try {
+            $decoded = json_decode($payload, true, 512, JSON_THROW_ON_ERROR);
+        } catch (JsonException $exception) {
+            $this->debug('Ungültige Shelly-Nutzdaten', $exception->getMessage());
+            return null;
+        }
+
+        return is_array($decoded) ? $decoded : null;
+    }
+
+    private function handleOnline(string $deviceTopic, string $payload): void
+    {
+        if (!$this->ReadPropertyBoolean('CreateOnline')) {
+            return;
+        }
+
+        $value = $this->toBoolean($payload);
+        if ($value === null) {
+            $this->debug('Online-Status ignoriert', $payload);
+            return;
+        }
+
+        $variableID = $this->ensureVariable($deviceTopic, 'online', 'Online', 0, '', 10);
+        if ($variableID > 0) {
+            SetValue($variableID, $value);
+        }
+    }
+
+    private function handleRpc(string $deviceTopic, array $rpc): void
+    {
+        $source = $rpc['src'] ?? '';
+        if ($this->ReadPropertyBoolean('CreateDeviceInfo') && is_string($source)) {
+            $type = ShellyParser::extractType($source);
+            if ($type !== 'unknown') {
+                $typeID = $this->ensureVariable($deviceTopic, 'type', 'Typ', 3, '', 20);
+                if ($typeID > 0) {
+                    SetValue($typeID, $type);
+                }
+            }
+        }
+
+        $this->updatePoints($deviceTopic, ShellyParser::pointsFromRpc($rpc));
+    }
+
+    /**
+     * @param array<int, array{component: string, path: string, value: bool|int|float|string}> $points
+     */
+    private function updatePoints(string $deviceTopic, array $points): void
+    {
+        foreach ($points as $point) {
+            $group = ShellyParser::groupForPoint($point['component'], $point['path']);
+            if (!$this->isGroupEnabled($group)) {
+                continue;
+            }
+
+            $definition = $this->pointDefinition($deviceTopic, $point);
+            $variableID = $this->ensureVariable(
+                $deviceTopic,
+                $definition['suffix'],
+                $definition['name'],
+                $definition['type'],
+                $definition['profile'],
+                $definition['position'],
+                $definition['action']
+            );
+            if ($variableID > 0) {
+                $value = $point['value'];
+                if ($definition['type'] === 1 && is_float($value)) {
+                    $value = (int) $value;
+                } elseif ($definition['type'] === 2 && is_int($value)) {
+                    $value = (float) $value;
+                }
+                SetValue($variableID, $value);
+            }
+        }
+    }
+
+    private function isGroupEnabled(string $group): bool
+    {
+        $property = self::GROUP_PROPERTIES[$group] ?? 'CreateOther';
+        return $this->ReadPropertyBoolean($property);
+    }
+
+    /**
+     * @param array{component: string, path: string, value: bool|int|float|string} $point
+     * @return array{suffix: string, name: string, type: int, profile: string, position: int, action: bool}
+     */
+    private function pointDefinition(string $deviceTopic, array $point): array
+    {
+        [$componentType, $componentIndex] = array_pad(explode(':', $point['component'], 2), 2, null);
+        if ($componentType === 'switch' && $point['path'] === 'output' && ctype_digit((string) $componentIndex)) {
+            $index = (int) $componentIndex;
+            return [
+                'suffix' => 'output_' . $index,
+                'name' => 'Output ' . $index,
+                'type' => 0,
+                'profile' => '~Switch',
+                'position' => 200 + $index,
+                'action' => true,
+            ];
+        }
+
+        if (($componentType === 'input' && $point['path'] === 'state')
+            || ($componentType === 'switch' && $point['path'] === 'input')) {
+            $index = ctype_digit((string) $componentIndex) ? (int) $componentIndex : 0;
+            return [
+                'suffix' => 'input_' . $index,
+                'name' => 'Input ' . $index,
+                'type' => 0,
+                'profile' => '',
+                'position' => 100 + $index,
+                'action' => false,
+            ];
+        }
+
+        if ($componentType === 'switch' && str_ends_with(strtolower($point['path']), 'temperature.tc')) {
+            return [
+                'suffix' => 'temperature',
+                'name' => 'Temperatur',
+                'type' => 2,
+                'profile' => '~Temperature',
+                'position' => 300,
+                'action' => false,
+            ];
+        }
+
+        $source = $point['component'] . '.' . $point['path'];
+        $normalized = strtolower($source);
+        $normalized = preg_replace('/[^a-z0-9_]+/', '_', $normalized) ?? 'value';
+        $normalized = trim($normalized, '_');
+        $suffix = 'dp_' . substr($normalized, 0, 48) . '_' . substr(hash('sha256', $source), 0, 8);
+
+        return [
+            'suffix' => $suffix,
+            'name' => $this->displayName($point['component'], $point['path']),
+            'type' => ShellyParser::variableType($point['value'], $point['path']),
+            'profile' => $this->profileForPoint($point['component'], $point['path']),
+            'position' => 1000 + (int) (hexdec(substr(hash('sha256', $source), 0, 4)) % 50000),
+            'action' => false,
+        ];
+    }
+
+    private function displayName(string $component, string $path): string
+    {
+        $fieldNames = [
+            'apower' => 'Wirkleistung',
+            'aprtpower' => 'Scheinleistung',
+            'voltage' => 'Spannung',
+            'current' => 'Strom',
+            'freq' => 'Frequenz',
+            'pf' => 'Leistungsfaktor',
+            'total' => 'Gesamt',
+            'rh' => 'Luftfeuchtigkeit',
+            'tc' => 'Temperatur',
+            'current_pos' => 'Position',
+            'brightness' => 'Helligkeit',
+        ];
+
+        $componentLabel = ucfirst(str_replace(':', ' ', $component));
+        $parts = explode('.', $path);
+        foreach ($parts as &$part) {
+            $lower = strtolower($part);
+            $part = $fieldNames[$lower] ?? ucfirst(str_replace('_', ' ', $part));
+        }
+        unset($part);
+
+        return $componentLabel . ' - ' . implode(' / ', $parts);
+    }
+
+    private function profileForPoint(string $component, string $path): string
+    {
+        $fullPath = strtolower($component . '.' . $path);
+        if (preg_match('/(^|\.)(temperature|tc)(\.|$)/', $fullPath) === 1) {
+            return '~Temperature';
+        }
+        if (preg_match('/(^|\.)(humidity|rh)(\.|$)/', $fullPath) === 1) {
+            return '~Humidity';
+        }
+
+        return '';
+    }
+
+    private function ensureVariable(
+        string $deviceTopic,
+        string $suffix,
+        string $name,
+        int $type,
+        string $profile,
+        int $position,
+        bool $action = false
+    ): int {
+        $folderID = $this->ensureDeviceFolder($deviceTopic);
+        $ident = $this->deviceKey($deviceTopic) . '_' . $suffix;
+        $variableID = @IPS_GetObjectIDByIdent($ident, $folderID);
+
+        if ($variableID !== false) {
+            if (!IPS_VariableExists($variableID) || IPS_GetVariable($variableID)['VariableType'] !== $type) {
+                $this->debug('Variablentyp-Konflikt', $ident);
+                return 0;
+            }
+        } else {
+            $variableID = IPS_CreateVariable($type);
+            IPS_SetParent($variableID, $folderID);
+            IPS_SetIdent($variableID, $ident);
+        }
+
+        IPS_SetName($variableID, $name);
+        IPS_SetPosition($variableID, $position);
+        if ($profile !== '' && IPS_VariableProfileExists($profile)) {
+            IPS_SetVariableCustomProfile($variableID, $profile);
+        }
+        if ($action) {
+            $scriptID = $this->ensureActionScript();
+            if ($scriptID > 0) {
+                IPS_SetVariableCustomAction($variableID, $scriptID);
+            }
+        }
+
+        return $variableID;
+    }
+
+    private function ensureDeviceFolder(string $deviceTopic): int
+    {
+        $ident = 'folder_' . $this->deviceKey($deviceTopic);
+        $folderID = @IPS_GetObjectIDByIdent($ident, $this->InstanceID);
+        if ($folderID !== false) {
+            return $folderID;
+        }
+
+        $folderID = IPS_CreateCategory();
+        IPS_SetParent($folderID, $this->InstanceID);
+        IPS_SetIdent($folderID, $ident);
+        IPS_SetName($folderID, $deviceTopic);
+        IPS_SetInfo($folderID, 'Automatisch aus MQTT-Topic ' . $deviceTopic . ' angelegt.');
+
+        return $folderID;
+    }
+
+    private function ensureActionScript(): int
+    {
+        $ident = 'action_handler';
+        $scriptID = @IPS_GetObjectIDByIdent($ident, $this->InstanceID);
+        if ($scriptID === false) {
+            $scriptID = IPS_CreateScript(0);
+            IPS_SetParent($scriptID, $this->InstanceID);
+            IPS_SetIdent($scriptID, $ident);
+        } elseif (!IPS_ScriptExists($scriptID)) {
+            $this->debug('Action Handler', 'Ident ist bereits durch ein anderes Objekt belegt.');
+            return 0;
+        }
+
+        IPS_SetName($scriptID, 'Shelly Action Handler');
+        IPS_SetHidden($scriptID, true);
+        IPS_SetScriptContent($scriptID, <<<'PHP'
+<?php
+
+$variableID = $_IPS['VARIABLE'];
+$folderID = IPS_GetParent($variableID);
+$moduleID = IPS_GetParent($folderID);
+$ident = IPS_GetObject($variableID)['ObjectIdent'];
+
+IPS_RequestAction($moduleID, $folderID . ':' . $ident, $_IPS['VALUE']);
+PHP
+        );
+
+        return $scriptID;
+    }
+
+    private function publish(string $topic, string $payload): void
+    {
+        $parentID = (int) (IPS_GetInstance($this->InstanceID)['ConnectionID'] ?? 0);
+        if ($parentID === 0 || !IPS_InstanceExists($parentID)) {
+            throw new RuntimeException('Kein MQTT-Gateway verbunden.');
+        }
+        if ((int) IPS_GetInstance($parentID)['InstanceStatus'] !== 102) {
+            throw new RuntimeException('Das verbundene MQTT-Gateway ist nicht aktiv.');
+        }
+
+        $packet = json_encode([
+            'DataID' => self::MQTT_TX_DATA_ID,
+            'PacketType' => 3,
+            'QualityOfService' => 0,
+            'Retain' => false,
+            'Topic' => $topic,
+            'Payload' => $payload,
+        ], JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR);
+
+        $this->SendDataToParent($packet);
+        $this->debug('MQTT gesendet', $topic . ' -> ' . $payload);
+    }
+
+    private function isAcceptedDeviceTopic(string $deviceTopic): bool
+    {
+        if ($deviceTopic === '' || strlen($deviceTopic) > 300 || preg_match('//u', $deviceTopic) !== 1) {
+            return false;
+        }
+        if (preg_match('/[\x00-\x1F\x7F#\+]/u', $deviceTopic) === 1) {
+            return false;
+        }
+        if (!$this->ReadPropertyBoolean('UseDeviceTopicFilter')) {
+            return true;
+        }
+
+        $prefix = trim($this->ReadPropertyString('DeviceTopicPrefix'));
+        return $prefix === '' || strncasecmp($deviceTopic, $prefix, strlen($prefix)) === 0;
+    }
+
+    private function deviceKey(string $deviceTopic): string
+    {
+        $normalized = strtolower($deviceTopic);
+        $normalized = preg_replace('/[^a-z0-9_]+/', '_', $normalized) ?? 'device';
+        $normalized = trim($normalized, '_');
+        if ($normalized === '') {
+            $normalized = 'device';
+        }
+
+        return substr($normalized, 0, 48) . '_' . substr(hash('sha256', $deviceTopic), 0, 8);
+    }
+
+    private function toBoolean(string $value): ?bool
+    {
+        $normalized = strtolower(trim($value));
+        if (in_array($normalized, ['true', '1', 'on', 'online'], true)) {
+            return true;
+        }
+        if (in_array($normalized, ['false', '0', 'off', 'offline'], true)) {
+            return false;
+        }
+
+        return null;
+    }
+
+    private function debug(string $title, $message): void
+    {
+        if (!$this->ReadPropertyBoolean('Debug')) {
+            return;
+        }
+        if (!is_string($message)) {
+            $message = json_encode($message, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
+        }
+
+        $this->SendDebug($title, (string) $message, 0);
+    }
+}

VGTSchnittstelle/README.md

@@ -0,0 +1,9 @@
+# VGT-Schnittstelle
+
+Installierbares IP-Symcon-Modul fuer Enelix Utils ab Version 8.0.
+
+Das Modul fuehrt die bisherigen PV- und Batterie-SDL-Module zusammen. Die
+bestehenden MQTT-Topics und Payload-Felder bleiben unveraendert.
+
+Die vollstaendige Konfiguration steht in
+[`docs/module/VGT-Schnittstelle/README.md`](../docs/module/VGT-Schnittstelle/README.md).

VGTSchnittstelle/form.json

@@ -0,0 +1,78 @@
+{
+  "elements": [
+    {
+      "type": "Label",
+      "caption": "Die MQTT-Topics und Nutzdaten entsprechen unveraendert den bisherigen MQTTPVSDL- und MQTTBatterySDL-Modulen."
+    },
+    {
+      "type": "Select",
+      "name": "Geraeteart",
+      "caption": "Geraeteart",
+      "options": [
+        {"caption": "PV", "value": 0},
+        {"caption": "Batterie / SDL-Anteil", "value": 1}
+      ]
+    },
+    {
+      "type": "ValidationTextBox",
+      "name": "TopicSuffix",
+      "caption": "Topic Suffix"
+    },
+    {
+      "type": "SelectVariable",
+      "name": "ReqActionID",
+      "caption": "Ausgabe-Variable / SDL-Sollleistung"
+    },
+    {
+      "type": "SelectVariable",
+      "name": "PowerProductionID",
+      "caption": "Aktuelle Leistung SDL"
+    },
+    {
+      "type": "SelectVariable",
+      "name": "SoCID",
+      "caption": "SDL-Ladezustand (nur Batterie)"
+    },
+    {
+      "type": "NumberSpinner",
+      "name": "TargetSoC",
+      "caption": "Ziel-Ladezustand",
+      "suffix": " %",
+      "minimum": 0,
+      "maximum": 100
+    },
+    {
+      "type": "NumberSpinner",
+      "name": "ChargePower",
+      "caption": "Ladeleistung",
+      "suffix": " W",
+      "minimum": 0
+    },
+    {
+      "type": "NumberSpinner",
+      "name": "DischargePower",
+      "caption": "Entladeleistung",
+      "suffix": " W",
+      "minimum": 0
+    },
+    {
+      "type": "NumberSpinner",
+      "name": "MaxPowerSetpoint",
+      "caption": "Maximaler Power Setpoint",
+      "suffix": " W",
+      "minimum": 0
+    },
+    {
+      "type": "CheckBox",
+      "name": "LoggingEin",
+      "caption": "Debug-Logging aktivieren"
+    }
+  ],
+  "actions": [
+    {
+      "type": "Button",
+      "caption": "Steuerung testen",
+      "onClick": "ENLVGT_RunControl($id);"
+    }
+  ]
+}

VGTSchnittstelle/libs/VGTRegler.php

@@ -0,0 +1,126 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Belevo\EnelixUtils;
+
+use InvalidArgumentException;
+
+final class VGTRegler
+{
+    public const GERAETEART_PV = 0;
+    public const GERAETEART_BATTERIE = 1;
+
+    public static function begrenzeSetpoint(
+        int $geraeteart,
+        float $wert,
+        float $maximum
+    ): float {
+        self::pruefeGeraeteart($geraeteart);
+        if ($maximum < 0.0) {
+            throw new InvalidArgumentException(
+                'MaxPowerSetpoint darf nicht negativ sein.'
+            );
+        }
+        if ($geraeteart === self::GERAETEART_PV) {
+            return min($maximum, max(0.0, $wert));
+        }
+
+        return min($maximum, max(-$maximum, $wert));
+    }
+
+    public static function zielwert(
+        int $geraeteart,
+        string $strategie,
+        float $setpoint,
+        float $maximum,
+        float $ladezustand,
+        float $zielLadezustand,
+        float $ladeleistung,
+        float $entladeleistung,
+        float $minLadezustand,
+        float $maxLadezustand
+    ): float {
+        self::pruefeGeraeteart($geraeteart);
+        $strategie = trim($strategie);
+        $setpoint = self::begrenzeSetpoint(
+            $geraeteart,
+            $setpoint,
+            $maximum
+        );
+
+        if ($strategie === 'stop') {
+            return $geraeteart === self::GERAETEART_PV ? $maximum : 0.0;
+        }
+        if ($strategie === 'activate') {
+            $ziel = $geraeteart === self::GERAETEART_PV
+                ? $setpoint
+                : -$setpoint;
+            return self::begrenzeNachLadezustand(
+                $geraeteart,
+                $ziel,
+                $ladezustand,
+                $minLadezustand,
+                $maxLadezustand
+            );
+        }
+        if ($geraeteart === self::GERAETEART_PV) {
+            return $maximum;
+        }
+
+        if ($ladezustand >= $zielLadezustand
+            && $ladezustand <= $zielLadezustand + 1.0
+        ) {
+            return 0.0;
+        }
+        $ziel = $ladezustand < $zielLadezustand
+            ? abs($ladeleistung)
+            : -abs($entladeleistung);
+        $ziel = self::begrenzeSetpoint($geraeteart, $ziel, $maximum);
+
+        return self::begrenzeNachLadezustand(
+            $geraeteart,
+            $ziel,
+            $ladezustand,
+            $minLadezustand,
+            $maxLadezustand
+        );
+    }
+
+    private static function begrenzeNachLadezustand(
+        int $geraeteart,
+        float $zielW,
+        float $ladezustand,
+        float $minimum,
+        float $maximum
+    ): float {
+        if ($geraeteart === self::GERAETEART_PV) {
+            return $zielW;
+        }
+        if ($minimum < 0.0
+            || $maximum > 100.0
+            || $minimum > $maximum
+        ) {
+            throw new InvalidArgumentException(
+                'MinSoC und MaxSoC sind ungueltig.'
+            );
+        }
+        if (($zielW < 0.0 && $ladezustand <= $minimum)
+            || ($zielW > 0.0 && $ladezustand >= $maximum)
+        ) {
+            return 0.0;
+        }
+
+        return $zielW;
+    }
+
+    private static function pruefeGeraeteart(int $geraeteart): void
+    {
+        if (!in_array($geraeteart, [
+            self::GERAETEART_PV,
+            self::GERAETEART_BATTERIE,
+        ], true)) {
+            throw new InvalidArgumentException('Geraeteart ist ungueltig.');
+        }
+    }
+}

VGTSchnittstelle/module.json

@@ -0,0 +1,20 @@
+{
+  "id": "{4BA1A557-7970-4FB9-93B8-1F6ADA0A5A94}",
+  "name": "VGTSchnittstelle",
+  "type": 3,
+  "vendor": "Enelix",
+  "aliases": [
+    "VGT-Schnittstelle",
+    "MQTT PV SDL",
+    "MQTT Battery SDL"
+  ],
+  "parentRequirements": [
+    "{043EA491-0325-4ADD-8FC2-A30C8EEB4D3F}"
+  ],
+  "childRequirements": [],
+  "implemented": [
+    "{7F7632D9-FA40-4F38-8DEA-C83CD4325A32}"
+  ],
+  "prefix": "ENLVGT",
+  "url": ""
+}

VGTSchnittstelle/module.php

@@ -0,0 +1,432 @@
+<?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);
+    }
+}

Verbrauchskostenreport/README.md

@@ -0,0 +1,70 @@
+# Verbrauchskostenreport
+
+IP-Symcon-Modul zur Aufbereitung von Energie- und Nebenkosten als PDF-Report.
+
+Das Modul verwendet eine eigenständige, neutrale öffentliche API mit dem
+Präfix `VKR`. Aus Enelix 1 wurde ausschließlich die fachliche Berechnungslogik
+adaptiert. Alte Modulnamen, Aktionen und Medien-Idents werden nicht angeboten.
+
+Technische Anpassungen für IP-Symcon 8.0 und PHP 8.3 umfassen einen
+deklarierten Laufzeit-Cache, ausgabefreie `RequestAction`-Aufrufe und das
+Abmelden des WebHooks beim Löschen einer Instanz.
+
+## Funktion
+
+- erstellt pro Benutzer einen Verbrauchskostenreport
+- berechnet Stromkosten aus Archivwerten in 15-Minuten-Schritten
+- berücksichtigt Netz-, Solar- und Einspeisetarife
+- berechnet zusätzliche Zählerkosten für Warmwasser, Kaltwasser und Wärme
+- erzeugt optional einen Schweizer QR-Zahlteil
+- unterstützt den konfigurierbaren MWST-Ausweis
+
+## Lizenzierung
+
+Der Report benoetigt eine Grundlizenz. Zusaetzlich prueft das Modul getrennte
+Kontingente fuer konfigurierte Stromzaehler und Nebenzaehler. Lizenzcodes werden
+zur Laufzeit gegen `https://license.enelix.ch` geprueft; Zugangsdaten oder
+Lizenzcodes werden nicht im Repository gespeichert.
+
+## QR-Zahlteil
+
+Der QR-Zahlteil verwendet strukturierte Adressen (`S`) nach SIX SPS 2.3.
+Er wird nur bei hinterlegter normaler CH/LI-IBAN und positivem Gesamtbetrag
+erzeugt. QR-IBANs werden abgelehnt, da der Report keine QR-Referenz führt.
+Benutzer- und Zahlungsempfängeradresse benötigen Name, PLZ, Ort und ISO-2-Land.
+
+## Konfiguration
+
+| Property | Beschreibung |
+|---|---|
+| `Lizenzcode` | Laufzeitparameter fuer die Freigabe am Lizenzdienst |
+| `Users` | Benutzerliste |
+| `PowerMeters` | Stromzählerliste |
+| `WaterMeters` | Nebenkostenzähler |
+| `Tariffs` | Tarifliste |
+| `LogoMediaID` | Logo für PDF-Kopf |
+| `PropertyText` | Liegenschaftstext |
+| `FooterText` | PDF-Fusszeile |
+| `EnableVAT` | aktiviert MWST |
+| `VATPercentage` | MWST-Satz |
+| `CreditorName` | Name des Zahlungsempfängers |
+| `CreditorStreet` | Strasse des Zahlungsempfängers |
+| `CreditorBuildingNumber` | Hausnummer des Zahlungsempfängers |
+| `CreditorPostalCode` | PLZ des Zahlungsempfängers |
+| `CreditorTown` | Ort des Zahlungsempfängers |
+| `CreditorCountry` | ISO-2-Ländercode des Zahlungsempfängers |
+| `BankIBAN` | normale CH/LI-IBAN für den QR-Zahlteil |
+
+Bei einem Update müssen bisher kombinierte Benutzer- und Empfängeradressen einmalig
+in die strukturierten Felder aufgeteilt und kontrolliert werden. Bei aktiver IBAN
+verhindern fehlende QR-Pflichtfelder die Reporterzeugung.
+
+## Bedienung
+
+| Ident/Action | Beschreibung |
+|---|---|
+| `FromDate` | Startdatum |
+| `ToDate` | Enddatum |
+| `CreateReport` | erzeugt das PDF |
+| `LastResult` | letzter Lauf |
+| `ReportPDF` | erzeugtes PDF-Dokument |

Verbrauchskostenreport/form.json

@@ -0,0 +1,205 @@
+{
+  "elements": [
+    {
+      "type": "ExpansionPanel",
+      "caption": "Lizenzierung",
+      "expanded": true,
+      "items": [
+        {
+          "type": "ValidationTextBox",
+          "name": "Lizenzcode",
+          "caption": "Verbrauchskostenlizenzcode",
+          "placeholder": "ENX-XXXX-XXXX-XXXX-XXXX"
+        },
+        {
+          "type": "Label",
+          "name": "LizenzInstallationID",
+          "caption": "Installations-ID wird erzeugt"
+        },
+        {
+          "type": "Label",
+          "name": "LizenzInformation",
+          "caption": "Verbrauchskostenlizenzcode fehlt."
+        },
+        {
+          "type": "Button",
+          "name": "LizenzPruefen",
+          "caption": "Lizenz prüfen und binden",
+          "onClick": "IPS_RequestAction($id, 'FormLizenzPruefen', $Lizenzcode);"
+        },
+        {
+          "type": "Button",
+          "name": "LizenzVerwalten",
+          "caption": "Lizenz verwalten",
+          "link": true,
+          "onClick": "echo 'https://license.enelix.ch';"
+        }
+      ]
+    },
+    {
+      "type": "Label",
+      "caption": "🧾 Einstellungen Verbrauchskostenreport"
+    },
+    {
+      "type": "SelectMedia",
+      "name": "LogoMediaID",
+      "caption": "Logo auswählen"
+    },
+    {
+      "type": "ValidationTextBox",
+      "name": "PropertyText",
+      "caption": "Liegenschaft"
+    },
+    {
+      "type": "ValidationTextBox",
+      "name": "FooterText",
+      "caption": "Fusszeile"
+    },
+    {
+      "type": "Label",
+      "caption": "⚖️ Mehrwertsteuer (MWST)"
+    },
+    {
+      "type": "CheckBox",
+      "name": "EnableVAT",
+      "caption": "Mehrwertsteuer berechnen und ausweisen"
+    },
+    {
+      "type": "NumberSpinner",
+      "name": "VATPercentage",
+      "caption": "MWST-Satz in %",
+      "digits": 2,
+      "minimum": 0,
+      "maximum": 100
+    },
+    {
+      "type": "Label",
+      "caption": "🏦 Daten für den QR-Zahlteil"
+    },
+    {
+      "type": "ValidationTextBox",
+      "name": "CreditorName",
+      "caption": "Zahlungsempfänger Name"
+    },
+    {
+      "type": "ValidationTextBox",
+      "name": "CreditorStreet",
+      "caption": "Zahlungsempfänger Strasse"
+    },
+    {
+      "type": "ValidationTextBox",
+      "name": "CreditorBuildingNumber",
+      "caption": "Zahlungsempfänger Hausnummer"
+    },
+    {
+      "type": "ValidationTextBox",
+      "name": "CreditorPostalCode",
+      "caption": "Zahlungsempfänger PLZ"
+    },
+    {
+      "type": "ValidationTextBox",
+      "name": "CreditorTown",
+      "caption": "Zahlungsempfänger Ort"
+    },
+    {
+      "type": "ValidationTextBox",
+      "name": "CreditorCountry",
+      "caption": "Zahlungsempfänger Land (ISO-2)"
+    },
+    {
+      "type": "ValidationTextBox",
+      "name": "BankIBAN",
+      "caption": "Bank IBAN"
+    },
+    {
+      "type": "List",
+      "name": "Users",
+      "caption": "Benutzerliste",
+      "add": true,
+      "delete": true,
+      "sortable": true,
+      "columns": [
+        { "caption": "ID", "name": "id", "width": "8%", "add": "", "edit": { "type": "ValidationTextBox" } },
+        { "caption": "Name", "name": "name", "width": "18%", "add": "", "edit": { "type": "ValidationTextBox" } },
+        { "caption": "Strasse", "name": "street", "width": "18%", "add": "", "edit": { "type": "ValidationTextBox" } },
+        { "caption": "Nr.", "name": "building_number", "width": "8%", "add": "", "edit": { "type": "ValidationTextBox" } },
+        { "caption": "PLZ", "name": "postal_code", "width": "10%", "add": "", "edit": { "type": "ValidationTextBox" } },
+        { "caption": "Ort", "name": "town", "width": "18%", "add": "", "edit": { "type": "ValidationTextBox" } },
+        { "caption": "Land", "name": "country", "width": "8%", "add": "CH", "edit": { "type": "ValidationTextBox" } }
+      ]
+    },
+    {
+      "type": "List",
+      "name": "PowerMeters",
+      "caption": "Stromzählerliste",
+      "add": true,
+      "delete": true,
+      "sortable": true,
+      "columns": [
+        { "caption": "ID", "name": "id", "width": "10%", "add": "", "edit": { "type": "ValidationTextBox" } },
+        { "caption": "Name", "name": "name", "width": "20%", "add": "", "edit": { "type": "ValidationTextBox" } },
+        { "caption": "Var. Verbrauch", "name": "var_consumption", "width": "20%", "add": 0, "edit": { "type": "SelectVariable" } },
+        { "caption": "Var. Rückspeisung", "name": "var_feed", "width": "20%", "add": 0, "edit": { "type": "SelectVariable" } },
+        { "caption": "Benutzer-ID", "name": "user_id", "width": "20%", "add": "", "edit": { "type": "ValidationTextBox" } }
+      ]
+    },
+    {
+      "type": "List",
+      "name": "WaterMeters",
+      "caption": "Verbrauchszählerliste",
+      "add": true,
+      "delete": true,
+      "sortable": true,
+      "columns": [
+        { "caption": "ID", "name": "id", "width": "10%", "add": "", "edit": { "type": "ValidationTextBox" } },
+        { "caption": "Name", "name": "name", "width": "20%", "add": "", "edit": { "type": "ValidationTextBox" } },
+        { "caption": "Var. Verbrauch", "name": "var_consumption", "width": "20%", "add": 0, "edit": { "type": "SelectVariable" } },
+        { "caption": "Benutzer-ID", "name": "user_id", "width": "20%", "add": "", "edit": { "type": "ValidationTextBox" } },
+        {
+          "caption": "Zählertyp",
+          "name": "meter_type",
+          "width": "20%",
+          "add": "Warmwasser",
+          "edit": {
+            "type": "Select",
+            "options": [
+              { "caption": "Warmwasser", "value": "Warmwasser" },
+              { "caption": "Kaltwasser", "value": "Kaltwasser" },
+              { "caption": "Wärme", "value": "Wärme" }
+            ]
+          }
+        }
+      ]
+    },
+    {
+      "type": "List",
+      "name": "Tariffs",
+      "caption": "Tarifübersicht",
+      "add": true,
+      "delete": true,
+      "sortable": true,
+      "columns": [
+        { "caption": "Startdatum", "name": "start", "width": "20%", "add": "", "edit": { "type": "SelectDate" } },
+        { "caption": "Enddatum", "name": "end", "width": "20%", "add": "", "edit": { "type": "SelectDate" } },
+        { "caption": "Tarif (Rp/Einheit)", "name": "price", "width": "20%", "add": 0, "edit": { "type": "NumberSpinner", "digits": 3, "minimum": 0 } },
+        {
+          "caption": "Einheit",
+          "name": "unit_type",
+          "width": "20%",
+          "add": "Netztarif",
+          "edit": {
+            "type": "Select",
+            "options": [
+              { "caption": "Netztarif", "value": "Netztarif" },
+              { "caption": "Einspeisetarif", "value": "Einspeisetarif" },
+              { "caption": "Solartarif", "value": "Solartarif" },
+              { "caption": "Warmwasser", "value": "Warmwasser" },
+              { "caption": "Kaltwasser", "value": "Kaltwasser" },
+              { "caption": "Wärme", "value": "Wärme" }
+            ]
+          }
+        }
+      ]
+    }
+  ]
+}

Verbrauchskostenreport/libs/composer.json

@@ -0,0 +1,5 @@
+{
+    "require": {
+        "tecnickcom/tcpdf": "6.11.3"
+    }
+}

Verbrauchskostenreport/libs/composer.lock

@@ -0,0 +1,96 @@
+{
+    "_readme": [
+        "This file locks the dependencies of your project to a known state",
+        "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
+        "This file is @generated automatically"
+    ],
+    "content-hash": "61565f47f8edbe294fbfa2f4cd0ab261",
+    "packages": [
+        {
+            "name": "tecnickcom/tcpdf",
+            "version": "6.11.3",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/tecnickcom/TCPDF.git",
+                "reference": "b18f6119161019916c5bb07cb8da5205ae5c1b63"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/tecnickcom/TCPDF/zipball/b18f6119161019916c5bb07cb8da5205ae5c1b63",
+                "reference": "b18f6119161019916c5bb07cb8da5205ae5c1b63",
+                "shasum": ""
+            },
+            "require": {
+                "ext-curl": "*",
+                "php": ">=7.1.0"
+            },
+            "suggest": {
+                "ext-gd": "Enables additional image handling in some workflows.",
+                "ext-imagick": "Enables additional image format support when available.",
+                "ext-zlib": "Recommended for compressed streams and related features.",
+                "tecnickcom/tc-lib-pdf": "Modern replacement for TCPDF for new projects."
+            },
+            "type": "library",
+            "autoload": {
+                "classmap": [
+                    "config",
+                    "include",
+                    "tcpdf.php",
+                    "tcpdf_barcodes_1d.php",
+                    "tcpdf_barcodes_2d.php",
+                    "include/tcpdf_colors.php",
+                    "include/tcpdf_filters.php",
+                    "include/tcpdf_font_data.php",
+                    "include/tcpdf_fonts.php",
+                    "include/tcpdf_images.php",
+                    "include/tcpdf_static.php",
+                    "include/barcodes/datamatrix.php",
+                    "include/barcodes/pdf417.php",
+                    "include/barcodes/qrcode.php"
+                ]
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "LGPL-3.0-or-later"
+            ],
+            "authors": [
+                {
+                    "name": "Nicola Asuni",
+                    "email": "info@tecnick.com",
+                    "role": "lead"
+                }
+            ],
+            "description": "Deprecated legacy PDF engine for PHP. For new projects use tecnickcom/tc-lib-pdf.",
+            "homepage": "https://tcpdf.org",
+            "keywords": [
+                "PDFD32000-2008",
+                "TCPDF",
+                "barcodes",
+                "datamatrix",
+                "pdf",
+                "pdf417",
+                "qrcode"
+            ],
+            "support": {
+                "issues": "https://github.com/tecnickcom/TCPDF/issues",
+                "source": "https://github.com/tecnickcom/TCPDF"
+            },
+            "funding": [
+                {
+                    "url": "https://www.paypal.com/donate/?hosted_button_id=NZUEC5XS8MFBJ",
+                    "type": "paypal"
+                }
+            ],
+            "time": "2026-04-21T17:00:18+00:00"
+        }
+    ],
+    "packages-dev": [],
+    "aliases": [],
+    "minimum-stability": "stable",
+    "stability-flags": {},
+    "prefer-stable": false,
+    "prefer-lowest": false,
+    "platform": {},
+    "platform-dev": {},
+    "plugin-api-version": "2.9.0"
+}

Verbrauchskostenreport/libs/vendor/autoload.php

@@ -0,0 +1,22 @@
+<?php
+
+// autoload.php @generated by Composer
+
+if (PHP_VERSION_ID < 50600) {
+    if (!headers_sent()) {
+        header('HTTP/1.1 500 Internal Server Error');
+    }
+    $err = 'Composer 2.3.0 dropped support for autoloading on PHP <5.6 and you are running '.PHP_VERSION.', please upgrade PHP or use Composer 2.2 LTS via "composer self-update --2.2". Aborting.'.PHP_EOL;
+    if (!ini_get('display_errors')) {
+        if (PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg') {
+            fwrite(STDERR, $err);
+        } elseif (!headers_sent()) {
+            echo $err;
+        }
+    }
+    throw new RuntimeException($err);
+}
+
+require_once __DIR__ . '/composer/autoload_real.php';
+
+return ComposerAutoloaderInit418d75d37a56e981b178936c5d087775::getLoader();

Verbrauchskostenreport/libs/vendor/composer/ClassLoader.php

@@ -0,0 +1,579 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer\Autoload;
+
+/**
+ * ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
+ *
+ *     $loader = new \Composer\Autoload\ClassLoader();
+ *
+ *     // register classes with namespaces
+ *     $loader->add('Symfony\Component', __DIR__.'/component');
+ *     $loader->add('Symfony',           __DIR__.'/framework');
+ *
+ *     // activate the autoloader
+ *     $loader->register();
+ *
+ *     // to enable searching the include path (eg. for PEAR packages)
+ *     $loader->setUseIncludePath(true);
+ *
+ * In this example, if you try to use a class in the Symfony\Component
+ * namespace or one of its children (Symfony\Component\Console for instance),
+ * the autoloader will first look for the class under the component/
+ * directory, and it will then fallback to the framework/ directory if not
+ * found before giving up.
+ *
+ * This class is loosely based on the Symfony UniversalClassLoader.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ * @see    https://www.php-fig.org/psr/psr-0/
+ * @see    https://www.php-fig.org/psr/psr-4/
+ */
+class ClassLoader
+{
+    /** @var \Closure(string):void */
+    private static $includeFile;
+
+    /** @var string|null */
+    private $vendorDir;
+
+    // PSR-4
+    /**
+     * @var array<string, array<string, int>>
+     */
+    private $prefixLengthsPsr4 = array();
+    /**
+     * @var array<string, list<string>>
+     */
+    private $prefixDirsPsr4 = array();
+    /**
+     * @var list<string>
+     */
+    private $fallbackDirsPsr4 = array();
+
+    // PSR-0
+    /**
+     * List of PSR-0 prefixes
+     *
+     * Structured as array('F (first letter)' => array('Foo\Bar (full prefix)' => array('path', 'path2')))
+     *
+     * @var array<string, array<string, list<string>>>
+     */
+    private $prefixesPsr0 = array();
+    /**
+     * @var list<string>
+     */
+    private $fallbackDirsPsr0 = array();
+
+    /** @var bool */
+    private $useIncludePath = false;
+
+    /**
+     * @var array<string, string>
+     */
+    private $classMap = array();
+
+    /** @var bool */
+    private $classMapAuthoritative = false;
+
+    /**
+     * @var array<string, bool>
+     */
+    private $missingClasses = array();
+
+    /** @var string|null */
+    private $apcuPrefix;
+
+    /**
+     * @var array<string, self>
+     */
+    private static $registeredLoaders = array();
+
+    /**
+     * @param string|null $vendorDir
+     */
+    public function __construct($vendorDir = null)
+    {
+        $this->vendorDir = $vendorDir;
+        self::initializeIncludeClosure();
+    }
+
+    /**
+     * @return array<string, list<string>>
+     */
+    public function getPrefixes()
+    {
+        if (!empty($this->prefixesPsr0)) {
+            return call_user_func_array('array_merge', array_values($this->prefixesPsr0));
+        }
+
+        return array();
+    }
+
+    /**
+     * @return array<string, list<string>>
+     */
+    public function getPrefixesPsr4()
+    {
+        return $this->prefixDirsPsr4;
+    }
+
+    /**
+     * @return list<string>
+     */
+    public function getFallbackDirs()
+    {
+        return $this->fallbackDirsPsr0;
+    }
+
+    /**
+     * @return list<string>
+     */
+    public function getFallbackDirsPsr4()
+    {
+        return $this->fallbackDirsPsr4;
+    }
+
+    /**
+     * @return array<string, string> Array of classname => path
+     */
+    public function getClassMap()
+    {
+        return $this->classMap;
+    }
+
+    /**
+     * @param array<string, string> $classMap Class to filename map
+     *
+     * @return void
+     */
+    public function addClassMap(array $classMap)
+    {
+        if ($this->classMap) {
+            $this->classMap = array_merge($this->classMap, $classMap);
+        } else {
+            $this->classMap = $classMap;
+        }
+    }
+
+    /**
+     * Registers a set of PSR-0 directories for a given prefix, either
+     * appending or prepending to the ones previously set for this prefix.
+     *
+     * @param string              $prefix  The prefix
+     * @param list<string>|string $paths   The PSR-0 root directories
+     * @param bool                $prepend Whether to prepend the directories
+     *
+     * @return void
+     */
+    public function add($prefix, $paths, $prepend = false)
+    {
+        $paths = (array) $paths;
+        if (!$prefix) {
+            if ($prepend) {
+                $this->fallbackDirsPsr0 = array_merge(
+                    $paths,
+                    $this->fallbackDirsPsr0
+                );
+            } else {
+                $this->fallbackDirsPsr0 = array_merge(
+                    $this->fallbackDirsPsr0,
+                    $paths
+                );
+            }
+
+            return;
+        }
+
+        $first = $prefix[0];
+        if (!isset($this->prefixesPsr0[$first][$prefix])) {
+            $this->prefixesPsr0[$first][$prefix] = $paths;
+
+            return;
+        }
+        if ($prepend) {
+            $this->prefixesPsr0[$first][$prefix] = array_merge(
+                $paths,
+                $this->prefixesPsr0[$first][$prefix]
+            );
+        } else {
+            $this->prefixesPsr0[$first][$prefix] = array_merge(
+                $this->prefixesPsr0[$first][$prefix],
+                $paths
+            );
+        }
+    }
+
+    /**
+     * Registers a set of PSR-4 directories for a given namespace, either
+     * appending or prepending to the ones previously set for this namespace.
+     *
+     * @param string              $prefix  The prefix/namespace, with trailing '\\'
+     * @param list<string>|string $paths   The PSR-4 base directories
+     * @param bool                $prepend Whether to prepend the directories
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return void
+     */
+    public function addPsr4($prefix, $paths, $prepend = false)
+    {
+        $paths = (array) $paths;
+        if (!$prefix) {
+            // Register directories for the root namespace.
+            if ($prepend) {
+                $this->fallbackDirsPsr4 = array_merge(
+                    $paths,
+                    $this->fallbackDirsPsr4
+                );
+            } else {
+                $this->fallbackDirsPsr4 = array_merge(
+                    $this->fallbackDirsPsr4,
+                    $paths
+                );
+            }
+        } elseif (!isset($this->prefixDirsPsr4[$prefix])) {
+            // Register directories for a new namespace.
+            $length = strlen($prefix);
+            if ('\\' !== $prefix[$length - 1]) {
+                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
+            }
+            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
+            $this->prefixDirsPsr4[$prefix] = $paths;
+        } elseif ($prepend) {
+            // Prepend directories for an already registered namespace.
+            $this->prefixDirsPsr4[$prefix] = array_merge(
+                $paths,
+                $this->prefixDirsPsr4[$prefix]
+            );
+        } else {
+            // Append directories for an already registered namespace.
+            $this->prefixDirsPsr4[$prefix] = array_merge(
+                $this->prefixDirsPsr4[$prefix],
+                $paths
+            );
+        }
+    }
+
+    /**
+     * Registers a set of PSR-0 directories for a given prefix,
+     * replacing any others previously set for this prefix.
+     *
+     * @param string              $prefix The prefix
+     * @param list<string>|string $paths  The PSR-0 base directories
+     *
+     * @return void
+     */
+    public function set($prefix, $paths)
+    {
+        if (!$prefix) {
+            $this->fallbackDirsPsr0 = (array) $paths;
+        } else {
+            $this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths;
+        }
+    }
+
+    /**
+     * Registers a set of PSR-4 directories for a given namespace,
+     * replacing any others previously set for this namespace.
+     *
+     * @param string              $prefix The prefix/namespace, with trailing '\\'
+     * @param list<string>|string $paths  The PSR-4 base directories
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return void
+     */
+    public function setPsr4($prefix, $paths)
+    {
+        if (!$prefix) {
+            $this->fallbackDirsPsr4 = (array) $paths;
+        } else {
+            $length = strlen($prefix);
+            if ('\\' !== $prefix[$length - 1]) {
+                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
+            }
+            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
+            $this->prefixDirsPsr4[$prefix] = (array) $paths;
+        }
+    }
+
+    /**
+     * Turns on searching the include path for class files.
+     *
+     * @param bool $useIncludePath
+     *
+     * @return void
+     */
+    public function setUseIncludePath($useIncludePath)
+    {
+        $this->useIncludePath = $useIncludePath;
+    }
+
+    /**
+     * Can be used to check if the autoloader uses the include path to check
+     * for classes.
+     *
+     * @return bool
+     */
+    public function getUseIncludePath()
+    {
+        return $this->useIncludePath;
+    }
+
+    /**
+     * Turns off searching the prefix and fallback directories for classes
+     * that have not been registered with the class map.
+     *
+     * @param bool $classMapAuthoritative
+     *
+     * @return void
+     */
+    public function setClassMapAuthoritative($classMapAuthoritative)
+    {
+        $this->classMapAuthoritative = $classMapAuthoritative;
+    }
+
+    /**
+     * Should class lookup fail if not found in the current class map?
+     *
+     * @return bool
+     */
+    public function isClassMapAuthoritative()
+    {
+        return $this->classMapAuthoritative;
+    }
+
+    /**
+     * APCu prefix to use to cache found/not-found classes, if the extension is enabled.
+     *
+     * @param string|null $apcuPrefix
+     *
+     * @return void
+     */
+    public function setApcuPrefix($apcuPrefix)
+    {
+        $this->apcuPrefix = function_exists('apcu_fetch') && filter_var(ini_get('apc.enabled'), FILTER_VALIDATE_BOOLEAN) ? $apcuPrefix : null;
+    }
+
+    /**
+     * The APCu prefix in use, or null if APCu caching is not enabled.
+     *
+     * @return string|null
+     */
+    public function getApcuPrefix()
+    {
+        return $this->apcuPrefix;
+    }
+
+    /**
+     * Registers this instance as an autoloader.
+     *
+     * @param bool $prepend Whether to prepend the autoloader or not
+     *
+     * @return void
+     */
+    public function register($prepend = false)
+    {
+        spl_autoload_register(array($this, 'loadClass'), true, $prepend);
+
+        if (null === $this->vendorDir) {
+            return;
+        }
+
+        if ($prepend) {
+            self::$registeredLoaders = array($this->vendorDir => $this) + self::$registeredLoaders;
+        } else {
+            unset(self::$registeredLoaders[$this->vendorDir]);
+            self::$registeredLoaders[$this->vendorDir] = $this;
+        }
+    }
+
+    /**
+     * Unregisters this instance as an autoloader.
+     *
+     * @return void
+     */
+    public function unregister()
+    {
+        spl_autoload_unregister(array($this, 'loadClass'));
+
+        if (null !== $this->vendorDir) {
+            unset(self::$registeredLoaders[$this->vendorDir]);
+        }
+    }
+
+    /**
+     * Loads the given class or interface.
+     *
+     * @param  string    $class The name of the class
+     * @return true|null True if loaded, null otherwise
+     */
+    public function loadClass($class)
+    {
+        if ($file = $this->findFile($class)) {
+            $includeFile = self::$includeFile;
+            $includeFile($file);
+
+            return true;
+        }
+
+        return null;
+    }
+
+    /**
+     * Finds the path to the file where the class is defined.
+     *
+     * @param string $class The name of the class
+     *
+     * @return string|false The path if found, false otherwise
+     */
+    public function findFile($class)
+    {
+        // class map lookup
+        if (isset($this->classMap[$class])) {
+            return $this->classMap[$class];
+        }
+        if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) {
+            return false;
+        }
+        if (null !== $this->apcuPrefix) {
+            $file = apcu_fetch($this->apcuPrefix.$class, $hit);
+            if ($hit) {
+                return $file;
+            }
+        }
+
+        $file = $this->findFileWithExtension($class, '.php');
+
+        // Search for Hack files if we are running on HHVM
+        if (false === $file && defined('HHVM_VERSION')) {
+            $file = $this->findFileWithExtension($class, '.hh');
+        }
+
+        if (null !== $this->apcuPrefix) {
+            apcu_add($this->apcuPrefix.$class, $file);
+        }
+
+        if (false === $file) {
+            // Remember that this class does not exist.
+            $this->missingClasses[$class] = true;
+        }
+
+        return $file;
+    }
+
+    /**
+     * Returns the currently registered loaders keyed by their corresponding vendor directories.
+     *
+     * @return array<string, self>
+     */
+    public static function getRegisteredLoaders()
+    {
+        return self::$registeredLoaders;
+    }
+
+    /**
+     * @param  string       $class
+     * @param  string       $ext
+     * @return string|false
+     */
+    private function findFileWithExtension($class, $ext)
+    {
+        // PSR-4 lookup
+        $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;
+
+        $first = $class[0];
+        if (isset($this->prefixLengthsPsr4[$first])) {
+            $subPath = $class;
+            while (false !== $lastPos = strrpos($subPath, '\\')) {
+                $subPath = substr($subPath, 0, $lastPos);
+                $search = $subPath . '\\';
+                if (isset($this->prefixDirsPsr4[$search])) {
+                    $pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1);
+                    foreach ($this->prefixDirsPsr4[$search] as $dir) {
+                        if (file_exists($file = $dir . $pathEnd)) {
+                            return $file;
+                        }
+                    }
+                }
+            }
+        }
+
+        // PSR-4 fallback dirs
+        foreach ($this->fallbackDirsPsr4 as $dir) {
+            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) {
+                return $file;
+            }
+        }
+
+        // PSR-0 lookup
+        if (false !== $pos = strrpos($class, '\\')) {
+            // namespaced class name
+            $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
+                . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
+        } else {
+            // PEAR-like class name
+            $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
+        }
+
+        if (isset($this->prefixesPsr0[$first])) {
+            foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
+                if (0 === strpos($class, $prefix)) {
+                    foreach ($dirs as $dir) {
+                        if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
+                            return $file;
+                        }
+                    }
+                }
+            }
+        }
+
+        // PSR-0 fallback dirs
+        foreach ($this->fallbackDirsPsr0 as $dir) {
+            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
+                return $file;
+            }
+        }
+
+        // PSR-0 include paths.
+        if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
+            return $file;
+        }
+
+        return false;
+    }
+
+    /**
+     * @return void
+     */
+    private static function initializeIncludeClosure()
+    {
+        if (self::$includeFile !== null) {
+            return;
+        }
+
+        /**
+         * Scope isolated include.
+         *
+         * Prevents access to $this/self from included files.
+         *
+         * @param  string $file
+         * @return void
+         */
+        self::$includeFile = \Closure::bind(static function($file) {
+            include $file;
+        }, null, null);
+    }
+}

Verbrauchskostenreport/libs/vendor/composer/InstalledVersions.php

@@ -0,0 +1,396 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer;
+
+use Composer\Autoload\ClassLoader;
+use Composer\Semver\VersionParser;
+
+/**
+ * This class is copied in every Composer installed project and available to all
+ *
+ * See also https://getcomposer.org/doc/07-runtime.md#installed-versions
+ *
+ * To require its presence, you can require `composer-runtime-api ^2.0`
+ *
+ * @final
+ */
+class InstalledVersions
+{
+    /**
+     * @var string|null if set (by reflection by Composer), this should be set to the path where this class is being copied to
+     * @internal
+     */
+    private static $selfDir = null;
+
+    /**
+     * @var mixed[]|null
+     * @psalm-var array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}|array{}|null
+     */
+    private static $installed;
+
+    /**
+     * @var bool
+     */
+    private static $installedIsLocalDir;
+
+    /**
+     * @var bool|null
+     */
+    private static $canGetVendors;
+
+    /**
+     * @var array[]
+     * @psalm-var array<string, array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}>
+     */
+    private static $installedByVendor = array();
+
+    /**
+     * Returns a list of all package names which are present, either by being installed, replaced or provided
+     *
+     * @return string[]
+     * @psalm-return list<string>
+     */
+    public static function getInstalledPackages()
+    {
+        $packages = array();
+        foreach (self::getInstalled() as $installed) {
+            $packages[] = array_keys($installed['versions']);
+        }
+
+        if (1 === \count($packages)) {
+            return $packages[0];
+        }
+
+        return array_keys(array_flip(\call_user_func_array('array_merge', $packages)));
+    }
+
+    /**
+     * Returns a list of all package names with a specific type e.g. 'library'
+     *
+     * @param  string   $type
+     * @return string[]
+     * @psalm-return list<string>
+     */
+    public static function getInstalledPackagesByType($type)
+    {
+        $packagesByType = array();
+
+        foreach (self::getInstalled() as $installed) {
+            foreach ($installed['versions'] as $name => $package) {
+                if (isset($package['type']) && $package['type'] === $type) {
+                    $packagesByType[] = $name;
+                }
+            }
+        }
+
+        return $packagesByType;
+    }
+
+    /**
+     * Checks whether the given package is installed
+     *
+     * This also returns true if the package name is provided or replaced by another package
+     *
+     * @param  string $packageName
+     * @param  bool   $includeDevRequirements
+     * @return bool
+     */
+    public static function isInstalled($packageName, $includeDevRequirements = true)
+    {
+        foreach (self::getInstalled() as $installed) {
+            if (isset($installed['versions'][$packageName])) {
+                return $includeDevRequirements || !isset($installed['versions'][$packageName]['dev_requirement']) || $installed['versions'][$packageName]['dev_requirement'] === false;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Checks whether the given package satisfies a version constraint
+     *
+     * e.g. If you want to know whether version 2.3+ of package foo/bar is installed, you would call:
+     *
+     *   Composer\InstalledVersions::satisfies(new VersionParser, 'foo/bar', '^2.3')
+     *
+     * @param  VersionParser $parser      Install composer/semver to have access to this class and functionality
+     * @param  string        $packageName
+     * @param  string|null   $constraint  A version constraint to check for, if you pass one you have to make sure composer/semver is required by your package
+     * @return bool
+     */
+    public static function satisfies(VersionParser $parser, $packageName, $constraint)
+    {
+        $constraint = $parser->parseConstraints((string) $constraint);
+        $provided = $parser->parseConstraints(self::getVersionRanges($packageName));
+
+        return $provided->matches($constraint);
+    }
+
+    /**
+     * Returns a version constraint representing all the range(s) which are installed for a given package
+     *
+     * It is easier to use this via isInstalled() with the $constraint argument if you need to check
+     * whether a given version of a package is installed, and not just whether it exists
+     *
+     * @param  string $packageName
+     * @return string Version constraint usable with composer/semver
+     */
+    public static function getVersionRanges($packageName)
+    {
+        foreach (self::getInstalled() as $installed) {
+            if (!isset($installed['versions'][$packageName])) {
+                continue;
+            }
+
+            $ranges = array();
+            if (isset($installed['versions'][$packageName]['pretty_version'])) {
+                $ranges[] = $installed['versions'][$packageName]['pretty_version'];
+            }
+            if (array_key_exists('aliases', $installed['versions'][$packageName])) {
+                $ranges = array_merge($ranges, $installed['versions'][$packageName]['aliases']);
+            }
+            if (array_key_exists('replaced', $installed['versions'][$packageName])) {
+                $ranges = array_merge($ranges, $installed['versions'][$packageName]['replaced']);
+            }
+            if (array_key_exists('provided', $installed['versions'][$packageName])) {
+                $ranges = array_merge($ranges, $installed['versions'][$packageName]['provided']);
+            }
+
+            return implode(' || ', $ranges);
+        }
+
+        throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
+    }
+
+    /**
+     * @param  string      $packageName
+     * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as version, use satisfies or getVersionRanges if you need to know if a given version is present
+     */
+    public static function getVersion($packageName)
+    {
+        foreach (self::getInstalled() as $installed) {
+            if (!isset($installed['versions'][$packageName])) {
+                continue;
+            }
+
+            if (!isset($installed['versions'][$packageName]['version'])) {
+                return null;
+            }
+
+            return $installed['versions'][$packageName]['version'];
+        }
+
+        throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
+    }
+
+    /**
+     * @param  string      $packageName
+     * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as version, use satisfies or getVersionRanges if you need to know if a given version is present
+     */
+    public static function getPrettyVersion($packageName)
+    {
+        foreach (self::getInstalled() as $installed) {
+            if (!isset($installed['versions'][$packageName])) {
+                continue;
+            }
+
+            if (!isset($installed['versions'][$packageName]['pretty_version'])) {
+                return null;
+            }
+
+            return $installed['versions'][$packageName]['pretty_version'];
+        }
+
+        throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
+    }
+
+    /**
+     * @param  string      $packageName
+     * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as reference
+     */
+    public static function getReference($packageName)
+    {
+        foreach (self::getInstalled() as $installed) {
+            if (!isset($installed['versions'][$packageName])) {
+                continue;
+            }
+
+            if (!isset($installed['versions'][$packageName]['reference'])) {
+                return null;
+            }
+
+            return $installed['versions'][$packageName]['reference'];
+        }
+
+        throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
+    }
+
+    /**
+     * @param  string      $packageName
+     * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as install path. Packages of type metapackages also have a null install path.
+     */
+    public static function getInstallPath($packageName)
+    {
+        foreach (self::getInstalled() as $installed) {
+            if (!isset($installed['versions'][$packageName])) {
+                continue;
+            }
+
+            return isset($installed['versions'][$packageName]['install_path']) ? $installed['versions'][$packageName]['install_path'] : null;
+        }
+
+        throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
+    }
+
+    /**
+     * @return array
+     * @psalm-return array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}
+     */
+    public static function getRootPackage()
+    {
+        $installed = self::getInstalled();
+
+        return $installed[0]['root'];
+    }
+
+    /**
+     * Returns the raw installed.php data for custom implementations
+     *
+     * @deprecated Use getAllRawData() instead which returns all datasets for all autoloaders present in the process. getRawData only returns the first dataset loaded, which may not be what you expect.
+     * @return array[]
+     * @psalm-return array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}
+     */
+    public static function getRawData()
+    {
+        @trigger_error('getRawData only returns the first dataset loaded, which may not be what you expect. Use getAllRawData() instead which returns all datasets for all autoloaders present in the process.', E_USER_DEPRECATED);
+
+        if (null === self::$installed) {
+            // only require the installed.php file if this file is loaded from its dumped location,
+            // and not from its source location in the composer/composer package, see https://github.com/composer/composer/issues/9937
+            if (substr(__DIR__, -8, 1) !== 'C') {
+                self::$installed = include __DIR__ . '/installed.php';
+            } else {
+                self::$installed = array();
+            }
+        }
+
+        return self::$installed;
+    }
+
+    /**
+     * Returns the raw data of all installed.php which are currently loaded for custom implementations
+     *
+     * @return array[]
+     * @psalm-return list<array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}>
+     */
+    public static function getAllRawData()
+    {
+        return self::getInstalled();
+    }
+
+    /**
+     * Lets you reload the static array from another file
+     *
+     * This is only useful for complex integrations in which a project needs to use
+     * this class but then also needs to execute another project's autoloader in process,
+     * and wants to ensure both projects have access to their version of installed.php.
+     *
+     * A typical case would be PHPUnit, where it would need to make sure it reads all
+     * the data it needs from this class, then call reload() with
+     * `require $CWD/vendor/composer/installed.php` (or similar) as input to make sure
+     * the project in which it runs can then also use this class safely, without
+     * interference between PHPUnit's dependencies and the project's dependencies.
+     *
+     * @param  array[] $data A vendor/composer/installed.php data set
+     * @return void
+     *
+     * @psalm-param array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>} $data
+     */
+    public static function reload($data)
+    {
+        self::$installed = $data;
+        self::$installedByVendor = array();
+
+        // when using reload, we disable the duplicate protection to ensure that self::$installed data is
+        // always returned, but we cannot know whether it comes from the installed.php in __DIR__ or not,
+        // so we have to assume it does not, and that may result in duplicate data being returned when listing
+        // all installed packages for example
+        self::$installedIsLocalDir = false;
+    }
+
+    /**
+     * @return string
+     */
+    private static function getSelfDir()
+    {
+        if (self::$selfDir === null) {
+            self::$selfDir = strtr(__DIR__, '\\', '/');
+        }
+
+        return self::$selfDir;
+    }
+
+    /**
+     * @return array[]
+     * @psalm-return list<array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}>
+     */
+    private static function getInstalled()
+    {
+        if (null === self::$canGetVendors) {
+            self::$canGetVendors = method_exists('Composer\Autoload\ClassLoader', 'getRegisteredLoaders');
+        }
+
+        $installed = array();
+        $copiedLocalDir = false;
+
+        if (self::$canGetVendors) {
+            $selfDir = self::getSelfDir();
+            foreach (ClassLoader::getRegisteredLoaders() as $vendorDir => $loader) {
+                $vendorDir = strtr($vendorDir, '\\', '/');
+                if (isset(self::$installedByVendor[$vendorDir])) {
+                    $installed[] = self::$installedByVendor[$vendorDir];
+                } elseif (is_file($vendorDir.'/composer/installed.php')) {
+                    /** @var array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>} $required */
+                    $required = require $vendorDir.'/composer/installed.php';
+                    self::$installedByVendor[$vendorDir] = $required;
+                    $installed[] = $required;
+                    if (self::$installed === null && $vendorDir.'/composer' === $selfDir) {
+                        self::$installed = $required;
+                        self::$installedIsLocalDir = true;
+                    }
+                }
+                if (self::$installedIsLocalDir && $vendorDir.'/composer' === $selfDir) {
+                    $copiedLocalDir = true;
+                }
+            }
+        }
+
+        if (null === self::$installed) {
+            // only require the installed.php file if this file is loaded from its dumped location,
+            // and not from its source location in the composer/composer package, see https://github.com/composer/composer/issues/9937
+            if (substr(__DIR__, -8, 1) !== 'C') {
+                /** @var array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>} $required */
+                $required = require __DIR__ . '/installed.php';
+                self::$installed = $required;
+            } else {
+                self::$installed = array();
+            }
+        }
+
+        if (self::$installed !== array() && !$copiedLocalDir) {
+            $installed[] = self::$installed;
+        }
+
+        return $installed;
+    }
+}

Verbrauchskostenreport/libs/vendor/composer/LICENSE

@@ -0,0 +1,21 @@
+
+Copyright (c) Nils Adermann, Jordi Boggiano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

Verbrauchskostenreport/libs/vendor/composer/autoload_classmap.php

@@ -0,0 +1,22 @@
+<?php
+
+// autoload_classmap.php @generated by Composer
+
+$vendorDir = dirname(__DIR__);
+$baseDir = dirname($vendorDir);
+
+return array(
+    'Composer\\InstalledVersions' => $vendorDir . '/composer/InstalledVersions.php',
+    'Datamatrix' => $vendorDir . '/tecnickcom/tcpdf/include/barcodes/datamatrix.php',
+    'PDF417' => $vendorDir . '/tecnickcom/tcpdf/include/barcodes/pdf417.php',
+    'QRcode' => $vendorDir . '/tecnickcom/tcpdf/include/barcodes/qrcode.php',
+    'TCPDF' => $vendorDir . '/tecnickcom/tcpdf/tcpdf.php',
+    'TCPDF2DBarcode' => $vendorDir . '/tecnickcom/tcpdf/tcpdf_barcodes_2d.php',
+    'TCPDFBarcode' => $vendorDir . '/tecnickcom/tcpdf/tcpdf_barcodes_1d.php',
+    'TCPDF_COLORS' => $vendorDir . '/tecnickcom/tcpdf/include/tcpdf_colors.php',
+    'TCPDF_FILTERS' => $vendorDir . '/tecnickcom/tcpdf/include/tcpdf_filters.php',
+    'TCPDF_FONTS' => $vendorDir . '/tecnickcom/tcpdf/include/tcpdf_fonts.php',
+    'TCPDF_FONT_DATA' => $vendorDir . '/tecnickcom/tcpdf/include/tcpdf_font_data.php',
+    'TCPDF_IMAGES' => $vendorDir . '/tecnickcom/tcpdf/include/tcpdf_images.php',
+    'TCPDF_STATIC' => $vendorDir . '/tecnickcom/tcpdf/include/tcpdf_static.php',
+);

Verbrauchskostenreport/libs/vendor/composer/autoload_namespaces.php

@@ -0,0 +1,9 @@
+<?php
+
+// autoload_namespaces.php @generated by Composer
+
+$vendorDir = dirname(__DIR__);
+$baseDir = dirname($vendorDir);
+
+return array(
+);

Verbrauchskostenreport/libs/vendor/composer/autoload_psr4.php

@@ -0,0 +1,9 @@
+<?php
+
+// autoload_psr4.php @generated by Composer
+
+$vendorDir = dirname(__DIR__);
+$baseDir = dirname($vendorDir);
+
+return array(
+);

Verbrauchskostenreport/libs/vendor/composer/autoload_real.php

@@ -0,0 +1,38 @@
+<?php
+
+// autoload_real.php @generated by Composer
+
+class ComposerAutoloaderInit418d75d37a56e981b178936c5d087775
+{
+    private static $loader;
+
+    public static function loadClassLoader($class)
+    {
+        if ('Composer\Autoload\ClassLoader' === $class) {
+            require __DIR__ . '/ClassLoader.php';
+        }
+    }
+
+    /**
+     * @return \Composer\Autoload\ClassLoader
+     */
+    public static function getLoader()
+    {
+        if (null !== self::$loader) {
+            return self::$loader;
+        }
+
+        require __DIR__ . '/platform_check.php';
+
+        spl_autoload_register(array('ComposerAutoloaderInit418d75d37a56e981b178936c5d087775', 'loadClassLoader'), true, true);
+        self::$loader = $loader = new \Composer\Autoload\ClassLoader(\dirname(__DIR__));
+        spl_autoload_unregister(array('ComposerAutoloaderInit418d75d37a56e981b178936c5d087775', 'loadClassLoader'));
+
+        require __DIR__ . '/autoload_static.php';
+        call_user_func(\Composer\Autoload\ComposerStaticInit418d75d37a56e981b178936c5d087775::getInitializer($loader));
+
+        $loader->register(true);
+
+        return $loader;
+    }
+}

Verbrauchskostenreport/libs/vendor/composer/autoload_static.php

@@ -0,0 +1,32 @@
+<?php
+
+// autoload_static.php @generated by Composer
+
+namespace Composer\Autoload;
+
+class ComposerStaticInit418d75d37a56e981b178936c5d087775
+{
+    public static $classMap = array (
+        'Composer\\InstalledVersions' => __DIR__ . '/..' . '/composer/InstalledVersions.php',
+        'Datamatrix' => __DIR__ . '/..' . '/tecnickcom/tcpdf/include/barcodes/datamatrix.php',
+        'PDF417' => __DIR__ . '/..' . '/tecnickcom/tcpdf/include/barcodes/pdf417.php',
+        'QRcode' => __DIR__ . '/..' . '/tecnickcom/tcpdf/include/barcodes/qrcode.php',
+        'TCPDF' => __DIR__ . '/..' . '/tecnickcom/tcpdf/tcpdf.php',
+        'TCPDF2DBarcode' => __DIR__ . '/..' . '/tecnickcom/tcpdf/tcpdf_barcodes_2d.php',
+        'TCPDFBarcode' => __DIR__ . '/..' . '/tecnickcom/tcpdf/tcpdf_barcodes_1d.php',
+        'TCPDF_COLORS' => __DIR__ . '/..' . '/tecnickcom/tcpdf/include/tcpdf_colors.php',
+        'TCPDF_FILTERS' => __DIR__ . '/..' . '/tecnickcom/tcpdf/include/tcpdf_filters.php',
+        'TCPDF_FONTS' => __DIR__ . '/..' . '/tecnickcom/tcpdf/include/tcpdf_fonts.php',
+        'TCPDF_FONT_DATA' => __DIR__ . '/..' . '/tecnickcom/tcpdf/include/tcpdf_font_data.php',
+        'TCPDF_IMAGES' => __DIR__ . '/..' . '/tecnickcom/tcpdf/include/tcpdf_images.php',
+        'TCPDF_STATIC' => __DIR__ . '/..' . '/tecnickcom/tcpdf/include/tcpdf_static.php',
+    );
+
+    public static function getInitializer(ClassLoader $loader)
+    {
+        return \Closure::bind(function () use ($loader) {
+            $loader->classMap = ComposerStaticInit418d75d37a56e981b178936c5d087775::$classMap;
+
+        }, null, ClassLoader::class);
+    }
+}

Verbrauchskostenreport/libs/vendor/composer/installed.json

@@ -0,0 +1,86 @@
+{
+    "packages": [
+        {
+            "name": "tecnickcom/tcpdf",
+            "version": "6.11.3",
+            "version_normalized": "6.11.3.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/tecnickcom/TCPDF.git",
+                "reference": "b18f6119161019916c5bb07cb8da5205ae5c1b63"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/tecnickcom/TCPDF/zipball/b18f6119161019916c5bb07cb8da5205ae5c1b63",
+                "reference": "b18f6119161019916c5bb07cb8da5205ae5c1b63",
+                "shasum": ""
+            },
+            "require": {
+                "ext-curl": "*",
+                "php": ">=7.1.0"
+            },
+            "suggest": {
+                "ext-gd": "Enables additional image handling in some workflows.",
+                "ext-imagick": "Enables additional image format support when available.",
+                "ext-zlib": "Recommended for compressed streams and related features.",
+                "tecnickcom/tc-lib-pdf": "Modern replacement for TCPDF for new projects."
+            },
+            "time": "2026-04-21T17:00:18+00:00",
+            "type": "library",
+            "installation-source": "dist",
+            "autoload": {
+                "classmap": [
+                    "config",
+                    "include",
+                    "tcpdf.php",
+                    "tcpdf_barcodes_1d.php",
+                    "tcpdf_barcodes_2d.php",
+                    "include/tcpdf_colors.php",
+                    "include/tcpdf_filters.php",
+                    "include/tcpdf_font_data.php",
+                    "include/tcpdf_fonts.php",
+                    "include/tcpdf_images.php",
+                    "include/tcpdf_static.php",
+                    "include/barcodes/datamatrix.php",
+                    "include/barcodes/pdf417.php",
+                    "include/barcodes/qrcode.php"
+                ]
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "LGPL-3.0-or-later"
+            ],
+            "authors": [
+                {
+                    "name": "Nicola Asuni",
+                    "email": "info@tecnick.com",
+                    "role": "lead"
+                }
+            ],
+            "description": "Deprecated legacy PDF engine for PHP. For new projects use tecnickcom/tc-lib-pdf.",
+            "homepage": "https://tcpdf.org",
+            "keywords": [
+                "PDFD32000-2008",
+                "TCPDF",
+                "barcodes",
+                "datamatrix",
+                "pdf",
+                "pdf417",
+                "qrcode"
+            ],
+            "support": {
+                "issues": "https://github.com/tecnickcom/TCPDF/issues",
+                "source": "https://github.com/tecnickcom/TCPDF"
+            },
+            "funding": [
+                {
+                    "url": "https://www.paypal.com/donate/?hosted_button_id=NZUEC5XS8MFBJ",
+                    "type": "paypal"
+                }
+            ],
+            "install-path": "../tecnickcom/tcpdf"
+        }
+    ],
+    "dev": true,
+    "dev-package-names": []
+}

Verbrauchskostenreport/libs/vendor/composer/installed.php

@@ -0,0 +1,32 @@
+<?php return array(
+    'root' => array(
+        'name' => '__root__',
+        'pretty_version' => '1.0.0+no-version-set',
+        'version' => '1.0.0.0',
+        'reference' => null,
+        'type' => 'library',
+        'install_path' => __DIR__ . '/../../',
+        'aliases' => array(),
+        'dev' => true,
+    ),
+    'versions' => array(
+        '__root__' => array(
+            'pretty_version' => '1.0.0+no-version-set',
+            'version' => '1.0.0.0',
+            'reference' => null,
+            'type' => 'library',
+            'install_path' => __DIR__ . '/../../',
+            'aliases' => array(),
+            'dev_requirement' => false,
+        ),
+        'tecnickcom/tcpdf' => array(
+            'pretty_version' => '6.11.3',
+            'version' => '6.11.3.0',
+            'reference' => 'b18f6119161019916c5bb07cb8da5205ae5c1b63',
+            'type' => 'library',
+            'install_path' => __DIR__ . '/../tecnickcom/tcpdf',
+            'aliases' => array(),
+            'dev_requirement' => false,
+        ),
+    ),
+);

Verbrauchskostenreport/libs/vendor/composer/platform_check.php

@@ -0,0 +1,25 @@
+<?php
+
+// platform_check.php @generated by Composer
+
+$issues = array();
+
+if (!(PHP_VERSION_ID >= 70100)) {
+    $issues[] = 'Your Composer dependencies require a PHP version ">= 7.1.0". You are running ' . PHP_VERSION . '.';
+}
+
+if ($issues) {
+    if (!headers_sent()) {
+        header('HTTP/1.1 500 Internal Server Error');
+    }
+    if (!ini_get('display_errors')) {
+        if (PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg') {
+            fwrite(STDERR, 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . implode(PHP_EOL, $issues) . PHP_EOL.PHP_EOL);
+        } elseif (!headers_sent()) {
+            echo 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . str_replace('You are running '.PHP_VERSION.'.', '', implode(PHP_EOL, $issues)) . PHP_EOL.PHP_EOL;
+        }
+    }
+    throw new \RuntimeException(
+        'Composer detected issues in your platform: ' . implode(' ', $issues)
+    );
+}

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/LICENSE.TXT

@@ -0,0 +1,860 @@
+**********************************************************************
+* TCPDF LICENSE
+**********************************************************************
+
+  TCPDF is free software: you can redistribute it and/or modify it
+  under the terms of the GNU Lesser General Public License as
+  published by the Free Software Foundation, either version 3 of the
+  License, or (at your option) any later version.
+  
+  2002-2026 Nicola Asuni - Tecnick.com LTD
+
+**********************************************************************
+**********************************************************************
+
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://www.fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
+
+**********************************************************************
+**********************************************************************
+
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://www.fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/philosophy/why-not-lgpl.html>.
+
+**********************************************************************
+**********************************************************************

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/VERSION

@@ -0,0 +1 @@
+6.11.3

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/composer.json

@@ -0,0 +1,75 @@
+{
+    "name": "tecnickcom/tcpdf",
+    "type": "library",
+    "description": "Deprecated legacy PDF engine for PHP. For new projects use tecnickcom/tc-lib-pdf.",
+    "keywords": [
+        "PDF",
+        "tcpdf",
+        "PDFD32000-2008",
+        "qrcode",
+        "datamatrix",
+        "pdf417",
+        "barcodes"
+    ],
+    "homepage": "https://tcpdf.org",
+    "license": "LGPL-3.0-or-later",
+    "authors": [
+        {
+            "name": "Nicola Asuni",
+            "email": "info@tecnick.com",
+            "role": "lead"
+        }
+    ],
+    "require": {
+        "php": ">=7.1.0",
+        "ext-curl": "*"
+    },
+    "suggest": {
+        "tecnickcom/tc-lib-pdf": "Modern replacement for TCPDF for new projects.",
+        "ext-gd": "Enables additional image handling in some workflows.",
+        "ext-imagick": "Enables additional image format support when available.",
+        "ext-zlib": "Recommended for compressed streams and related features."
+    },
+    "minimum-stability": "dev",
+    "prefer-stable": true,
+    "config": {
+        "sort-packages": true
+    },
+    "autoload": {
+        "classmap": [
+            "config",
+            "include",
+            "tcpdf.php",
+            "tcpdf_barcodes_1d.php",
+            "tcpdf_barcodes_2d.php",
+            "include/tcpdf_colors.php",
+            "include/tcpdf_filters.php",
+            "include/tcpdf_font_data.php",
+            "include/tcpdf_fonts.php",
+            "include/tcpdf_images.php",
+            "include/tcpdf_static.php",
+            "include/barcodes/datamatrix.php",
+            "include/barcodes/pdf417.php",
+            "include/barcodes/qrcode.php"
+        ]
+    },
+    "archive": {
+        "exclude": [
+            "/.github",
+            "/.phpdoc",
+            "/examples",
+            "/scripts",
+            "/tests"
+        ]
+    },
+    "support": {
+        "issues": "https://github.com/tecnickcom/TCPDF/issues",
+        "source": "https://github.com/tecnickcom/TCPDF"
+    },
+    "funding": [
+        {
+            "type": "paypal",
+            "url": "https://www.paypal.com/donate/?hosted_button_id=NZUEC5XS8MFBJ"
+        }
+    ]
+}

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/config/tcpdf_config.php

@@ -0,0 +1,235 @@
+<?php
+//============================================================+
+// File name   : tcpdf_config.php
+// Begin       : 2004-06-11
+// Last Update : 2014-12-11
+//
+// Description : Configuration file for TCPDF.
+// Author      : Nicola Asuni - Tecnick.com LTD - www.tecnick.com - info@tecnick.com
+// License     : GNU-LGPL v3 (https://www.gnu.org/copyleft/lesser.html)
+// -------------------------------------------------------------------
+// Copyright (C) 2004-2014 2026 Nicola Asuni - Tecnick.com LTD
+//
+// This file is part of TCPDF software library.
+//
+// TCPDF is free software: you can redistribute it and/or modify it
+// under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// TCPDF is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with TCPDF.  If not, see <https://www.gnu.org/licenses/>.
+//
+// See LICENSE.TXT file for more information.
+//============================================================+
+
+/**
+ * Configuration file for TCPDF.
+ * @author Nicola Asuni
+ * @package com.tecnick.tcpdf
+ * @version 4.9.005
+ * @since 2004-10-27
+ */
+
+// IMPORTANT:
+// If you define the constant K_TCPDF_EXTERNAL_CONFIG, all the following settings will be ignored.
+// If you use the tcpdf_autoconfig.php, then you can overwrite some values here.
+
+
+/**
+ * Installation path (/var/www/tcpdf/).
+ * By default it is automatically calculated but you can also set it as a fixed string to improve performances.
+ */
+//define ('K_PATH_MAIN', '');
+
+/**
+ * URL path to tcpdf installation folder (http://localhost/tcpdf/).
+ * By default it is automatically set but you can also set it as a fixed string to improve performances.
+ */
+//define ('K_PATH_URL', '');
+
+/**
+ * Path for PDF fonts.
+ * By default it is automatically set but you can also set it as a fixed string to improve performances.
+ */
+//define ('K_PATH_FONTS', K_PATH_MAIN.'fonts/');
+
+/**
+ * Default images directory.
+ * By default it is automatically set but you can also set it as a fixed string to improve performances.
+ */
+//define ('K_PATH_IMAGES', '');
+
+/**
+ * Deafult image logo used be the default Header() method.
+ * Please set here your own logo or an empty string to disable it.
+ */
+//define ('PDF_HEADER_LOGO', '');
+
+/**
+ * Header logo image width in user units.
+ */
+//define ('PDF_HEADER_LOGO_WIDTH', 0);
+
+/**
+ * Cache directory for temporary files (full path).
+ */
+//define ('K_PATH_CACHE', '/tmp/');
+
+/**
+ * Generic name for a blank image.
+ */
+define ('K_BLANK_IMAGE', '_blank.png');
+
+/**
+ * Page format.
+ */
+define ('PDF_PAGE_FORMAT', 'A4');
+
+/**
+ * Page orientation (P=portrait, L=landscape).
+ */
+define ('PDF_PAGE_ORIENTATION', 'P');
+
+/**
+ * Document creator.
+ */
+define ('PDF_CREATOR', 'TCPDF');
+
+/**
+ * Document author.
+ */
+define ('PDF_AUTHOR', 'TCPDF');
+
+/**
+ * Header title.
+ */
+define ('PDF_HEADER_TITLE', 'TCPDF Example');
+
+/**
+ * Header description string.
+ */
+define ('PDF_HEADER_STRING', "by2026 Nicola Asuni - Tecnick.com\nwww.tcpdf.org");
+
+/**
+ * Document unit of measure [pt=point, mm=millimeter, cm=centimeter, in=inch].
+ */
+define ('PDF_UNIT', 'mm');
+
+/**
+ * Header margin.
+ */
+define ('PDF_MARGIN_HEADER', 5);
+
+/**
+ * Footer margin.
+ */
+define ('PDF_MARGIN_FOOTER', 10);
+
+/**
+ * Top margin.
+ */
+define ('PDF_MARGIN_TOP', 27);
+
+/**
+ * Bottom margin.
+ */
+define ('PDF_MARGIN_BOTTOM', 25);
+
+/**
+ * Left margin.
+ */
+define ('PDF_MARGIN_LEFT', 15);
+
+/**
+ * Right margin.
+ */
+define ('PDF_MARGIN_RIGHT', 15);
+
+/**
+ * Default main font name.
+ */
+define ('PDF_FONT_NAME_MAIN', 'helvetica');
+
+/**
+ * Default main font size.
+ */
+define ('PDF_FONT_SIZE_MAIN', 10);
+
+/**
+ * Default data font name.
+ */
+define ('PDF_FONT_NAME_DATA', 'helvetica');
+
+/**
+ * Default data font size.
+ */
+define ('PDF_FONT_SIZE_DATA', 8);
+
+/**
+ * Default monospaced font name.
+ */
+define ('PDF_FONT_MONOSPACED', 'courier');
+
+/**
+ * Ratio used to adjust the conversion of pixels to user units.
+ */
+define ('PDF_IMAGE_SCALE_RATIO', 1.25);
+
+/**
+ * Magnification factor for titles.
+ */
+define('HEAD_MAGNIFICATION', 1.1);
+
+/**
+ * Height of cell respect font height.
+ */
+define('K_CELL_HEIGHT_RATIO', 1.25);
+
+/**
+ * Title magnification respect main font size.
+ */
+define('K_TITLE_MAGNIFICATION', 1.3);
+
+/**
+ * Reduction factor for small font.
+ */
+define('K_SMALL_RATIO', 2/3);
+
+/**
+ * Set to true to enable the special procedure used to avoid the overlappind of symbols on Thai language.
+ */
+define('K_THAI_TOPCHARS', true);
+
+/**
+ * If true allows to call TCPDF methods using HTML syntax
+ * IMPORTANT: For security reason, disable this feature if you are printing user HTML content.
+ */
+define('K_TCPDF_CALLS_IN_HTML', false);
+
+/**
+ * List of TCPDF methods that are allowed to be called using HTML syntax.
+ * Note: each method name must end with surrounded with | (pipe) character.
+ * The constant K_TCPDF_CALLS_IN_HTML must be set to true.
+ * IMPORTANT: For security reason, disable this feature if you are allowing user HTML content.
+ */
+define('K_ALLOWED_TCPDF_TAGS', '');
+
+/**
+ * If true and PHP version is greater than 5, then the Error() method throw new exception instead of terminating the execution.
+ */
+define('K_TCPDF_THROW_EXCEPTION_ERROR', false);
+
+/**
+ * Default timezone for datetime functions
+ */
+define('K_TIMEZONE', 'UTC');
+
+//============================================================+
+// END OF FILE
+//============================================================+

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/fonts/courier.php

@@ -0,0 +1,12 @@
+<?php
+// TCPDF FONT FILE DESCRIPTION
+$type='core';
+$name='Courier';
+$up=-100;
+$ut=50;
+$dw=600;
+$diff='';
+$enc='';
+$desc=array('Flags'=>33,'FontBBox'=>'[-23 -250 715 805]','ItalicAngle'=>0,'Ascent'=>805,'Descent'=>-250,'Leading'=>0,'CapHeight'=>562,'XHeight'=>426,'StemV'=>51,'StemH'=>51,'AvgWidth'=>600,'MaxWidth'=>600,'MissingWidth'=>600);
+$cw=array(0=>600,1=>600,2=>600,3=>600,4=>600,5=>600,6=>600,7=>600,8=>600,9=>600,10=>600,11=>600,12=>600,13=>600,14=>600,15=>600,16=>600,17=>600,18=>600,19=>600,20=>600,21=>600,22=>600,23=>600,24=>600,25=>600,26=>600,27=>600,28=>600,29=>600,30=>600,31=>600,32=>600,33=>600,34=>600,35=>600,36=>600,37=>600,38=>600,39=>600,40=>600,41=>600,42=>600,43=>600,44=>600,45=>600,46=>600,47=>600,48=>600,49=>600,50=>600,51=>600,52=>600,53=>600,54=>600,55=>600,56=>600,57=>600,58=>600,59=>600,60=>600,61=>600,62=>600,63=>600,64=>600,65=>600,66=>600,67=>600,68=>600,69=>600,70=>600,71=>600,72=>600,73=>600,74=>600,75=>600,76=>600,77=>600,78=>600,79=>600,80=>600,81=>600,82=>600,83=>600,84=>600,85=>600,86=>600,87=>600,88=>600,89=>600,90=>600,91=>600,92=>600,93=>600,94=>600,95=>600,96=>600,97=>600,98=>600,99=>600,100=>600,101=>600,102=>600,103=>600,104=>600,105=>600,106=>600,107=>600,108=>600,109=>600,110=>600,111=>600,112=>600,113=>600,114=>600,115=>600,116=>600,117=>600,118=>600,119=>600,120=>600,121=>600,122=>600,123=>600,124=>600,125=>600,126=>600,127=>600,128=>600,129=>600,130=>600,131=>600,132=>600,133=>600,134=>600,135=>600,136=>600,137=>600,138=>600,139=>600,140=>600,141=>600,142=>600,143=>600,144=>600,145=>600,146=>600,147=>600,148=>600,149=>600,150=>600,151=>600,152=>600,153=>600,154=>600,155=>600,156=>600,157=>600,158=>600,159=>600,160=>600,161=>600,162=>600,163=>600,164=>600,165=>600,166=>600,167=>600,168=>600,169=>600,170=>600,171=>600,172=>600,173=>600,174=>600,175=>600,176=>600,177=>600,178=>600,179=>600,180=>600,181=>600,182=>600,183=>600,184=>600,185=>600,186=>600,187=>600,188=>600,189=>600,190=>600,191=>600,192=>600,193=>600,194=>600,195=>600,196=>600,197=>600,198=>600,199=>600,200=>600,201=>600,202=>600,203=>600,204=>600,205=>600,206=>600,207=>600,208=>600,209=>600,210=>600,211=>600,212=>600,213=>600,214=>600,215=>600,216=>600,217=>600,218=>600,219=>600,220=>600,221=>600,222=>600,223=>600,224=>600,225=>600,226=>600,227=>600,228=>600,229=>600,230=>600,231=>600,232=>600,233=>600,234=>600,235=>600,236=>600,237=>600,238=>600,239=>600,240=>600,241=>600,242=>600,243=>600,244=>600,245=>600,246=>600,247=>600,248=>600,249=>600,250=>600,251=>600,252=>600,253=>600,254=>600,255=>600);
+// --- EOF ---

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/fonts/courierb.php

@@ -0,0 +1,12 @@
+<?php
+// TCPDF FONT FILE DESCRIPTION
+$type='core';
+$name='Courier-Bold';
+$up=-100;
+$ut=50;
+$dw=600;
+$diff='';
+$enc='';
+$desc=array('Flags'=>33,'FontBBox'=>'[-113 -250 749 801]','ItalicAngle'=>0,'Ascent'=>801,'Descent'=>-250,'Leading'=>0,'CapHeight'=>562,'XHeight'=>439,'StemV'=>106,'StemH'=>84,'AvgWidth'=>600,'MaxWidth'=>600,'MissingWidth'=>600);
+$cw=array(0=>600,1=>600,2=>600,3=>600,4=>600,5=>600,6=>600,7=>600,8=>600,9=>600,10=>600,11=>600,12=>600,13=>600,14=>600,15=>600,16=>600,17=>600,18=>600,19=>600,20=>600,21=>600,22=>600,23=>600,24=>600,25=>600,26=>600,27=>600,28=>600,29=>600,30=>600,31=>600,32=>600,33=>600,34=>600,35=>600,36=>600,37=>600,38=>600,39=>600,40=>600,41=>600,42=>600,43=>600,44=>600,45=>600,46=>600,47=>600,48=>600,49=>600,50=>600,51=>600,52=>600,53=>600,54=>600,55=>600,56=>600,57=>600,58=>600,59=>600,60=>600,61=>600,62=>600,63=>600,64=>600,65=>600,66=>600,67=>600,68=>600,69=>600,70=>600,71=>600,72=>600,73=>600,74=>600,75=>600,76=>600,77=>600,78=>600,79=>600,80=>600,81=>600,82=>600,83=>600,84=>600,85=>600,86=>600,87=>600,88=>600,89=>600,90=>600,91=>600,92=>600,93=>600,94=>600,95=>600,96=>600,97=>600,98=>600,99=>600,100=>600,101=>600,102=>600,103=>600,104=>600,105=>600,106=>600,107=>600,108=>600,109=>600,110=>600,111=>600,112=>600,113=>600,114=>600,115=>600,116=>600,117=>600,118=>600,119=>600,120=>600,121=>600,122=>600,123=>600,124=>600,125=>600,126=>600,127=>600,128=>600,129=>600,130=>600,131=>600,132=>600,133=>600,134=>600,135=>600,136=>600,137=>600,138=>600,139=>600,140=>600,141=>600,142=>600,143=>600,144=>600,145=>600,146=>600,147=>600,148=>600,149=>600,150=>600,151=>600,152=>600,153=>600,154=>600,155=>600,156=>600,157=>600,158=>600,159=>600,160=>600,161=>600,162=>600,163=>600,164=>600,165=>600,166=>600,167=>600,168=>600,169=>600,170=>600,171=>600,172=>600,173=>600,174=>600,175=>600,176=>600,177=>600,178=>600,179=>600,180=>600,181=>600,182=>600,183=>600,184=>600,185=>600,186=>600,187=>600,188=>600,189=>600,190=>600,191=>600,192=>600,193=>600,194=>600,195=>600,196=>600,197=>600,198=>600,199=>600,200=>600,201=>600,202=>600,203=>600,204=>600,205=>600,206=>600,207=>600,208=>600,209=>600,210=>600,211=>600,212=>600,213=>600,214=>600,215=>600,216=>600,217=>600,218=>600,219=>600,220=>600,221=>600,222=>600,223=>600,224=>600,225=>600,226=>600,227=>600,228=>600,229=>600,230=>600,231=>600,232=>600,233=>600,234=>600,235=>600,236=>600,237=>600,238=>600,239=>600,240=>600,241=>600,242=>600,243=>600,244=>600,245=>600,246=>600,247=>600,248=>600,249=>600,250=>600,251=>600,252=>600,253=>600,254=>600,255=>600);
+// --- EOF ---

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/fonts/courierbi.php

@@ -0,0 +1,12 @@
+<?php
+// TCPDF FONT FILE DESCRIPTION
+$type='core';
+$name='Courier-BoldOblique';
+$up=-100;
+$ut=50;
+$dw=600;
+$diff='';
+$enc='';
+$desc=array('Flags'=>97,'FontBBox'=>'[-57 -250 869 801]','ItalicAngle'=>-12,'Ascent'=>801,'Descent'=>-250,'Leading'=>0,'CapHeight'=>562,'XHeight'=>439,'StemV'=>106,'StemH'=>84,'AvgWidth'=>600,'MaxWidth'=>600,'MissingWidth'=>600);
+$cw=array(0=>600,1=>600,2=>600,3=>600,4=>600,5=>600,6=>600,7=>600,8=>600,9=>600,10=>600,11=>600,12=>600,13=>600,14=>600,15=>600,16=>600,17=>600,18=>600,19=>600,20=>600,21=>600,22=>600,23=>600,24=>600,25=>600,26=>600,27=>600,28=>600,29=>600,30=>600,31=>600,32=>600,33=>600,34=>600,35=>600,36=>600,37=>600,38=>600,39=>600,40=>600,41=>600,42=>600,43=>600,44=>600,45=>600,46=>600,47=>600,48=>600,49=>600,50=>600,51=>600,52=>600,53=>600,54=>600,55=>600,56=>600,57=>600,58=>600,59=>600,60=>600,61=>600,62=>600,63=>600,64=>600,65=>600,66=>600,67=>600,68=>600,69=>600,70=>600,71=>600,72=>600,73=>600,74=>600,75=>600,76=>600,77=>600,78=>600,79=>600,80=>600,81=>600,82=>600,83=>600,84=>600,85=>600,86=>600,87=>600,88=>600,89=>600,90=>600,91=>600,92=>600,93=>600,94=>600,95=>600,96=>600,97=>600,98=>600,99=>600,100=>600,101=>600,102=>600,103=>600,104=>600,105=>600,106=>600,107=>600,108=>600,109=>600,110=>600,111=>600,112=>600,113=>600,114=>600,115=>600,116=>600,117=>600,118=>600,119=>600,120=>600,121=>600,122=>600,123=>600,124=>600,125=>600,126=>600,127=>600,128=>600,129=>600,130=>600,131=>600,132=>600,133=>600,134=>600,135=>600,136=>600,137=>600,138=>600,139=>600,140=>600,141=>600,142=>600,143=>600,144=>600,145=>600,146=>600,147=>600,148=>600,149=>600,150=>600,151=>600,152=>600,153=>600,154=>600,155=>600,156=>600,157=>600,158=>600,159=>600,160=>600,161=>600,162=>600,163=>600,164=>600,165=>600,166=>600,167=>600,168=>600,169=>600,170=>600,171=>600,172=>600,173=>600,174=>600,175=>600,176=>600,177=>600,178=>600,179=>600,180=>600,181=>600,182=>600,183=>600,184=>600,185=>600,186=>600,187=>600,188=>600,189=>600,190=>600,191=>600,192=>600,193=>600,194=>600,195=>600,196=>600,197=>600,198=>600,199=>600,200=>600,201=>600,202=>600,203=>600,204=>600,205=>600,206=>600,207=>600,208=>600,209=>600,210=>600,211=>600,212=>600,213=>600,214=>600,215=>600,216=>600,217=>600,218=>600,219=>600,220=>600,221=>600,222=>600,223=>600,224=>600,225=>600,226=>600,227=>600,228=>600,229=>600,230=>600,231=>600,232=>600,233=>600,234=>600,235=>600,236=>600,237=>600,238=>600,239=>600,240=>600,241=>600,242=>600,243=>600,244=>600,245=>600,246=>600,247=>600,248=>600,249=>600,250=>600,251=>600,252=>600,253=>600,254=>600,255=>600);
+// --- EOF ---

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/fonts/courieri.php

@@ -0,0 +1,12 @@
+<?php
+// TCPDF FONT FILE DESCRIPTION
+$type='core';
+$name='Courier-Oblique';
+$up=-100;
+$ut=50;
+$dw=600;
+$diff='';
+$enc='';
+$desc=array('Flags'=>97,'FontBBox'=>'[-27 -250 849 805]','ItalicAngle'=>-12,'Ascent'=>805,'Descent'=>-250,'Leading'=>0,'CapHeight'=>562,'XHeight'=>426,'StemV'=>51,'StemH'=>51,'AvgWidth'=>600,'MaxWidth'=>600,'MissingWidth'=>600);
+$cw=array(0=>600,1=>600,2=>600,3=>600,4=>600,5=>600,6=>600,7=>600,8=>600,9=>600,10=>600,11=>600,12=>600,13=>600,14=>600,15=>600,16=>600,17=>600,18=>600,19=>600,20=>600,21=>600,22=>600,23=>600,24=>600,25=>600,26=>600,27=>600,28=>600,29=>600,30=>600,31=>600,32=>600,33=>600,34=>600,35=>600,36=>600,37=>600,38=>600,39=>600,40=>600,41=>600,42=>600,43=>600,44=>600,45=>600,46=>600,47=>600,48=>600,49=>600,50=>600,51=>600,52=>600,53=>600,54=>600,55=>600,56=>600,57=>600,58=>600,59=>600,60=>600,61=>600,62=>600,63=>600,64=>600,65=>600,66=>600,67=>600,68=>600,69=>600,70=>600,71=>600,72=>600,73=>600,74=>600,75=>600,76=>600,77=>600,78=>600,79=>600,80=>600,81=>600,82=>600,83=>600,84=>600,85=>600,86=>600,87=>600,88=>600,89=>600,90=>600,91=>600,92=>600,93=>600,94=>600,95=>600,96=>600,97=>600,98=>600,99=>600,100=>600,101=>600,102=>600,103=>600,104=>600,105=>600,106=>600,107=>600,108=>600,109=>600,110=>600,111=>600,112=>600,113=>600,114=>600,115=>600,116=>600,117=>600,118=>600,119=>600,120=>600,121=>600,122=>600,123=>600,124=>600,125=>600,126=>600,127=>600,128=>600,129=>600,130=>600,131=>600,132=>600,133=>600,134=>600,135=>600,136=>600,137=>600,138=>600,139=>600,140=>600,141=>600,142=>600,143=>600,144=>600,145=>600,146=>600,147=>600,148=>600,149=>600,150=>600,151=>600,152=>600,153=>600,154=>600,155=>600,156=>600,157=>600,158=>600,159=>600,160=>600,161=>600,162=>600,163=>600,164=>600,165=>600,166=>600,167=>600,168=>600,169=>600,170=>600,171=>600,172=>600,173=>600,174=>600,175=>600,176=>600,177=>600,178=>600,179=>600,180=>600,181=>600,182=>600,183=>600,184=>600,185=>600,186=>600,187=>600,188=>600,189=>600,190=>600,191=>600,192=>600,193=>600,194=>600,195=>600,196=>600,197=>600,198=>600,199=>600,200=>600,201=>600,202=>600,203=>600,204=>600,205=>600,206=>600,207=>600,208=>600,209=>600,210=>600,211=>600,212=>600,213=>600,214=>600,215=>600,216=>600,217=>600,218=>600,219=>600,220=>600,221=>600,222=>600,223=>600,224=>600,225=>600,226=>600,227=>600,228=>600,229=>600,230=>600,231=>600,232=>600,233=>600,234=>600,235=>600,236=>600,237=>600,238=>600,239=>600,240=>600,241=>600,242=>600,243=>600,244=>600,245=>600,246=>600,247=>600,248=>600,249=>600,250=>600,251=>600,252=>600,253=>600,254=>600,255=>600);
+// --- EOF ---

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/fonts/helvetica.php

@@ -0,0 +1,13 @@
+<?php
+// TCPDF FONT FILE DESCRIPTION
+$type='core';
+$name='Helvetica';
+$up=-100;
+$ut=50;
+$dw=513;
+$diff='';
+$enc='';
+$desc=array('Flags'=>32,'FontBBox'=>'[-166 -225 1000 931]','ItalicAngle'=>0,'Ascent'=>931,'Descent'=>-225,'Leading'=>0,'CapHeight'=>718,'XHeight'=>523,'StemV'=>88,'StemH'=>76,'AvgWidth'=>513,'MaxWidth'=>1015,'MissingWidth'=>513);
+$cw=array(0=>500,1=>500,2=>500,3=>500,4=>500,5=>500,6=>500,7=>500,8=>500,9=>500,10=>500,11=>500,12=>500,13=>500,14=>500,15=>500,16=>500,17=>500,18=>500,19=>500,20=>500,21=>500,22=>500,23=>500,24=>500,25=>500,26=>500,27=>500,28=>500,29=>500,30=>500,31=>500,32=>278,33=>278,34=>355,35=>556,36=>556,37=>889,38=>667,39=>191,40=>333,41=>333,42=>389,43=>584,44=>278,45=>333,46=>278,47=>278,48=>556,49=>556,50=>556,51=>556,52=>556,53=>556,54=>556,55=>556,56=>556,57=>556,58=>278,59=>278,60=>584,61=>584,62=>584,63=>556,64=>1015,65=>667,66=>667,67=>722,68=>722,69=>667,70=>611,71=>778,72=>722,73=>278,74=>500,75=>667,76=>556,77=>833,78=>722,79=>778,80=>667,81=>778,82=>722,83=>667,84=>611,85=>722,86=>667,87=>944,88=>667,89=>667,90=>611,91=>278,92=>278,93=>277,94=>469,95=>556,96=>333,97=>556,98=>556,99=>500,100=>556,101=>556,102=>278,103=>556,104=>556,105=>222,106=>222,107=>500,108=>222,109=>833,110=>556,111=>556,112=>556,113=>556,114=>333,115=>500,116=>278,117=>556,118=>500,119=>722,120=>500,121=>500,122=>500,123=>334,124=>260,125=>334,126=>584,127=>500,128=>655,129=>500,130=>222,131=>278,132=>333,133=>1000,134=>556,135=>556,136=>333,137=>1000,138=>667,139=>250,140=>1000,141=>500,142=>611,143=>500,144=>500,145=>222,146=>221,147=>333,148=>333,149=>350,150=>556,151=>1000,152=>333,153=>1000,154=>500,155=>250,156=>938,157=>500,158=>500,159=>667,160=>278,161=>278,162=>556,163=>556,164=>556,165=>556,166=>260,167=>556,168=>333,169=>737,170=>370,171=>448,172=>584,173=>333,174=>737,175=>333,176=>606,177=>584,178=>350,179=>350,180=>333,181=>556,182=>537,183=>278,184=>333,185=>350,186=>365,187=>448,188=>869,189=>869,190=>879,191=>556,192=>667,193=>667,194=>667,195=>667,196=>667,197=>667,198=>1000,199=>722,200=>667,201=>667,202=>667,203=>667,204=>278,205=>278,206=>278,207=>278,208=>722,209=>722,210=>778,211=>778,212=>778,213=>778,214=>778,215=>584,216=>778,217=>722,218=>722,219=>722,220=>722,221=>667,222=>666,223=>611,224=>556,225=>556,226=>556,227=>556,228=>556,229=>556,230=>896,231=>500,232=>556,233=>556,234=>556,235=>556,236=>251,237=>251,238=>251,239=>251,240=>556,241=>556,242=>556,243=>556,244=>556,245=>556,246=>556,247=>584,248=>611,249=>556,250=>556,251=>556,252=>556,253=>500,254=>555,255=>500);
+
+// --- EOF ---

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/fonts/helveticab.php

@@ -0,0 +1,12 @@
+<?php
+// TCPDF FONT FILE DESCRIPTION
+$type='core';
+$name='Helvetica-Bold';
+$up=-100;
+$ut=50;
+$dw=535;
+$diff='';
+$enc='';
+$desc=array('Flags'=>32,'FontBBox'=>'[-170 -228 1003 962]','ItalicAngle'=>0,'Ascent'=>962,'Descent'=>-228,'Leading'=>0,'CapHeight'=>718,'XHeight'=>532,'StemV'=>140,'StemH'=>118,'AvgWidth'=>535,'MaxWidth'=>1000,'MissingWidth'=>535);
+$cw=array(0=>278,1=>278,2=>278,3=>278,4=>278,5=>278,6=>278,7=>278,8=>278,9=>278,10=>278,11=>278,12=>278,13=>278,14=>278,15=>278,16=>278,17=>278,18=>278,19=>278,20=>278,21=>278,22=>278,23=>278,24=>278,25=>278,26=>278,27=>278,28=>278,29=>278,30=>278,31=>278,32=>278,33=>333,34=>474,35=>556,36=>556,37=>889,38=>722,39=>238,40=>333,41=>333,42=>389,43=>584,44=>278,45=>333,46=>278,47=>278,48=>556,49=>556,50=>556,51=>556,52=>556,53=>556,54=>556,55=>556,56=>556,57=>556,58=>333,59=>333,60=>584,61=>584,62=>584,63=>611,64=>975,65=>722,66=>722,67=>722,68=>722,69=>667,70=>611,71=>778,72=>722,73=>278,74=>556,75=>722,76=>611,77=>833,78=>722,79=>778,80=>667,81=>778,82=>722,83=>667,84=>611,85=>722,86=>667,87=>944,88=>667,89=>667,90=>611,91=>333,92=>278,93=>333,94=>584,95=>556,96=>333,97=>556,98=>611,99=>556,100=>611,101=>556,102=>333,103=>611,104=>611,105=>278,106=>278,107=>556,108=>278,109=>889,110=>611,111=>611,112=>611,113=>611,114=>389,115=>556,116=>333,117=>611,118=>556,119=>778,120=>556,121=>556,122=>500,123=>389,124=>280,125=>389,126=>584,127=>350,128=>556,129=>350,130=>278,131=>556,132=>500,133=>1000,134=>556,135=>556,136=>333,137=>1000,138=>667,139=>333,140=>1000,141=>350,142=>611,143=>350,144=>350,145=>278,146=>278,147=>500,148=>500,149=>350,150=>556,151=>1000,152=>333,153=>1000,154=>556,155=>333,156=>944,157=>350,158=>500,159=>667,160=>278,161=>333,162=>556,163=>556,164=>556,165=>556,166=>280,167=>556,168=>333,169=>737,170=>370,171=>556,172=>584,173=>333,174=>737,175=>333,176=>400,177=>584,178=>333,179=>333,180=>333,181=>611,182=>556,183=>278,184=>333,185=>333,186=>365,187=>556,188=>834,189=>834,190=>834,191=>611,192=>722,193=>722,194=>722,195=>722,196=>722,197=>722,198=>1000,199=>722,200=>667,201=>667,202=>667,203=>667,204=>278,205=>278,206=>278,207=>278,208=>722,209=>722,210=>778,211=>778,212=>778,213=>778,214=>778,215=>584,216=>778,217=>722,218=>722,219=>722,220=>722,221=>667,222=>667,223=>611,224=>556,225=>556,226=>556,227=>556,228=>556,229=>556,230=>889,231=>556,232=>556,233=>556,234=>556,235=>556,236=>278,237=>278,238=>278,239=>278,240=>611,241=>611,242=>611,243=>611,244=>611,245=>611,246=>611,247=>584,248=>611,249=>611,250=>611,251=>611,252=>611,253=>556,254=>611,255=>556);
+// --- EOF ---

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/fonts/helveticabi.php

@@ -0,0 +1,12 @@
+<?php
+// TCPDF FONT FILE DESCRIPTION
+$type='core';
+$name='Helvetica-BoldOblique';
+$up=-100;
+$ut=50;
+$dw=535;
+$diff='';
+$enc='';
+$desc=array('Flags'=>96,'FontBBox'=>'[-174 -228 1114 962]','ItalicAngle'=>-12,'Ascent'=>962,'Descent'=>-228,'Leading'=>0,'CapHeight'=>718,'XHeight'=>532,'StemV'=>140,'StemH'=>118,'AvgWidth'=>535,'MaxWidth'=>1000,'MissingWidth'=>535);
+$cw=array(0=>278,1=>278,2=>278,3=>278,4=>278,5=>278,6=>278,7=>278,8=>278,9=>278,10=>278,11=>278,12=>278,13=>278,14=>278,15=>278,16=>278,17=>278,18=>278,19=>278,20=>278,21=>278,22=>278,23=>278,24=>278,25=>278,26=>278,27=>278,28=>278,29=>278,30=>278,31=>278,32=>278,33=>333,34=>474,35=>556,36=>556,37=>889,38=>722,39=>238,40=>333,41=>333,42=>389,43=>584,44=>278,45=>333,46=>278,47=>278,48=>556,49=>556,50=>556,51=>556,52=>556,53=>556,54=>556,55=>556,56=>556,57=>556,58=>333,59=>333,60=>584,61=>584,62=>584,63=>611,64=>975,65=>722,66=>722,67=>722,68=>722,69=>667,70=>611,71=>778,72=>722,73=>278,74=>556,75=>722,76=>611,77=>833,78=>722,79=>778,80=>667,81=>778,82=>722,83=>667,84=>611,85=>722,86=>667,87=>944,88=>667,89=>667,90=>611,91=>333,92=>278,93=>333,94=>584,95=>556,96=>333,97=>556,98=>611,99=>556,100=>611,101=>556,102=>333,103=>611,104=>611,105=>278,106=>278,107=>556,108=>278,109=>889,110=>611,111=>611,112=>611,113=>611,114=>389,115=>556,116=>333,117=>611,118=>556,119=>778,120=>556,121=>556,122=>500,123=>389,124=>280,125=>389,126=>584,127=>350,128=>556,129=>350,130=>278,131=>556,132=>500,133=>1000,134=>556,135=>556,136=>333,137=>1000,138=>667,139=>333,140=>1000,141=>350,142=>611,143=>350,144=>350,145=>278,146=>278,147=>500,148=>500,149=>350,150=>556,151=>1000,152=>333,153=>1000,154=>556,155=>333,156=>944,157=>350,158=>500,159=>667,160=>278,161=>333,162=>556,163=>556,164=>556,165=>556,166=>280,167=>556,168=>333,169=>737,170=>370,171=>556,172=>584,173=>333,174=>737,175=>333,176=>400,177=>584,178=>333,179=>333,180=>333,181=>611,182=>556,183=>278,184=>333,185=>333,186=>365,187=>556,188=>834,189=>834,190=>834,191=>611,192=>722,193=>722,194=>722,195=>722,196=>722,197=>722,198=>1000,199=>722,200=>667,201=>667,202=>667,203=>667,204=>278,205=>278,206=>278,207=>278,208=>722,209=>722,210=>778,211=>778,212=>778,213=>778,214=>778,215=>584,216=>778,217=>722,218=>722,219=>722,220=>722,221=>667,222=>667,223=>611,224=>556,225=>556,226=>556,227=>556,228=>556,229=>556,230=>889,231=>556,232=>556,233=>556,234=>556,235=>556,236=>278,237=>278,238=>278,239=>278,240=>611,241=>611,242=>611,243=>611,244=>611,245=>611,246=>611,247=>584,248=>611,249=>611,250=>611,251=>611,252=>611,253=>556,254=>611,255=>556);
+// --- EOF ---

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/fonts/helveticai.php

@@ -0,0 +1,12 @@
+<?php
+// TCPDF FONT FILE DESCRIPTION
+$type='core';
+$name='Helvetica-Oblique';
+$up=-100;
+$ut=50;
+$dw=513;
+$diff='';
+$enc='';
+$desc=array('Flags'=>96,'FontBBox'=>'[-170 -225 1116 931]','ItalicAngle'=>-12,'Ascent'=>931,'Descent'=>-225,'Leading'=>0,'CapHeight'=>718,'XHeight'=>523,'StemV'=>88,'StemH'=>76,'AvgWidth'=>513,'MaxWidth'=>1015,'MissingWidth'=>513);
+$cw=array(0=>278,1=>278,2=>278,3=>278,4=>278,5=>278,6=>278,7=>278,8=>278,9=>278,10=>278,11=>278,12=>278,13=>278,14=>278,15=>278,16=>278,17=>278,18=>278,19=>278,20=>278,21=>278,22=>278,23=>278,24=>278,25=>278,26=>278,27=>278,28=>278,29=>278,30=>278,31=>278,32=>278,33=>278,34=>355,35=>556,36=>556,37=>889,38=>667,39=>191,40=>333,41=>333,42=>389,43=>584,44=>278,45=>333,46=>278,47=>278,48=>556,49=>556,50=>556,51=>556,52=>556,53=>556,54=>556,55=>556,56=>556,57=>556,58=>278,59=>278,60=>584,61=>584,62=>584,63=>556,64=>1015,65=>667,66=>667,67=>722,68=>722,69=>667,70=>611,71=>778,72=>722,73=>278,74=>500,75=>667,76=>556,77=>833,78=>722,79=>778,80=>667,81=>778,82=>722,83=>667,84=>611,85=>722,86=>667,87=>944,88=>667,89=>667,90=>611,91=>278,92=>278,93=>278,94=>469,95=>556,96=>333,97=>556,98=>556,99=>500,100=>556,101=>556,102=>278,103=>556,104=>556,105=>222,106=>222,107=>500,108=>222,109=>833,110=>556,111=>556,112=>556,113=>556,114=>333,115=>500,116=>278,117=>556,118=>500,119=>722,120=>500,121=>500,122=>500,123=>334,124=>260,125=>334,126=>584,127=>350,128=>556,129=>350,130=>222,131=>556,132=>333,133=>1000,134=>556,135=>556,136=>333,137=>1000,138=>667,139=>333,140=>1000,141=>350,142=>611,143=>350,144=>350,145=>222,146=>222,147=>333,148=>333,149=>350,150=>556,151=>1000,152=>333,153=>1000,154=>500,155=>333,156=>944,157=>350,158=>500,159=>667,160=>278,161=>333,162=>556,163=>556,164=>556,165=>556,166=>260,167=>556,168=>333,169=>737,170=>370,171=>556,172=>584,173=>333,174=>737,175=>333,176=>400,177=>584,178=>333,179=>333,180=>333,181=>556,182=>537,183=>278,184=>333,185=>333,186=>365,187=>556,188=>834,189=>834,190=>834,191=>611,192=>667,193=>667,194=>667,195=>667,196=>667,197=>667,198=>1000,199=>722,200=>667,201=>667,202=>667,203=>667,204=>278,205=>278,206=>278,207=>278,208=>722,209=>722,210=>778,211=>778,212=>778,213=>778,214=>778,215=>584,216=>778,217=>722,218=>722,219=>722,220=>722,221=>667,222=>667,223=>611,224=>556,225=>556,226=>556,227=>556,228=>556,229=>556,230=>889,231=>500,232=>556,233=>556,234=>556,235=>556,236=>278,237=>278,238=>278,239=>278,240=>556,241=>556,242=>556,243=>556,244=>556,245=>556,246=>556,247=>584,248=>611,249=>556,250=>556,251=>556,252=>556,253=>500,254=>556,255=>500);
+// --- EOF ---

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/include/barcodes/pdf417.php

@@ -0,0 +1,996 @@
+<?php
+//============================================================+
+// File name   : pdf417.php
+// Version     : 1.0.005
+// Begin       : 2010-06-03
+// Last Update : 2014-04-25
+// Author      : Nicola Asuni - Tecnick.com LTD - www.tecnick.com - info@tecnick.com
+// License     : GNU-LGPL v3 (https://www.gnu.org/copyleft/lesser.html)
+// -------------------------------------------------------------------
+// Copyright (C) 2010-2013 2026 Nicola Asuni - Tecnick.com LTD
+//
+// This file is part of TCPDF software library.
+//
+// TCPDF is free software: you can redistribute it and/or modify it
+// under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// TCPDF is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with TCPDF.  If not, see <https://www.gnu.org/licenses/>.
+//
+// See LICENSE.TXT file for more information.
+// -------------------------------------------------------------------
+//
+// DESCRIPTION :
+//
+// Class to create PDF417 barcode arrays for TCPDF class.
+// PDF417 (ISO/IEC 15438:2006) is a 2-dimensional stacked bar code created by Symbol Technologies in 1991.
+// It is one of the most popular 2D codes because of its ability to be read with slightly modified handheld laser or linear CCD scanners.
+// TECHNICAL DATA / FEATURES OF PDF417:
+//		Encodable Character Set:     All 128 ASCII Characters (including extended)
+//		Code Type:                   Continuous, Multi-Row
+//		Symbol Height:               3 - 90 Rows
+//		Symbol Width:                90X - 583X
+//		Bidirectional Decoding:      Yes
+//		Error Correction Characters: 2 - 512
+//		Maximum Data Characters:     1850 text, 2710 digits, 1108 bytes
+//
+//============================================================+
+
+/**
+ * @file
+ * Class to create PDF417 barcode arrays for TCPDF class.
+ * PDF417 (ISO/IEC 15438:2006) is a 2-dimensional stacked bar code created by Symbol Technologies in 1991.
+ * (requires PHP bcmath extension)
+ * @package com.tecnick.tcpdf
+ * @author Nicola Asuni
+ * @version 1.0.005
+ */
+
+// definitions
+if (!defined('PDF417DEFS')) {
+
+	/**
+	 * Indicate that definitions for this class are set
+	 */
+	define('PDF417DEFS', true);
+
+	// -----------------------------------------------------
+
+	/**
+	 * Row height respect X dimension of single module
+	 */
+	define('ROWHEIGHT', 4);
+
+	/**
+	 * Horizontal quiet zone in modules
+	 */
+	define('QUIETH', 2);
+
+	/**
+	 * Vertical quiet zone in modules
+	 */
+	define('QUIETV', 2);
+
+} // end of definitions
+
+// #*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#
+
+/**
+ * @class PDF417
+ * Class to create PDF417 barcode arrays for TCPDF class.
+ * PDF417 (ISO/IEC 15438:2006) is a 2-dimensional stacked bar code created by Symbol Technologies in 1991.
+ * @package com.tecnick.tcpdf
+ * @author Nicola Asuni
+ * @version 1.0.003
+ */
+class PDF417 {
+
+	/**
+	 * Barcode array to be returned which is readable by TCPDF.
+	 * @protected
+	 */
+	protected $barcode_array = array();
+
+	/**
+	 * Start pattern.
+	 * @protected
+	 */
+	protected $start_pattern = '11111111010101000';
+
+	/**
+	 * Stop pattern.
+	 * @protected
+	 */
+	protected $stop_pattern = '111111101000101001';
+
+	/**
+	 * Array of text Compaction Sub-Modes (values 0xFB - 0xFF are used for submode changers).
+	 * @protected
+	 */
+	protected $textsubmodes = array(
+		array(0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x20,0xFD,0xFE,0xFF), // Alpha
+		array(0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x20,0xFD,0xFE,0xFF), // Lower
+		array(0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x26,0x0d,0x09,0x2c,0x3a,0x23,0x2d,0x2e,0x24,0x2f,0x2b,0x25,0x2a,0x3d,0x5e,0xFB,0x20,0xFD,0xFE,0xFF), // Mixed
+		array(0x3b,0x3c,0x3e,0x40,0x5b,0x5c,0x5d,0x5f,0x60,0x7e,0x21,0x0d,0x09,0x2c,0x3a,0x0a,0x2d,0x2e,0x24,0x2f,0x22,0x7c,0x2a,0x28,0x29,0x3f,0x7b,0x7d,0x27,0xFF) // Puntuaction
+	);
+
+	/**
+	 * Array of switching codes for Text Compaction Sub-Modes.
+	 * @protected
+	 */
+	protected $textlatch = array(
+		'01' => array(27), '02' => array(28), '03' => array(28,25), //
+		'10' => array(28,28), '12' => array(28), '13' => array(28,25), //
+		'20' => array(28), '21' => array(27), '23' => array(25), //
+		'30' => array(29), '31' => array(29,27), '32' => array(29,28) //
+	);
+
+	/**
+	 * Clusters of codewords (0, 3, 6)<br/>
+	 * Values are hex equivalents of binary representation of bars (1 = bar, 0 = space).<br/>
+	 * The codewords numbered from 900 to 928 have special meaning, some enable to switch between modes in order to optimise the code:<ul>
+	 * <li>900 : Switch to "Text" mode</li>
+	 * <li>901 : Switch to "Byte" mode</li>
+	 * <li>902 : Switch to "Numeric" mode</li>
+	 * <li>903 - 912 : Reserved</li>
+	 * <li>913 : Switch to "Octet" only for the next codeword</li>
+	 * <li>914 - 920 : Reserved</li>
+	 * <li>921 : Initialization</li>
+	 * <li>922 : Terminator codeword for Macro PDF control block</li>
+	 * <li>923 : Sequence tag to identify the beginning of optional fields in the Macro PDF control block</li>
+	 * <li>924 : Switch to "Byte" mode (If the total number of byte is multiple of 6)</li>
+	 * <li>925 : Identifier for a user defined Extended Channel Interpretation (ECI)</li>
+	 * <li>926 : Identifier for a general purpose ECI format</li>
+	 * <li>927 : Identifier for an ECI of a character set or code page</li>
+	 * <li>928 : Macro marker codeword to indicate the beginning of a Macro PDF Control Block</li>
+	 * </ul>
+	 * @protected
+	 */
+	protected $clusters = array(
+		array( // cluster 0 -----------------------------------------------------------------------
+			0x1d5c0,0x1eaf0,0x1f57c,0x1d4e0,0x1ea78,0x1f53e,0x1a8c0,0x1d470,0x1a860,0x15040, //  10
+			0x1a830,0x15020,0x1adc0,0x1d6f0,0x1eb7c,0x1ace0,0x1d678,0x1eb3e,0x158c0,0x1ac70, //  20
+			0x15860,0x15dc0,0x1aef0,0x1d77c,0x15ce0,0x1ae78,0x1d73e,0x15c70,0x1ae3c,0x15ef0, //  30
+			0x1af7c,0x15e78,0x1af3e,0x15f7c,0x1f5fa,0x1d2e0,0x1e978,0x1f4be,0x1a4c0,0x1d270, //  40
+			0x1e93c,0x1a460,0x1d238,0x14840,0x1a430,0x1d21c,0x14820,0x1a418,0x14810,0x1a6e0, //  50
+			0x1d378,0x1e9be,0x14cc0,0x1a670,0x1d33c,0x14c60,0x1a638,0x1d31e,0x14c30,0x1a61c, //  60
+			0x14ee0,0x1a778,0x1d3be,0x14e70,0x1a73c,0x14e38,0x1a71e,0x14f78,0x1a7be,0x14f3c, //  70
+			0x14f1e,0x1a2c0,0x1d170,0x1e8bc,0x1a260,0x1d138,0x1e89e,0x14440,0x1a230,0x1d11c, //  80
+			0x14420,0x1a218,0x14410,0x14408,0x146c0,0x1a370,0x1d1bc,0x14660,0x1a338,0x1d19e, //  90
+			0x14630,0x1a31c,0x14618,0x1460c,0x14770,0x1a3bc,0x14738,0x1a39e,0x1471c,0x147bc, // 100
+			0x1a160,0x1d0b8,0x1e85e,0x14240,0x1a130,0x1d09c,0x14220,0x1a118,0x1d08e,0x14210, // 110
+			0x1a10c,0x14208,0x1a106,0x14360,0x1a1b8,0x1d0de,0x14330,0x1a19c,0x14318,0x1a18e, // 120
+			0x1430c,0x14306,0x1a1de,0x1438e,0x14140,0x1a0b0,0x1d05c,0x14120,0x1a098,0x1d04e, // 130
+			0x14110,0x1a08c,0x14108,0x1a086,0x14104,0x141b0,0x14198,0x1418c,0x140a0,0x1d02e, // 140
+			0x1a04c,0x1a046,0x14082,0x1cae0,0x1e578,0x1f2be,0x194c0,0x1ca70,0x1e53c,0x19460, // 150
+			0x1ca38,0x1e51e,0x12840,0x19430,0x12820,0x196e0,0x1cb78,0x1e5be,0x12cc0,0x19670, // 160
+			0x1cb3c,0x12c60,0x19638,0x12c30,0x12c18,0x12ee0,0x19778,0x1cbbe,0x12e70,0x1973c, // 170
+			0x12e38,0x12e1c,0x12f78,0x197be,0x12f3c,0x12fbe,0x1dac0,0x1ed70,0x1f6bc,0x1da60, // 180
+			0x1ed38,0x1f69e,0x1b440,0x1da30,0x1ed1c,0x1b420,0x1da18,0x1ed0e,0x1b410,0x1da0c, // 190
+			0x192c0,0x1c970,0x1e4bc,0x1b6c0,0x19260,0x1c938,0x1e49e,0x1b660,0x1db38,0x1ed9e, // 200
+			0x16c40,0x12420,0x19218,0x1c90e,0x16c20,0x1b618,0x16c10,0x126c0,0x19370,0x1c9bc, // 210
+			0x16ec0,0x12660,0x19338,0x1c99e,0x16e60,0x1b738,0x1db9e,0x16e30,0x12618,0x16e18, // 220
+			0x12770,0x193bc,0x16f70,0x12738,0x1939e,0x16f38,0x1b79e,0x16f1c,0x127bc,0x16fbc, // 230
+			0x1279e,0x16f9e,0x1d960,0x1ecb8,0x1f65e,0x1b240,0x1d930,0x1ec9c,0x1b220,0x1d918, // 240
+			0x1ec8e,0x1b210,0x1d90c,0x1b208,0x1b204,0x19160,0x1c8b8,0x1e45e,0x1b360,0x19130, // 250
+			0x1c89c,0x16640,0x12220,0x1d99c,0x1c88e,0x16620,0x12210,0x1910c,0x16610,0x1b30c, // 260
+			0x19106,0x12204,0x12360,0x191b8,0x1c8de,0x16760,0x12330,0x1919c,0x16730,0x1b39c, // 270
+			0x1918e,0x16718,0x1230c,0x12306,0x123b8,0x191de,0x167b8,0x1239c,0x1679c,0x1238e, // 280
+			0x1678e,0x167de,0x1b140,0x1d8b0,0x1ec5c,0x1b120,0x1d898,0x1ec4e,0x1b110,0x1d88c, // 290
+			0x1b108,0x1d886,0x1b104,0x1b102,0x12140,0x190b0,0x1c85c,0x16340,0x12120,0x19098, // 300
+			0x1c84e,0x16320,0x1b198,0x1d8ce,0x16310,0x12108,0x19086,0x16308,0x1b186,0x16304, // 310
+			0x121b0,0x190dc,0x163b0,0x12198,0x190ce,0x16398,0x1b1ce,0x1638c,0x12186,0x16386, // 320
+			0x163dc,0x163ce,0x1b0a0,0x1d858,0x1ec2e,0x1b090,0x1d84c,0x1b088,0x1d846,0x1b084, // 330
+			0x1b082,0x120a0,0x19058,0x1c82e,0x161a0,0x12090,0x1904c,0x16190,0x1b0cc,0x19046, // 340
+			0x16188,0x12084,0x16184,0x12082,0x120d8,0x161d8,0x161cc,0x161c6,0x1d82c,0x1d826, // 350
+			0x1b042,0x1902c,0x12048,0x160c8,0x160c4,0x160c2,0x18ac0,0x1c570,0x1e2bc,0x18a60, // 360
+			0x1c538,0x11440,0x18a30,0x1c51c,0x11420,0x18a18,0x11410,0x11408,0x116c0,0x18b70, // 370
+			0x1c5bc,0x11660,0x18b38,0x1c59e,0x11630,0x18b1c,0x11618,0x1160c,0x11770,0x18bbc, // 380
+			0x11738,0x18b9e,0x1171c,0x117bc,0x1179e,0x1cd60,0x1e6b8,0x1f35e,0x19a40,0x1cd30, // 390
+			0x1e69c,0x19a20,0x1cd18,0x1e68e,0x19a10,0x1cd0c,0x19a08,0x1cd06,0x18960,0x1c4b8, // 400
+			0x1e25e,0x19b60,0x18930,0x1c49c,0x13640,0x11220,0x1cd9c,0x1c48e,0x13620,0x19b18, // 410
+			0x1890c,0x13610,0x11208,0x13608,0x11360,0x189b8,0x1c4de,0x13760,0x11330,0x1cdde, // 420
+			0x13730,0x19b9c,0x1898e,0x13718,0x1130c,0x1370c,0x113b8,0x189de,0x137b8,0x1139c, // 430
+			0x1379c,0x1138e,0x113de,0x137de,0x1dd40,0x1eeb0,0x1f75c,0x1dd20,0x1ee98,0x1f74e, // 440
+			0x1dd10,0x1ee8c,0x1dd08,0x1ee86,0x1dd04,0x19940,0x1ccb0,0x1e65c,0x1bb40,0x19920, // 450
+			0x1eedc,0x1e64e,0x1bb20,0x1dd98,0x1eece,0x1bb10,0x19908,0x1cc86,0x1bb08,0x1dd86, // 460
+			0x19902,0x11140,0x188b0,0x1c45c,0x13340,0x11120,0x18898,0x1c44e,0x17740,0x13320, // 470
+			0x19998,0x1ccce,0x17720,0x1bb98,0x1ddce,0x18886,0x17710,0x13308,0x19986,0x17708, // 480
+			0x11102,0x111b0,0x188dc,0x133b0,0x11198,0x188ce,0x177b0,0x13398,0x199ce,0x17798, // 490
+			0x1bbce,0x11186,0x13386,0x111dc,0x133dc,0x111ce,0x177dc,0x133ce,0x1dca0,0x1ee58, // 500
+			0x1f72e,0x1dc90,0x1ee4c,0x1dc88,0x1ee46,0x1dc84,0x1dc82,0x198a0,0x1cc58,0x1e62e, // 510
+			0x1b9a0,0x19890,0x1ee6e,0x1b990,0x1dccc,0x1cc46,0x1b988,0x19884,0x1b984,0x19882, // 520
+			0x1b982,0x110a0,0x18858,0x1c42e,0x131a0,0x11090,0x1884c,0x173a0,0x13190,0x198cc, // 530
+			0x18846,0x17390,0x1b9cc,0x11084,0x17388,0x13184,0x11082,0x13182,0x110d8,0x1886e, // 540
+			0x131d8,0x110cc,0x173d8,0x131cc,0x110c6,0x173cc,0x131c6,0x110ee,0x173ee,0x1dc50, // 550
+			0x1ee2c,0x1dc48,0x1ee26,0x1dc44,0x1dc42,0x19850,0x1cc2c,0x1b8d0,0x19848,0x1cc26, // 560
+			0x1b8c8,0x1dc66,0x1b8c4,0x19842,0x1b8c2,0x11050,0x1882c,0x130d0,0x11048,0x18826, // 570
+			0x171d0,0x130c8,0x19866,0x171c8,0x1b8e6,0x11042,0x171c4,0x130c2,0x171c2,0x130ec, // 580
+			0x171ec,0x171e6,0x1ee16,0x1dc22,0x1cc16,0x19824,0x19822,0x11028,0x13068,0x170e8, // 590
+			0x11022,0x13062,0x18560,0x10a40,0x18530,0x10a20,0x18518,0x1c28e,0x10a10,0x1850c, // 600
+			0x10a08,0x18506,0x10b60,0x185b8,0x1c2de,0x10b30,0x1859c,0x10b18,0x1858e,0x10b0c, // 610
+			0x10b06,0x10bb8,0x185de,0x10b9c,0x10b8e,0x10bde,0x18d40,0x1c6b0,0x1e35c,0x18d20, // 620
+			0x1c698,0x18d10,0x1c68c,0x18d08,0x1c686,0x18d04,0x10940,0x184b0,0x1c25c,0x11b40, // 630
+			0x10920,0x1c6dc,0x1c24e,0x11b20,0x18d98,0x1c6ce,0x11b10,0x10908,0x18486,0x11b08, // 640
+			0x18d86,0x10902,0x109b0,0x184dc,0x11bb0,0x10998,0x184ce,0x11b98,0x18dce,0x11b8c, // 650
+			0x10986,0x109dc,0x11bdc,0x109ce,0x11bce,0x1cea0,0x1e758,0x1f3ae,0x1ce90,0x1e74c, // 660
+			0x1ce88,0x1e746,0x1ce84,0x1ce82,0x18ca0,0x1c658,0x19da0,0x18c90,0x1c64c,0x19d90, // 670
+			0x1cecc,0x1c646,0x19d88,0x18c84,0x19d84,0x18c82,0x19d82,0x108a0,0x18458,0x119a0, // 680
+			0x10890,0x1c66e,0x13ba0,0x11990,0x18ccc,0x18446,0x13b90,0x19dcc,0x10884,0x13b88, // 690
+			0x11984,0x10882,0x11982,0x108d8,0x1846e,0x119d8,0x108cc,0x13bd8,0x119cc,0x108c6, // 700
+			0x13bcc,0x119c6,0x108ee,0x119ee,0x13bee,0x1ef50,0x1f7ac,0x1ef48,0x1f7a6,0x1ef44, // 710
+			0x1ef42,0x1ce50,0x1e72c,0x1ded0,0x1ef6c,0x1e726,0x1dec8,0x1ef66,0x1dec4,0x1ce42, // 720
+			0x1dec2,0x18c50,0x1c62c,0x19cd0,0x18c48,0x1c626,0x1bdd0,0x19cc8,0x1ce66,0x1bdc8, // 730
+			0x1dee6,0x18c42,0x1bdc4,0x19cc2,0x1bdc2,0x10850,0x1842c,0x118d0,0x10848,0x18426, // 740
+			0x139d0,0x118c8,0x18c66,0x17bd0,0x139c8,0x19ce6,0x10842,0x17bc8,0x1bde6,0x118c2, // 750
+			0x17bc4,0x1086c,0x118ec,0x10866,0x139ec,0x118e6,0x17bec,0x139e6,0x17be6,0x1ef28, // 760
+			0x1f796,0x1ef24,0x1ef22,0x1ce28,0x1e716,0x1de68,0x1ef36,0x1de64,0x1ce22,0x1de62, // 770
+			0x18c28,0x1c616,0x19c68,0x18c24,0x1bce8,0x19c64,0x18c22,0x1bce4,0x19c62,0x1bce2, // 780
+			0x10828,0x18416,0x11868,0x18c36,0x138e8,0x11864,0x10822,0x179e8,0x138e4,0x11862, // 790
+			0x179e4,0x138e2,0x179e2,0x11876,0x179f6,0x1ef12,0x1de34,0x1de32,0x19c34,0x1bc74, // 800
+			0x1bc72,0x11834,0x13874,0x178f4,0x178f2,0x10540,0x10520,0x18298,0x10510,0x10508, // 810
+			0x10504,0x105b0,0x10598,0x1058c,0x10586,0x105dc,0x105ce,0x186a0,0x18690,0x1c34c, // 820
+			0x18688,0x1c346,0x18684,0x18682,0x104a0,0x18258,0x10da0,0x186d8,0x1824c,0x10d90, // 830
+			0x186cc,0x10d88,0x186c6,0x10d84,0x10482,0x10d82,0x104d8,0x1826e,0x10dd8,0x186ee, // 840
+			0x10dcc,0x104c6,0x10dc6,0x104ee,0x10dee,0x1c750,0x1c748,0x1c744,0x1c742,0x18650, // 850
+			0x18ed0,0x1c76c,0x1c326,0x18ec8,0x1c766,0x18ec4,0x18642,0x18ec2,0x10450,0x10cd0, // 860
+			0x10448,0x18226,0x11dd0,0x10cc8,0x10444,0x11dc8,0x10cc4,0x10442,0x11dc4,0x10cc2, // 870
+			0x1046c,0x10cec,0x10466,0x11dec,0x10ce6,0x11de6,0x1e7a8,0x1e7a4,0x1e7a2,0x1c728, // 880
+			0x1cf68,0x1e7b6,0x1cf64,0x1c722,0x1cf62,0x18628,0x1c316,0x18e68,0x1c736,0x19ee8, // 890
+			0x18e64,0x18622,0x19ee4,0x18e62,0x19ee2,0x10428,0x18216,0x10c68,0x18636,0x11ce8, // 900
+			0x10c64,0x10422,0x13de8,0x11ce4,0x10c62,0x13de4,0x11ce2,0x10436,0x10c76,0x11cf6, // 910
+			0x13df6,0x1f7d4,0x1f7d2,0x1e794,0x1efb4,0x1e792,0x1efb2,0x1c714,0x1cf34,0x1c712, // 920
+			0x1df74,0x1cf32,0x1df72,0x18614,0x18e34,0x18612,0x19e74,0x18e32,0x1bef4),        // 929
+		array( // cluster 3 -----------------------------------------------------------------------
+			0x1f560,0x1fab8,0x1ea40,0x1f530,0x1fa9c,0x1ea20,0x1f518,0x1fa8e,0x1ea10,0x1f50c, //  10
+			0x1ea08,0x1f506,0x1ea04,0x1eb60,0x1f5b8,0x1fade,0x1d640,0x1eb30,0x1f59c,0x1d620, //  20
+			0x1eb18,0x1f58e,0x1d610,0x1eb0c,0x1d608,0x1eb06,0x1d604,0x1d760,0x1ebb8,0x1f5de, //  30
+			0x1ae40,0x1d730,0x1eb9c,0x1ae20,0x1d718,0x1eb8e,0x1ae10,0x1d70c,0x1ae08,0x1d706, //  40
+			0x1ae04,0x1af60,0x1d7b8,0x1ebde,0x15e40,0x1af30,0x1d79c,0x15e20,0x1af18,0x1d78e, //  50
+			0x15e10,0x1af0c,0x15e08,0x1af06,0x15f60,0x1afb8,0x1d7de,0x15f30,0x1af9c,0x15f18, //  60
+			0x1af8e,0x15f0c,0x15fb8,0x1afde,0x15f9c,0x15f8e,0x1e940,0x1f4b0,0x1fa5c,0x1e920, //  70
+			0x1f498,0x1fa4e,0x1e910,0x1f48c,0x1e908,0x1f486,0x1e904,0x1e902,0x1d340,0x1e9b0, //  80
+			0x1f4dc,0x1d320,0x1e998,0x1f4ce,0x1d310,0x1e98c,0x1d308,0x1e986,0x1d304,0x1d302, //  90
+			0x1a740,0x1d3b0,0x1e9dc,0x1a720,0x1d398,0x1e9ce,0x1a710,0x1d38c,0x1a708,0x1d386, // 100
+			0x1a704,0x1a702,0x14f40,0x1a7b0,0x1d3dc,0x14f20,0x1a798,0x1d3ce,0x14f10,0x1a78c, // 110
+			0x14f08,0x1a786,0x14f04,0x14fb0,0x1a7dc,0x14f98,0x1a7ce,0x14f8c,0x14f86,0x14fdc, // 120
+			0x14fce,0x1e8a0,0x1f458,0x1fa2e,0x1e890,0x1f44c,0x1e888,0x1f446,0x1e884,0x1e882, // 130
+			0x1d1a0,0x1e8d8,0x1f46e,0x1d190,0x1e8cc,0x1d188,0x1e8c6,0x1d184,0x1d182,0x1a3a0, // 140
+			0x1d1d8,0x1e8ee,0x1a390,0x1d1cc,0x1a388,0x1d1c6,0x1a384,0x1a382,0x147a0,0x1a3d8, // 150
+			0x1d1ee,0x14790,0x1a3cc,0x14788,0x1a3c6,0x14784,0x14782,0x147d8,0x1a3ee,0x147cc, // 160
+			0x147c6,0x147ee,0x1e850,0x1f42c,0x1e848,0x1f426,0x1e844,0x1e842,0x1d0d0,0x1e86c, // 170
+			0x1d0c8,0x1e866,0x1d0c4,0x1d0c2,0x1a1d0,0x1d0ec,0x1a1c8,0x1d0e6,0x1a1c4,0x1a1c2, // 180
+			0x143d0,0x1a1ec,0x143c8,0x1a1e6,0x143c4,0x143c2,0x143ec,0x143e6,0x1e828,0x1f416, // 190
+			0x1e824,0x1e822,0x1d068,0x1e836,0x1d064,0x1d062,0x1a0e8,0x1d076,0x1a0e4,0x1a0e2, // 200
+			0x141e8,0x1a0f6,0x141e4,0x141e2,0x1e814,0x1e812,0x1d034,0x1d032,0x1a074,0x1a072, // 210
+			0x1e540,0x1f2b0,0x1f95c,0x1e520,0x1f298,0x1f94e,0x1e510,0x1f28c,0x1e508,0x1f286, // 220
+			0x1e504,0x1e502,0x1cb40,0x1e5b0,0x1f2dc,0x1cb20,0x1e598,0x1f2ce,0x1cb10,0x1e58c, // 230
+			0x1cb08,0x1e586,0x1cb04,0x1cb02,0x19740,0x1cbb0,0x1e5dc,0x19720,0x1cb98,0x1e5ce, // 240
+			0x19710,0x1cb8c,0x19708,0x1cb86,0x19704,0x19702,0x12f40,0x197b0,0x1cbdc,0x12f20, // 250
+			0x19798,0x1cbce,0x12f10,0x1978c,0x12f08,0x19786,0x12f04,0x12fb0,0x197dc,0x12f98, // 260
+			0x197ce,0x12f8c,0x12f86,0x12fdc,0x12fce,0x1f6a0,0x1fb58,0x16bf0,0x1f690,0x1fb4c, // 270
+			0x169f8,0x1f688,0x1fb46,0x168fc,0x1f684,0x1f682,0x1e4a0,0x1f258,0x1f92e,0x1eda0, // 280
+			0x1e490,0x1fb6e,0x1ed90,0x1f6cc,0x1f246,0x1ed88,0x1e484,0x1ed84,0x1e482,0x1ed82, // 290
+			0x1c9a0,0x1e4d8,0x1f26e,0x1dba0,0x1c990,0x1e4cc,0x1db90,0x1edcc,0x1e4c6,0x1db88, // 300
+			0x1c984,0x1db84,0x1c982,0x1db82,0x193a0,0x1c9d8,0x1e4ee,0x1b7a0,0x19390,0x1c9cc, // 310
+			0x1b790,0x1dbcc,0x1c9c6,0x1b788,0x19384,0x1b784,0x19382,0x1b782,0x127a0,0x193d8, // 320
+			0x1c9ee,0x16fa0,0x12790,0x193cc,0x16f90,0x1b7cc,0x193c6,0x16f88,0x12784,0x16f84, // 330
+			0x12782,0x127d8,0x193ee,0x16fd8,0x127cc,0x16fcc,0x127c6,0x16fc6,0x127ee,0x1f650, // 340
+			0x1fb2c,0x165f8,0x1f648,0x1fb26,0x164fc,0x1f644,0x1647e,0x1f642,0x1e450,0x1f22c, // 350
+			0x1ecd0,0x1e448,0x1f226,0x1ecc8,0x1f666,0x1ecc4,0x1e442,0x1ecc2,0x1c8d0,0x1e46c, // 360
+			0x1d9d0,0x1c8c8,0x1e466,0x1d9c8,0x1ece6,0x1d9c4,0x1c8c2,0x1d9c2,0x191d0,0x1c8ec, // 370
+			0x1b3d0,0x191c8,0x1c8e6,0x1b3c8,0x1d9e6,0x1b3c4,0x191c2,0x1b3c2,0x123d0,0x191ec, // 380
+			0x167d0,0x123c8,0x191e6,0x167c8,0x1b3e6,0x167c4,0x123c2,0x167c2,0x123ec,0x167ec, // 390
+			0x123e6,0x167e6,0x1f628,0x1fb16,0x162fc,0x1f624,0x1627e,0x1f622,0x1e428,0x1f216, // 400
+			0x1ec68,0x1f636,0x1ec64,0x1e422,0x1ec62,0x1c868,0x1e436,0x1d8e8,0x1c864,0x1d8e4, // 410
+			0x1c862,0x1d8e2,0x190e8,0x1c876,0x1b1e8,0x1d8f6,0x1b1e4,0x190e2,0x1b1e2,0x121e8, // 420
+			0x190f6,0x163e8,0x121e4,0x163e4,0x121e2,0x163e2,0x121f6,0x163f6,0x1f614,0x1617e, // 430
+			0x1f612,0x1e414,0x1ec34,0x1e412,0x1ec32,0x1c834,0x1d874,0x1c832,0x1d872,0x19074, // 440
+			0x1b0f4,0x19072,0x1b0f2,0x120f4,0x161f4,0x120f2,0x161f2,0x1f60a,0x1e40a,0x1ec1a, // 450
+			0x1c81a,0x1d83a,0x1903a,0x1b07a,0x1e2a0,0x1f158,0x1f8ae,0x1e290,0x1f14c,0x1e288, // 460
+			0x1f146,0x1e284,0x1e282,0x1c5a0,0x1e2d8,0x1f16e,0x1c590,0x1e2cc,0x1c588,0x1e2c6, // 470
+			0x1c584,0x1c582,0x18ba0,0x1c5d8,0x1e2ee,0x18b90,0x1c5cc,0x18b88,0x1c5c6,0x18b84, // 480
+			0x18b82,0x117a0,0x18bd8,0x1c5ee,0x11790,0x18bcc,0x11788,0x18bc6,0x11784,0x11782, // 490
+			0x117d8,0x18bee,0x117cc,0x117c6,0x117ee,0x1f350,0x1f9ac,0x135f8,0x1f348,0x1f9a6, // 500
+			0x134fc,0x1f344,0x1347e,0x1f342,0x1e250,0x1f12c,0x1e6d0,0x1e248,0x1f126,0x1e6c8, // 510
+			0x1f366,0x1e6c4,0x1e242,0x1e6c2,0x1c4d0,0x1e26c,0x1cdd0,0x1c4c8,0x1e266,0x1cdc8, // 520
+			0x1e6e6,0x1cdc4,0x1c4c2,0x1cdc2,0x189d0,0x1c4ec,0x19bd0,0x189c8,0x1c4e6,0x19bc8, // 530
+			0x1cde6,0x19bc4,0x189c2,0x19bc2,0x113d0,0x189ec,0x137d0,0x113c8,0x189e6,0x137c8, // 540
+			0x19be6,0x137c4,0x113c2,0x137c2,0x113ec,0x137ec,0x113e6,0x137e6,0x1fba8,0x175f0, // 550
+			0x1bafc,0x1fba4,0x174f8,0x1ba7e,0x1fba2,0x1747c,0x1743e,0x1f328,0x1f996,0x132fc, // 560
+			0x1f768,0x1fbb6,0x176fc,0x1327e,0x1f764,0x1f322,0x1767e,0x1f762,0x1e228,0x1f116, // 570
+			0x1e668,0x1e224,0x1eee8,0x1f776,0x1e222,0x1eee4,0x1e662,0x1eee2,0x1c468,0x1e236, // 580
+			0x1cce8,0x1c464,0x1dde8,0x1cce4,0x1c462,0x1dde4,0x1cce2,0x1dde2,0x188e8,0x1c476, // 590
+			0x199e8,0x188e4,0x1bbe8,0x199e4,0x188e2,0x1bbe4,0x199e2,0x1bbe2,0x111e8,0x188f6, // 600
+			0x133e8,0x111e4,0x177e8,0x133e4,0x111e2,0x177e4,0x133e2,0x177e2,0x111f6,0x133f6, // 610
+			0x1fb94,0x172f8,0x1b97e,0x1fb92,0x1727c,0x1723e,0x1f314,0x1317e,0x1f734,0x1f312, // 620
+			0x1737e,0x1f732,0x1e214,0x1e634,0x1e212,0x1ee74,0x1e632,0x1ee72,0x1c434,0x1cc74, // 630
+			0x1c432,0x1dcf4,0x1cc72,0x1dcf2,0x18874,0x198f4,0x18872,0x1b9f4,0x198f2,0x1b9f2, // 640
+			0x110f4,0x131f4,0x110f2,0x173f4,0x131f2,0x173f2,0x1fb8a,0x1717c,0x1713e,0x1f30a, // 650
+			0x1f71a,0x1e20a,0x1e61a,0x1ee3a,0x1c41a,0x1cc3a,0x1dc7a,0x1883a,0x1987a,0x1b8fa, // 660
+			0x1107a,0x130fa,0x171fa,0x170be,0x1e150,0x1f0ac,0x1e148,0x1f0a6,0x1e144,0x1e142, // 670
+			0x1c2d0,0x1e16c,0x1c2c8,0x1e166,0x1c2c4,0x1c2c2,0x185d0,0x1c2ec,0x185c8,0x1c2e6, // 680
+			0x185c4,0x185c2,0x10bd0,0x185ec,0x10bc8,0x185e6,0x10bc4,0x10bc2,0x10bec,0x10be6, // 690
+			0x1f1a8,0x1f8d6,0x11afc,0x1f1a4,0x11a7e,0x1f1a2,0x1e128,0x1f096,0x1e368,0x1e124, // 700
+			0x1e364,0x1e122,0x1e362,0x1c268,0x1e136,0x1c6e8,0x1c264,0x1c6e4,0x1c262,0x1c6e2, // 710
+			0x184e8,0x1c276,0x18de8,0x184e4,0x18de4,0x184e2,0x18de2,0x109e8,0x184f6,0x11be8, // 720
+			0x109e4,0x11be4,0x109e2,0x11be2,0x109f6,0x11bf6,0x1f9d4,0x13af8,0x19d7e,0x1f9d2, // 730
+			0x13a7c,0x13a3e,0x1f194,0x1197e,0x1f3b4,0x1f192,0x13b7e,0x1f3b2,0x1e114,0x1e334, // 740
+			0x1e112,0x1e774,0x1e332,0x1e772,0x1c234,0x1c674,0x1c232,0x1cef4,0x1c672,0x1cef2, // 750
+			0x18474,0x18cf4,0x18472,0x19df4,0x18cf2,0x19df2,0x108f4,0x119f4,0x108f2,0x13bf4, // 760
+			0x119f2,0x13bf2,0x17af0,0x1bd7c,0x17a78,0x1bd3e,0x17a3c,0x17a1e,0x1f9ca,0x1397c, // 770
+			0x1fbda,0x17b7c,0x1393e,0x17b3e,0x1f18a,0x1f39a,0x1f7ba,0x1e10a,0x1e31a,0x1e73a, // 780
+			0x1ef7a,0x1c21a,0x1c63a,0x1ce7a,0x1defa,0x1843a,0x18c7a,0x19cfa,0x1bdfa,0x1087a, // 790
+			0x118fa,0x139fa,0x17978,0x1bcbe,0x1793c,0x1791e,0x138be,0x179be,0x178bc,0x1789e, // 800
+			0x1785e,0x1e0a8,0x1e0a4,0x1e0a2,0x1c168,0x1e0b6,0x1c164,0x1c162,0x182e8,0x1c176, // 810
+			0x182e4,0x182e2,0x105e8,0x182f6,0x105e4,0x105e2,0x105f6,0x1f0d4,0x10d7e,0x1f0d2, // 820
+			0x1e094,0x1e1b4,0x1e092,0x1e1b2,0x1c134,0x1c374,0x1c132,0x1c372,0x18274,0x186f4, // 830
+			0x18272,0x186f2,0x104f4,0x10df4,0x104f2,0x10df2,0x1f8ea,0x11d7c,0x11d3e,0x1f0ca, // 840
+			0x1f1da,0x1e08a,0x1e19a,0x1e3ba,0x1c11a,0x1c33a,0x1c77a,0x1823a,0x1867a,0x18efa, // 850
+			0x1047a,0x10cfa,0x11dfa,0x13d78,0x19ebe,0x13d3c,0x13d1e,0x11cbe,0x13dbe,0x17d70, // 860
+			0x1bebc,0x17d38,0x1be9e,0x17d1c,0x17d0e,0x13cbc,0x17dbc,0x13c9e,0x17d9e,0x17cb8, // 870
+			0x1be5e,0x17c9c,0x17c8e,0x13c5e,0x17cde,0x17c5c,0x17c4e,0x17c2e,0x1c0b4,0x1c0b2, // 880
+			0x18174,0x18172,0x102f4,0x102f2,0x1e0da,0x1c09a,0x1c1ba,0x1813a,0x1837a,0x1027a, // 890
+			0x106fa,0x10ebe,0x11ebc,0x11e9e,0x13eb8,0x19f5e,0x13e9c,0x13e8e,0x11e5e,0x13ede, // 900
+			0x17eb0,0x1bf5c,0x17e98,0x1bf4e,0x17e8c,0x17e86,0x13e5c,0x17edc,0x13e4e,0x17ece, // 910
+			0x17e58,0x1bf2e,0x17e4c,0x17e46,0x13e2e,0x17e6e,0x17e2c,0x17e26,0x10f5e,0x11f5c, // 920
+			0x11f4e,0x13f58,0x19fae,0x13f4c,0x13f46,0x11f2e,0x13f6e,0x13f2c,0x13f26),        // 929
+		array( // cluster 6 -----------------------------------------------------------------------
+			0x1abe0,0x1d5f8,0x153c0,0x1a9f0,0x1d4fc,0x151e0,0x1a8f8,0x1d47e,0x150f0,0x1a87c, //  10
+			0x15078,0x1fad0,0x15be0,0x1adf8,0x1fac8,0x159f0,0x1acfc,0x1fac4,0x158f8,0x1ac7e, //  20
+			0x1fac2,0x1587c,0x1f5d0,0x1faec,0x15df8,0x1f5c8,0x1fae6,0x15cfc,0x1f5c4,0x15c7e, //  30
+			0x1f5c2,0x1ebd0,0x1f5ec,0x1ebc8,0x1f5e6,0x1ebc4,0x1ebc2,0x1d7d0,0x1ebec,0x1d7c8, //  40
+			0x1ebe6,0x1d7c4,0x1d7c2,0x1afd0,0x1d7ec,0x1afc8,0x1d7e6,0x1afc4,0x14bc0,0x1a5f0, //  50
+			0x1d2fc,0x149e0,0x1a4f8,0x1d27e,0x148f0,0x1a47c,0x14878,0x1a43e,0x1483c,0x1fa68, //  60
+			0x14df0,0x1a6fc,0x1fa64,0x14cf8,0x1a67e,0x1fa62,0x14c7c,0x14c3e,0x1f4e8,0x1fa76, //  70
+			0x14efc,0x1f4e4,0x14e7e,0x1f4e2,0x1e9e8,0x1f4f6,0x1e9e4,0x1e9e2,0x1d3e8,0x1e9f6, //  80
+			0x1d3e4,0x1d3e2,0x1a7e8,0x1d3f6,0x1a7e4,0x1a7e2,0x145e0,0x1a2f8,0x1d17e,0x144f0, //  90
+			0x1a27c,0x14478,0x1a23e,0x1443c,0x1441e,0x1fa34,0x146f8,0x1a37e,0x1fa32,0x1467c, // 100
+			0x1463e,0x1f474,0x1477e,0x1f472,0x1e8f4,0x1e8f2,0x1d1f4,0x1d1f2,0x1a3f4,0x1a3f2, // 110
+			0x142f0,0x1a17c,0x14278,0x1a13e,0x1423c,0x1421e,0x1fa1a,0x1437c,0x1433e,0x1f43a, // 120
+			0x1e87a,0x1d0fa,0x14178,0x1a0be,0x1413c,0x1411e,0x141be,0x140bc,0x1409e,0x12bc0, // 130
+			0x195f0,0x1cafc,0x129e0,0x194f8,0x1ca7e,0x128f0,0x1947c,0x12878,0x1943e,0x1283c, // 140
+			0x1f968,0x12df0,0x196fc,0x1f964,0x12cf8,0x1967e,0x1f962,0x12c7c,0x12c3e,0x1f2e8, // 150
+			0x1f976,0x12efc,0x1f2e4,0x12e7e,0x1f2e2,0x1e5e8,0x1f2f6,0x1e5e4,0x1e5e2,0x1cbe8, // 160
+			0x1e5f6,0x1cbe4,0x1cbe2,0x197e8,0x1cbf6,0x197e4,0x197e2,0x1b5e0,0x1daf8,0x1ed7e, // 170
+			0x169c0,0x1b4f0,0x1da7c,0x168e0,0x1b478,0x1da3e,0x16870,0x1b43c,0x16838,0x1b41e, // 180
+			0x1681c,0x125e0,0x192f8,0x1c97e,0x16de0,0x124f0,0x1927c,0x16cf0,0x1b67c,0x1923e, // 190
+			0x16c78,0x1243c,0x16c3c,0x1241e,0x16c1e,0x1f934,0x126f8,0x1937e,0x1fb74,0x1f932, // 200
+			0x16ef8,0x1267c,0x1fb72,0x16e7c,0x1263e,0x16e3e,0x1f274,0x1277e,0x1f6f4,0x1f272, // 210
+			0x16f7e,0x1f6f2,0x1e4f4,0x1edf4,0x1e4f2,0x1edf2,0x1c9f4,0x1dbf4,0x1c9f2,0x1dbf2, // 220
+			0x193f4,0x193f2,0x165c0,0x1b2f0,0x1d97c,0x164e0,0x1b278,0x1d93e,0x16470,0x1b23c, // 230
+			0x16438,0x1b21e,0x1641c,0x1640e,0x122f0,0x1917c,0x166f0,0x12278,0x1913e,0x16678, // 240
+			0x1b33e,0x1663c,0x1221e,0x1661e,0x1f91a,0x1237c,0x1fb3a,0x1677c,0x1233e,0x1673e, // 250
+			0x1f23a,0x1f67a,0x1e47a,0x1ecfa,0x1c8fa,0x1d9fa,0x191fa,0x162e0,0x1b178,0x1d8be, // 260
+			0x16270,0x1b13c,0x16238,0x1b11e,0x1621c,0x1620e,0x12178,0x190be,0x16378,0x1213c, // 270
+			0x1633c,0x1211e,0x1631e,0x121be,0x163be,0x16170,0x1b0bc,0x16138,0x1b09e,0x1611c, // 280
+			0x1610e,0x120bc,0x161bc,0x1209e,0x1619e,0x160b8,0x1b05e,0x1609c,0x1608e,0x1205e, // 290
+			0x160de,0x1605c,0x1604e,0x115e0,0x18af8,0x1c57e,0x114f0,0x18a7c,0x11478,0x18a3e, // 300
+			0x1143c,0x1141e,0x1f8b4,0x116f8,0x18b7e,0x1f8b2,0x1167c,0x1163e,0x1f174,0x1177e, // 310
+			0x1f172,0x1e2f4,0x1e2f2,0x1c5f4,0x1c5f2,0x18bf4,0x18bf2,0x135c0,0x19af0,0x1cd7c, // 320
+			0x134e0,0x19a78,0x1cd3e,0x13470,0x19a3c,0x13438,0x19a1e,0x1341c,0x1340e,0x112f0, // 330
+			0x1897c,0x136f0,0x11278,0x1893e,0x13678,0x19b3e,0x1363c,0x1121e,0x1361e,0x1f89a, // 340
+			0x1137c,0x1f9ba,0x1377c,0x1133e,0x1373e,0x1f13a,0x1f37a,0x1e27a,0x1e6fa,0x1c4fa, // 350
+			0x1cdfa,0x189fa,0x1bae0,0x1dd78,0x1eebe,0x174c0,0x1ba70,0x1dd3c,0x17460,0x1ba38, // 360
+			0x1dd1e,0x17430,0x1ba1c,0x17418,0x1ba0e,0x1740c,0x132e0,0x19978,0x1ccbe,0x176e0, // 370
+			0x13270,0x1993c,0x17670,0x1bb3c,0x1991e,0x17638,0x1321c,0x1761c,0x1320e,0x1760e, // 380
+			0x11178,0x188be,0x13378,0x1113c,0x17778,0x1333c,0x1111e,0x1773c,0x1331e,0x1771e, // 390
+			0x111be,0x133be,0x177be,0x172c0,0x1b970,0x1dcbc,0x17260,0x1b938,0x1dc9e,0x17230, // 400
+			0x1b91c,0x17218,0x1b90e,0x1720c,0x17206,0x13170,0x198bc,0x17370,0x13138,0x1989e, // 410
+			0x17338,0x1b99e,0x1731c,0x1310e,0x1730e,0x110bc,0x131bc,0x1109e,0x173bc,0x1319e, // 420
+			0x1739e,0x17160,0x1b8b8,0x1dc5e,0x17130,0x1b89c,0x17118,0x1b88e,0x1710c,0x17106, // 430
+			0x130b8,0x1985e,0x171b8,0x1309c,0x1719c,0x1308e,0x1718e,0x1105e,0x130de,0x171de, // 440
+			0x170b0,0x1b85c,0x17098,0x1b84e,0x1708c,0x17086,0x1305c,0x170dc,0x1304e,0x170ce, // 450
+			0x17058,0x1b82e,0x1704c,0x17046,0x1302e,0x1706e,0x1702c,0x17026,0x10af0,0x1857c, // 460
+			0x10a78,0x1853e,0x10a3c,0x10a1e,0x10b7c,0x10b3e,0x1f0ba,0x1e17a,0x1c2fa,0x185fa, // 470
+			0x11ae0,0x18d78,0x1c6be,0x11a70,0x18d3c,0x11a38,0x18d1e,0x11a1c,0x11a0e,0x10978, // 480
+			0x184be,0x11b78,0x1093c,0x11b3c,0x1091e,0x11b1e,0x109be,0x11bbe,0x13ac0,0x19d70, // 490
+			0x1cebc,0x13a60,0x19d38,0x1ce9e,0x13a30,0x19d1c,0x13a18,0x19d0e,0x13a0c,0x13a06, // 500
+			0x11970,0x18cbc,0x13b70,0x11938,0x18c9e,0x13b38,0x1191c,0x13b1c,0x1190e,0x13b0e, // 510
+			0x108bc,0x119bc,0x1089e,0x13bbc,0x1199e,0x13b9e,0x1bd60,0x1deb8,0x1ef5e,0x17a40, // 520
+			0x1bd30,0x1de9c,0x17a20,0x1bd18,0x1de8e,0x17a10,0x1bd0c,0x17a08,0x1bd06,0x17a04, // 530
+			0x13960,0x19cb8,0x1ce5e,0x17b60,0x13930,0x19c9c,0x17b30,0x1bd9c,0x19c8e,0x17b18, // 540
+			0x1390c,0x17b0c,0x13906,0x17b06,0x118b8,0x18c5e,0x139b8,0x1189c,0x17bb8,0x1399c, // 550
+			0x1188e,0x17b9c,0x1398e,0x17b8e,0x1085e,0x118de,0x139de,0x17bde,0x17940,0x1bcb0, // 560
+			0x1de5c,0x17920,0x1bc98,0x1de4e,0x17910,0x1bc8c,0x17908,0x1bc86,0x17904,0x17902, // 570
+			0x138b0,0x19c5c,0x179b0,0x13898,0x19c4e,0x17998,0x1bcce,0x1798c,0x13886,0x17986, // 580
+			0x1185c,0x138dc,0x1184e,0x179dc,0x138ce,0x179ce,0x178a0,0x1bc58,0x1de2e,0x17890, // 590
+			0x1bc4c,0x17888,0x1bc46,0x17884,0x17882,0x13858,0x19c2e,0x178d8,0x1384c,0x178cc, // 600
+			0x13846,0x178c6,0x1182e,0x1386e,0x178ee,0x17850,0x1bc2c,0x17848,0x1bc26,0x17844, // 610
+			0x17842,0x1382c,0x1786c,0x13826,0x17866,0x17828,0x1bc16,0x17824,0x17822,0x13816, // 620
+			0x17836,0x10578,0x182be,0x1053c,0x1051e,0x105be,0x10d70,0x186bc,0x10d38,0x1869e, // 630
+			0x10d1c,0x10d0e,0x104bc,0x10dbc,0x1049e,0x10d9e,0x11d60,0x18eb8,0x1c75e,0x11d30, // 640
+			0x18e9c,0x11d18,0x18e8e,0x11d0c,0x11d06,0x10cb8,0x1865e,0x11db8,0x10c9c,0x11d9c, // 650
+			0x10c8e,0x11d8e,0x1045e,0x10cde,0x11dde,0x13d40,0x19eb0,0x1cf5c,0x13d20,0x19e98, // 660
+			0x1cf4e,0x13d10,0x19e8c,0x13d08,0x19e86,0x13d04,0x13d02,0x11cb0,0x18e5c,0x13db0, // 670
+			0x11c98,0x18e4e,0x13d98,0x19ece,0x13d8c,0x11c86,0x13d86,0x10c5c,0x11cdc,0x10c4e, // 680
+			0x13ddc,0x11cce,0x13dce,0x1bea0,0x1df58,0x1efae,0x1be90,0x1df4c,0x1be88,0x1df46, // 690
+			0x1be84,0x1be82,0x13ca0,0x19e58,0x1cf2e,0x17da0,0x13c90,0x19e4c,0x17d90,0x1becc, // 700
+			0x19e46,0x17d88,0x13c84,0x17d84,0x13c82,0x17d82,0x11c58,0x18e2e,0x13cd8,0x11c4c, // 710
+			0x17dd8,0x13ccc,0x11c46,0x17dcc,0x13cc6,0x17dc6,0x10c2e,0x11c6e,0x13cee,0x17dee, // 720
+			0x1be50,0x1df2c,0x1be48,0x1df26,0x1be44,0x1be42,0x13c50,0x19e2c,0x17cd0,0x13c48, // 730
+			0x19e26,0x17cc8,0x1be66,0x17cc4,0x13c42,0x17cc2,0x11c2c,0x13c6c,0x11c26,0x17cec, // 740
+			0x13c66,0x17ce6,0x1be28,0x1df16,0x1be24,0x1be22,0x13c28,0x19e16,0x17c68,0x13c24, // 750
+			0x17c64,0x13c22,0x17c62,0x11c16,0x13c36,0x17c76,0x1be14,0x1be12,0x13c14,0x17c34, // 760
+			0x13c12,0x17c32,0x102bc,0x1029e,0x106b8,0x1835e,0x1069c,0x1068e,0x1025e,0x106de, // 770
+			0x10eb0,0x1875c,0x10e98,0x1874e,0x10e8c,0x10e86,0x1065c,0x10edc,0x1064e,0x10ece, // 780
+			0x11ea0,0x18f58,0x1c7ae,0x11e90,0x18f4c,0x11e88,0x18f46,0x11e84,0x11e82,0x10e58, // 790
+			0x1872e,0x11ed8,0x18f6e,0x11ecc,0x10e46,0x11ec6,0x1062e,0x10e6e,0x11eee,0x19f50, // 800
+			0x1cfac,0x19f48,0x1cfa6,0x19f44,0x19f42,0x11e50,0x18f2c,0x13ed0,0x19f6c,0x18f26, // 810
+			0x13ec8,0x11e44,0x13ec4,0x11e42,0x13ec2,0x10e2c,0x11e6c,0x10e26,0x13eec,0x11e66, // 820
+			0x13ee6,0x1dfa8,0x1efd6,0x1dfa4,0x1dfa2,0x19f28,0x1cf96,0x1bf68,0x19f24,0x1bf64, // 830
+			0x19f22,0x1bf62,0x11e28,0x18f16,0x13e68,0x11e24,0x17ee8,0x13e64,0x11e22,0x17ee4, // 840
+			0x13e62,0x17ee2,0x10e16,0x11e36,0x13e76,0x17ef6,0x1df94,0x1df92,0x19f14,0x1bf34, // 850
+			0x19f12,0x1bf32,0x11e14,0x13e34,0x11e12,0x17e74,0x13e32,0x17e72,0x1df8a,0x19f0a, // 860
+			0x1bf1a,0x11e0a,0x13e1a,0x17e3a,0x1035c,0x1034e,0x10758,0x183ae,0x1074c,0x10746, // 870
+			0x1032e,0x1076e,0x10f50,0x187ac,0x10f48,0x187a6,0x10f44,0x10f42,0x1072c,0x10f6c, // 880
+			0x10726,0x10f66,0x18fa8,0x1c7d6,0x18fa4,0x18fa2,0x10f28,0x18796,0x11f68,0x18fb6, // 890
+			0x11f64,0x10f22,0x11f62,0x10716,0x10f36,0x11f76,0x1cfd4,0x1cfd2,0x18f94,0x19fb4, // 900
+			0x18f92,0x19fb2,0x10f14,0x11f34,0x10f12,0x13f74,0x11f32,0x13f72,0x1cfca,0x18f8a, // 910
+			0x19f9a,0x10f0a,0x11f1a,0x13f3a,0x103ac,0x103a6,0x107a8,0x183d6,0x107a4,0x107a2, // 920
+			0x10396,0x107b6,0x187d4,0x187d2,0x10794,0x10fb4,0x10792,0x10fb2,0x1c7ea)         // 929
+	); // end of $clusters array
+
+	/**
+	 * Array of factors of the Reed-Solomon polynomial equations used for error correction; one sub array for each correction level (0-8).
+	 * @protected
+	 */
+	protected $rsfactors = array(
+		array( // ECL 0 (2 factors) -------------------------------------------------------------------------------
+			0x01b,0x395),                                                                                    //   2
+		array( // ECL 1 (4 factors) -------------------------------------------------------------------------------
+			0x20a,0x238,0x2d3,0x329),                                                                        //   4
+		array( // ECL 2 (8 factors) -------------------------------------------------------------------------------
+			0x0ed,0x134,0x1b4,0x11c,0x286,0x28d,0x1ac,0x17b),                                                //   8
+		array( // ECL 3 (16 factors) ------------------------------------------------------------------------------
+			0x112,0x232,0x0e8,0x2f3,0x257,0x20c,0x321,0x084,0x127,0x074,0x1ba,0x1ac,0x127,0x02a,0x0b0,0x041),//  16
+		array( // ECL 4 (32 factors) ------------------------------------------------------------------------------
+			0x169,0x23f,0x39a,0x20d,0x0b0,0x24a,0x280,0x141,0x218,0x2e6,0x2a5,0x2e6,0x2af,0x11c,0x0c1,0x205, //  16
+			0x111,0x1ee,0x107,0x093,0x251,0x320,0x23b,0x140,0x323,0x085,0x0e7,0x186,0x2ad,0x14a,0x03f,0x19a),//  32
+		array( // ECL 5 (64 factors) ------------------------------------------------------------------------------
+			0x21b,0x1a6,0x006,0x05d,0x35e,0x303,0x1c5,0x06a,0x262,0x11f,0x06b,0x1f9,0x2dd,0x36d,0x17d,0x264, //  16
+			0x2d3,0x1dc,0x1ce,0x0ac,0x1ae,0x261,0x35a,0x336,0x21f,0x178,0x1ff,0x190,0x2a0,0x2fa,0x11b,0x0b8, //  32
+			0x1b8,0x023,0x207,0x01f,0x1cc,0x252,0x0e1,0x217,0x205,0x160,0x25d,0x09e,0x28b,0x0c9,0x1e8,0x1f6, //  48
+			0x288,0x2dd,0x2cd,0x053,0x194,0x061,0x118,0x303,0x348,0x275,0x004,0x17d,0x34b,0x26f,0x108,0x21f),//  64
+		array( // ECL 6 (128 factors) -----------------------------------------------------------------------------
+			0x209,0x136,0x360,0x223,0x35a,0x244,0x128,0x17b,0x035,0x30b,0x381,0x1bc,0x190,0x39d,0x2ed,0x19f, //  16
+			0x336,0x05d,0x0d9,0x0d0,0x3a0,0x0f4,0x247,0x26c,0x0f6,0x094,0x1bf,0x277,0x124,0x38c,0x1ea,0x2c0, //  32
+			0x204,0x102,0x1c9,0x38b,0x252,0x2d3,0x2a2,0x124,0x110,0x060,0x2ac,0x1b0,0x2ae,0x25e,0x35c,0x239, //  48
+			0x0c1,0x0db,0x081,0x0ba,0x0ec,0x11f,0x0c0,0x307,0x116,0x0ad,0x028,0x17b,0x2c8,0x1cf,0x286,0x308, //  64
+			0x0ab,0x1eb,0x129,0x2fb,0x09c,0x2dc,0x05f,0x10e,0x1bf,0x05a,0x1fb,0x030,0x0e4,0x335,0x328,0x382, //  80
+			0x310,0x297,0x273,0x17a,0x17e,0x106,0x17c,0x25a,0x2f2,0x150,0x059,0x266,0x057,0x1b0,0x29e,0x268, //  96
+			0x09d,0x176,0x0f2,0x2d6,0x258,0x10d,0x177,0x382,0x34d,0x1c6,0x162,0x082,0x32e,0x24b,0x324,0x022, // 112
+			0x0d3,0x14a,0x21b,0x129,0x33b,0x361,0x025,0x205,0x342,0x13b,0x226,0x056,0x321,0x004,0x06c,0x21b),// 128
+		array( // ECL 7 (256 factors) -----------------------------------------------------------------------------
+			0x20c,0x37e,0x04b,0x2fe,0x372,0x359,0x04a,0x0cc,0x052,0x24a,0x2c4,0x0fa,0x389,0x312,0x08a,0x2d0, //  16
+			0x35a,0x0c2,0x137,0x391,0x113,0x0be,0x177,0x352,0x1b6,0x2dd,0x0c2,0x118,0x0c9,0x118,0x33c,0x2f5, //  32
+			0x2c6,0x32e,0x397,0x059,0x044,0x239,0x00b,0x0cc,0x31c,0x25d,0x21c,0x391,0x321,0x2bc,0x31f,0x089, //  48
+			0x1b7,0x1a2,0x250,0x29c,0x161,0x35b,0x172,0x2b6,0x145,0x0f0,0x0d8,0x101,0x11c,0x225,0x0d1,0x374, //  64
+			0x13b,0x046,0x149,0x319,0x1ea,0x112,0x36d,0x0a2,0x2ed,0x32c,0x2ac,0x1cd,0x14e,0x178,0x351,0x209, //  80
+			0x133,0x123,0x323,0x2c8,0x013,0x166,0x18f,0x38c,0x067,0x1ff,0x033,0x008,0x205,0x0e1,0x121,0x1d6, //  96
+			0x27d,0x2db,0x042,0x0ff,0x395,0x10d,0x1cf,0x33e,0x2da,0x1b1,0x350,0x249,0x088,0x21a,0x38a,0x05a, // 112
+			0x002,0x122,0x2e7,0x0c7,0x28f,0x387,0x149,0x031,0x322,0x244,0x163,0x24c,0x0bc,0x1ce,0x00a,0x086, // 128
+			0x274,0x140,0x1df,0x082,0x2e3,0x047,0x107,0x13e,0x176,0x259,0x0c0,0x25d,0x08e,0x2a1,0x2af,0x0ea, // 144
+			0x2d2,0x180,0x0b1,0x2f0,0x25f,0x280,0x1c7,0x0c1,0x2b1,0x2c3,0x325,0x281,0x030,0x03c,0x2dc,0x26d, // 160
+			0x37f,0x220,0x105,0x354,0x28f,0x135,0x2b9,0x2f3,0x2f4,0x03c,0x0e7,0x305,0x1b2,0x1a5,0x2d6,0x210, // 176
+			0x1f7,0x076,0x031,0x31b,0x020,0x090,0x1f4,0x0ee,0x344,0x18a,0x118,0x236,0x13f,0x009,0x287,0x226, // 192
+			0x049,0x392,0x156,0x07e,0x020,0x2a9,0x14b,0x318,0x26c,0x03c,0x261,0x1b9,0x0b4,0x317,0x37d,0x2f2, // 208
+			0x25d,0x17f,0x0e4,0x2ed,0x2f8,0x0d5,0x036,0x129,0x086,0x036,0x342,0x12b,0x39a,0x0bf,0x38e,0x214, // 224
+			0x261,0x33d,0x0bd,0x014,0x0a7,0x01d,0x368,0x1c1,0x053,0x192,0x029,0x290,0x1f9,0x243,0x1e1,0x0ad, // 240
+			0x194,0x0fb,0x2b0,0x05f,0x1f1,0x22b,0x282,0x21f,0x133,0x09f,0x39c,0x22e,0x288,0x037,0x1f1,0x00a),// 256
+		array( // ECL 8 (512 factors) -----------------------------------------------------------------------------
+			0x160,0x04d,0x175,0x1f8,0x023,0x257,0x1ac,0x0cf,0x199,0x23e,0x076,0x1f2,0x11d,0x17c,0x15e,0x1ec, //  16
+			0x0c5,0x109,0x398,0x09b,0x392,0x12b,0x0e5,0x283,0x126,0x367,0x132,0x058,0x057,0x0c1,0x160,0x30d, //  32
+			0x34e,0x04b,0x147,0x208,0x1b3,0x21f,0x0cb,0x29a,0x0f9,0x15a,0x30d,0x26d,0x280,0x10c,0x31a,0x216, //  48
+			0x21b,0x30d,0x198,0x186,0x284,0x066,0x1dc,0x1f3,0x122,0x278,0x221,0x025,0x35a,0x394,0x228,0x029, //  64
+			0x21e,0x121,0x07a,0x110,0x17f,0x320,0x1e5,0x062,0x2f0,0x1d8,0x2f9,0x06b,0x310,0x35c,0x292,0x2e5, //  80
+			0x122,0x0cc,0x2a9,0x197,0x357,0x055,0x063,0x03e,0x1e2,0x0b4,0x014,0x129,0x1c3,0x251,0x391,0x08e, //  96
+			0x328,0x2ac,0x11f,0x218,0x231,0x04c,0x28d,0x383,0x2d9,0x237,0x2e8,0x186,0x201,0x0c0,0x204,0x102, // 112
+			0x0f0,0x206,0x31a,0x18b,0x300,0x350,0x033,0x262,0x180,0x0a8,0x0be,0x33a,0x148,0x254,0x312,0x12f, // 128
+			0x23a,0x17d,0x19f,0x281,0x09c,0x0ed,0x097,0x1ad,0x213,0x0cf,0x2a4,0x2c6,0x059,0x0a8,0x130,0x192, // 144
+			0x028,0x2c4,0x23f,0x0a2,0x360,0x0e5,0x041,0x35d,0x349,0x200,0x0a4,0x1dd,0x0dd,0x05c,0x166,0x311, // 160
+			0x120,0x165,0x352,0x344,0x33b,0x2e0,0x2c3,0x05e,0x008,0x1ee,0x072,0x209,0x002,0x1f3,0x353,0x21f, // 176
+			0x098,0x2d9,0x303,0x05f,0x0f8,0x169,0x242,0x143,0x358,0x31d,0x121,0x033,0x2ac,0x1d2,0x215,0x334, // 192
+			0x29d,0x02d,0x386,0x1c4,0x0a7,0x156,0x0f4,0x0ad,0x023,0x1cf,0x28b,0x033,0x2bb,0x24f,0x1c4,0x242, // 208
+			0x025,0x07c,0x12a,0x14c,0x228,0x02b,0x1ab,0x077,0x296,0x309,0x1db,0x352,0x2fc,0x16c,0x242,0x38f, // 224
+			0x11b,0x2c7,0x1d8,0x1a4,0x0f5,0x120,0x252,0x18a,0x1ff,0x147,0x24d,0x309,0x2bb,0x2b0,0x02b,0x198, // 240
+			0x34a,0x17f,0x2d1,0x209,0x230,0x284,0x2ca,0x22f,0x03e,0x091,0x369,0x297,0x2c9,0x09f,0x2a0,0x2d9, // 256
+			0x270,0x03b,0x0c1,0x1a1,0x09e,0x0d1,0x233,0x234,0x157,0x2b5,0x06d,0x260,0x233,0x16d,0x0b5,0x304, // 272
+			0x2a5,0x136,0x0f8,0x161,0x2c4,0x19a,0x243,0x366,0x269,0x349,0x278,0x35c,0x121,0x218,0x023,0x309, // 288
+			0x26a,0x24a,0x1a8,0x341,0x04d,0x255,0x15a,0x10d,0x2f5,0x278,0x2b7,0x2ef,0x14b,0x0f7,0x0b8,0x02d, // 304
+			0x313,0x2a8,0x012,0x042,0x197,0x171,0x036,0x1ec,0x0e4,0x265,0x33e,0x39a,0x1b5,0x207,0x284,0x389, // 320
+			0x315,0x1a4,0x131,0x1b9,0x0cf,0x12c,0x37c,0x33b,0x08d,0x219,0x17d,0x296,0x201,0x038,0x0fc,0x155, // 336
+			0x0f2,0x31d,0x346,0x345,0x2d0,0x0e0,0x133,0x277,0x03d,0x057,0x230,0x136,0x2f4,0x299,0x18d,0x328, // 352
+			0x353,0x135,0x1d9,0x31b,0x17a,0x01f,0x287,0x393,0x1cb,0x326,0x24e,0x2db,0x1a9,0x0d8,0x224,0x0f9, // 368
+			0x141,0x371,0x2bb,0x217,0x2a1,0x30e,0x0d2,0x32f,0x389,0x12f,0x34b,0x39a,0x119,0x049,0x1d5,0x317, // 384
+			0x294,0x0a2,0x1f2,0x134,0x09b,0x1a6,0x38b,0x331,0x0bb,0x03e,0x010,0x1a9,0x217,0x150,0x11e,0x1b5, // 400
+			0x177,0x111,0x262,0x128,0x0b7,0x39b,0x074,0x29b,0x2ef,0x161,0x03e,0x16e,0x2b3,0x17b,0x2af,0x34a, // 416
+			0x025,0x165,0x2d0,0x2e6,0x14a,0x005,0x027,0x39b,0x137,0x1a8,0x0f2,0x2ed,0x141,0x036,0x29d,0x13c, // 432
+			0x156,0x12b,0x216,0x069,0x29b,0x1e8,0x280,0x2a0,0x240,0x21c,0x13c,0x1e6,0x2d1,0x262,0x02e,0x290, // 448
+			0x1bf,0x0ab,0x268,0x1d0,0x0be,0x213,0x129,0x141,0x2fa,0x2f0,0x215,0x0af,0x086,0x00e,0x17d,0x1b1, // 464
+			0x2cd,0x02d,0x06f,0x014,0x254,0x11c,0x2e0,0x08a,0x286,0x19b,0x36d,0x29d,0x08d,0x397,0x02d,0x30c, // 480
+			0x197,0x0a4,0x14c,0x383,0x0a5,0x2d6,0x258,0x145,0x1f2,0x28f,0x165,0x2f0,0x300,0x0df,0x351,0x287, // 496
+			0x03f,0x136,0x35f,0x0fb,0x16e,0x130,0x11a,0x2e2,0x2a3,0x19a,0x185,0x0f4,0x01f,0x079,0x12f,0x107) // 512
+	);
+
+	/**
+	 * This is the class constructor.
+	 * Creates a PDF417 object
+	 * @param string $code code to represent using PDF417
+	 * @param int $ecl error correction level (0-8); default -1 = automatic correction level
+	 * @param float $aspectratio the width to height of the symbol (excluding quiet zones)
+	 * @param array $macro information for macro block
+	 * @public
+	 */
+	public function __construct($code, $ecl=-1, $aspectratio=2, $macro=array()) {
+		$barcode_array = array();
+		if ((is_null($code)) OR ($code == '\0') OR ($code == '')) {
+			return false;
+		}
+		// get the input sequence array
+		$sequence = $this->getInputSequences($code);
+		$codewords = array(); // array of code-words
+		foreach($sequence as $seq) {
+			$cw = $this->getCompaction($seq[0], $seq[1], true);
+			$codewords = array_merge($codewords, $cw);
+		}
+		if ($codewords[0] == 900) {
+			// Text Alpha is the default mode, so remove the first code
+			array_shift($codewords);
+		}
+		// count number of codewords
+		$numcw = count($codewords);
+		if ($numcw > 925) {
+			// reached maximum data codeword capacity
+			return false;
+		}
+		// build macro control block codewords
+		if (!empty($macro)) {
+			$macrocw = array();
+			// beginning of macro control block
+			$macrocw[] = 928;
+			// segment index
+			$cw = $this->getCompaction(902, sprintf('%05d', $macro['segment_index']), false);
+			$macrocw = array_merge($macrocw, $cw);
+			// file ID
+			$cw = $this->getCompaction(900, $macro['file_id'], false);
+			$macrocw = array_merge($macrocw, $cw);
+			// optional fields
+			$optmodes = array(900,902,902,900,900,902,902);
+			$optsize = array(-1,2,4,-1,-1,-1,2);
+			foreach ($optmodes as $k => $omode) {
+				if (isset($macro['option_'.$k])) {
+					$macrocw[] = 923;
+					$macrocw[] = $k;
+					if ($optsize[$k] == 2) {
+						$macro['option_'.$k] = sprintf('%05d', $macro['option_'.$k]);
+					} elseif ($optsize[$k] == 4) {
+						$macro['option_'.$k] = sprintf('%010d', $macro['option_'.$k]);
+					}
+					$cw = $this->getCompaction($omode, $macro['option_'.$k], false);
+					$macrocw = array_merge($macrocw, $cw);
+				}
+			}
+			if ($macro['segment_index'] == ($macro['segment_total'] - 1)) {
+				// end of control block
+				$macrocw[] = 922;
+			}
+			// update total codewords
+			$numcw += count($macrocw);
+		}
+		// set error correction level
+		$ecl = $this->getErrorCorrectionLevel($ecl, $numcw);
+		// number of codewords for error correction
+		$errsize = (2 << $ecl);
+		// calculate number of columns (number of codewords per row) and rows
+		$nce = ($numcw + $errsize + 1);
+		$cols = round((sqrt(4761 + (68 * $aspectratio * ROWHEIGHT * $nce)) - 69) / 34);
+		// adjust cols
+		if ($cols < 1) {
+			$cols = 1;
+		} elseif ($cols > 30) {
+			$cols = 30;
+		}
+		$rows = ceil($nce / $cols);
+		$size = ($cols * $rows);
+		// adjust rows
+		if (($rows < 3) OR ($rows > 90)) {
+			if ($rows < 3) {
+				$rows = 3;
+			} elseif ($rows > 90) {
+				$rows = 90;
+			}
+			$cols = ceil($size / $rows);
+			$size = ($cols * $rows);
+		}
+		if ($size > 928) {
+			// set dimensions to get maximum capacity
+			if (abs($aspectratio - (17 * 29 / 32)) < abs($aspectratio - (17 * 16 / 58))) {
+				$cols = 29;
+				$rows = 32;
+			} else {
+				$cols = 16;
+				$rows = 58;
+			}
+			$size = 928;
+		}
+		// calculate padding
+		$pad = ($size - $nce);
+		if ($pad > 0) {
+			if (($size - $rows) == $nce) {
+				--$rows;
+				$size -= $rows;
+			} else {
+				// add pading
+				$codewords = array_merge($codewords, array_fill(0, $pad, 900));
+			}
+		}
+		if (!empty($macro)) {
+			// add macro section
+			$codewords = array_merge($codewords, $macrocw);
+		}
+		// Symbol Length Descriptor (number of data codewords including Symbol Length Descriptor and pad codewords)
+		$sld = $size - $errsize;
+		// add symbol length description
+		array_unshift($codewords, $sld);
+		// calculate error correction
+		$ecw = $this->getErrorCorrection($codewords, $ecl);
+		// add error correction codewords
+		$codewords = array_merge($codewords, $ecw);
+		// add horizontal quiet zones to start and stop patterns
+		$pstart = str_repeat('0', QUIETH).$this->start_pattern;
+		$pstop = $this->stop_pattern.str_repeat('0', QUIETH);
+		$barcode_array['num_rows'] = ($rows * ROWHEIGHT) + (2 * QUIETV);
+		$barcode_array['num_cols'] = (($cols + 2) * 17) + 35 + (2 * QUIETH);
+		$barcode_array['bcode'] = array();
+		// build rows for vertical quiet zone
+		if (QUIETV > 0) {
+			$empty_row = array_fill(0, $barcode_array['num_cols'], 0);
+			for ($i = 0; $i < QUIETV; ++$i) {
+				// add vertical quiet rows
+				$barcode_array['bcode'][] = $empty_row;
+			}
+		}
+		$k = 0; // codeword index
+		$cid = 0; // initial cluster
+		// for each row
+		for ($r = 0; $r < $rows; ++$r) {
+			// row start code
+			$row = $pstart;
+			switch ($cid) {
+				case 0: {
+					$L = ((30 * intval($r / 3)) + intval(($rows - 1) / 3));
+					break;
+				}
+				case 1: {
+					$L = ((30 * intval($r / 3)) + ($ecl * 3) + (($rows - 1) % 3));
+					break;
+				}
+				case 2: {
+					$L = ((30 * intval($r / 3)) + ($cols - 1));
+					break;
+				}
+			}
+			// left row indicator
+			$row .= sprintf('%17b', $this->clusters[$cid][$L]);
+			// for each column
+			for ($c = 0; $c < $cols; ++$c) {
+				$row .= sprintf('%17b', $this->clusters[$cid][$codewords[$k]]);
+				++$k;
+			}
+			switch ($cid) {
+				case 0: {
+					$L = ((30 * intval($r / 3)) + ($cols - 1));
+					break;
+				}
+				case 1: {
+					$L = ((30 * intval($r / 3)) + intval(($rows - 1) / 3));
+					break;
+				}
+				case 2: {
+					$L = ((30 * intval($r / 3)) + ($ecl * 3) + (($rows - 1) % 3));
+					break;
+				}
+			}
+			// right row indicator
+			$row .= sprintf('%17b', $this->clusters[$cid][$L]);
+			// row stop code
+			$row .= $pstop;
+			// convert the string to array
+			$arow = preg_split('//', $row, -1, PREG_SPLIT_NO_EMPTY);
+			// duplicate row to get the desired height
+			for ($h = 0; $h < ROWHEIGHT; ++$h) {
+				$barcode_array['bcode'][] = $arow;
+			}
+			++$cid;
+			if ($cid > 2) {
+				$cid = 0;
+			}
+		}
+		if (QUIETV > 0) {
+			for ($i = 0; $i < QUIETV; ++$i) {
+				// add vertical quiet rows
+				$barcode_array['bcode'][] = $empty_row;
+			}
+		}
+		$this->barcode_array = $barcode_array;
+	}
+
+	/**
+	 * Returns a barcode array which is readable by TCPDF
+	 * @return array barcode array readable by TCPDF;
+	 * @public
+	 */
+	public function getBarcodeArray() {
+		return $this->barcode_array;
+	}
+
+	/**
+	 * Returns the error correction level (0-8) to be used
+	 * @param int $ecl error correction level
+	 * @param int $numcw number of data codewords
+	 * @return int error correction level
+	 * @protected
+	 */
+	protected function getErrorCorrectionLevel($ecl, $numcw) {
+		$maxecl = 8; // starting error level
+		// check for automatic levels
+		if (($ecl < 0) OR ($ecl > 8)) {
+			if ($numcw < 41) {
+				$ecl = 2;
+			} elseif ($numcw < 161) {
+				$ecl = 3;
+			} elseif ($numcw < 321) {
+				$ecl = 4;
+			} elseif ($numcw < 864) {
+				$ecl = 5;
+			} else {
+				$ecl = $maxecl;
+			}
+		}
+		// get maximum correction level
+		$maxerrsize = (928 - $numcw); // available codewords for error
+		while ($maxecl > 0) {
+			$errsize = (2 << $ecl);
+			if ($maxerrsize >= $errsize) {
+				break;
+			}
+			--$maxecl;
+		}
+		if ($ecl > $maxecl) {
+			$ecl = $maxecl;
+		}
+		return $ecl;
+	}
+
+	/**
+	 * Returns the error correction codewords
+	 * @param array $cw array of codewords including Symbol Length Descriptor and pad
+	 * @param int $ecl error correction level 0-8
+	 * @return array of error correction codewords
+	 * @protected
+	 */
+	protected function getErrorCorrection($cw, $ecl) {
+		// get error correction coefficients
+		$ecc = $this->rsfactors[$ecl];
+		// number of error correction factors
+		$eclsize = (2 << $ecl);
+		// maximum index for $rsfactors[$ecl]
+		$eclmaxid = ($eclsize - 1);
+		// initialize array of error correction codewords
+		$ecw = array_fill(0, $eclsize, 0);
+		// for each data codeword
+		foreach($cw as $k => $d) {
+			$t1 = ($d + $ecw[$eclmaxid]) % 929;
+			for ($j = $eclmaxid; $j > 0; --$j) {
+				$t2 = ($t1 * $ecc[$j]) % 929;
+				$t3 = 929 - $t2;
+				$ecw[$j] = ($ecw[($j - 1)] + $t3) % 929;
+			}
+			$t2 = ($t1 * $ecc[0]) % 929;
+			$t3 = 929 - $t2;
+			$ecw[0] = $t3 % 929;
+		}
+		foreach($ecw as $j => $e) {
+			if ($e != 0) {
+				$ecw[$j] = 929 - $e;
+			}
+		}
+		$ecw = array_reverse($ecw);
+		return $ecw;
+	}
+
+	/**
+	 * Create array of sequences from input
+	 * @param string $code code
+	 * @return array bi-dimensional array containing characters and classification
+	 * @protected
+	 */
+	protected function getInputSequences($code) {
+		$sequence_array = array(); // array to be returned
+		$numseq = array();
+		// get numeric sequences
+		preg_match_all('/([0-9]{13,44})/', $code, $numseq, PREG_OFFSET_CAPTURE);
+		$numseq[1][] = array('', strlen($code));
+		$offset = 0;
+		foreach($numseq[1] as $seq) {
+			$seqlen = strlen($seq[0]);
+			if ($seq[1] > 0) {
+				// extract text sequence before the number sequence
+				$prevseq = substr($code, $offset, ($seq[1] - $offset));
+				$textseq = array();
+				// get text sequences
+				preg_match_all('/([\x09\x0a\x0d\x20-\x7e]{5,})/', $prevseq, $textseq, PREG_OFFSET_CAPTURE);
+				$textseq[1][] = array('', strlen($prevseq));
+				$txtoffset = 0;
+				foreach($textseq[1] as $txtseq) {
+					$txtseqlen = strlen($txtseq[0]);
+					if ($txtseq[1] > 0) {
+						// extract byte sequence before the text sequence
+						$prevtxtseq = substr($prevseq, $txtoffset, ($txtseq[1] - $txtoffset));
+						if (strlen($prevtxtseq) > 0) {
+							// add BYTE sequence
+							if ((strlen($prevtxtseq) == 1) AND ((count($sequence_array) > 0) AND ($sequence_array[(count($sequence_array) - 1)][0] == 900))) {
+								$sequence_array[] = array(913, $prevtxtseq);
+							} elseif ((strlen($prevtxtseq) % 6) == 0) {
+								$sequence_array[] = array(924, $prevtxtseq);
+							} else {
+								$sequence_array[] = array(901, $prevtxtseq);
+							}
+						}
+					}
+					if ($txtseqlen > 0) {
+						// add numeric sequence
+						$sequence_array[] = array(900, $txtseq[0]);
+					}
+					$txtoffset = $txtseq[1] + $txtseqlen;
+				}
+			}
+			if ($seqlen > 0) {
+				// add numeric sequence
+				$sequence_array[] = array(902, $seq[0]);
+			}
+			$offset = $seq[1] + $seqlen;
+		}
+		return $sequence_array;
+	}
+
+	/**
+	 * Compact data by mode.
+	 * @param int $mode compaction mode number
+	 * @param string $code data to compact
+	 * @param boolean $addmode if true add the mode codeword at first position
+	 * @return array of codewords
+	 * @protected
+	 */
+	protected function getCompaction($mode, $code, $addmode=true) {
+		$cw = array(); // array of codewords to return
+		switch($mode) {
+			case 900: { // Text Compaction mode latch
+				$submode = 0; // default Alpha sub-mode
+				$txtarr = array(); // array of characters and sub-mode switching characters
+				$codelen = strlen($code);
+				for ($i = 0; $i < $codelen; ++$i) {
+					$chval = ord($code[$i]);
+					if (($k = array_search($chval, $this->textsubmodes[$submode])) !== false) {
+						// we are on the same sub-mode
+						$txtarr[] = $k;
+					} else {
+						// the sub-mode is changed
+						for ($s = 0; $s < 4; ++$s) {
+							// search new sub-mode
+							if (($s != $submode) AND (($k = array_search($chval, $this->textsubmodes[$s])) !== false)) {
+								// $s is the new submode
+								if (((($i + 1) == $codelen) OR ((($i + 1) < $codelen) AND (array_search(ord($code[($i + 1)]), $this->textsubmodes[$submode]) !== false))) AND (($s == 3) OR (($s == 0) AND ($submode == 1)))) {
+									// shift (temporary change only for this char)
+									if ($s == 3) {
+										// shift to puntuaction
+										$txtarr[] = 29;
+									} else {
+										// shift from lower to alpha
+										$txtarr[] = 27;
+									}
+								} else {
+									// latch
+									$txtarr	= array_merge($txtarr, $this->textlatch[''.$submode.$s]);
+									// set new submode
+									$submode = $s;
+								}
+								// add characted code to array
+								$txtarr[] = $k;
+								break;
+							}
+						}
+					}
+				}
+				$txtarrlen = count($txtarr);
+				if (($txtarrlen % 2) != 0) {
+					// add padding
+					$txtarr[] = 29;
+					++$txtarrlen;
+				}
+				// calculate codewords
+				for ($i = 0; $i < $txtarrlen; $i += 2) {
+					$cw[] = (30 * $txtarr[$i]) + $txtarr[($i + 1)];
+				}
+				break;
+			}
+			case 901:
+			case 924: { // Byte Compaction mode latch
+				while (($codelen = strlen($code)) > 0) {
+					if ($codelen > 6) {
+						$rest = substr($code, 6);
+						$code = substr($code, 0, 6);
+						$sublen = 6;
+					} else {
+						$rest = '';
+						$sublen = strlen($code);
+					}
+					if ($sublen == 6) {
+						$t = bcmul(''.ord($code[0]), '1099511627776');
+						$t = bcadd($t, bcmul(''.ord($code[1]), '4294967296'));
+						$t = bcadd($t, bcmul(''.ord($code[2]), '16777216'));
+						$t = bcadd($t, bcmul(''.ord($code[3]), '65536'));
+						$t = bcadd($t, bcmul(''.ord($code[4]), '256'));
+						$t = bcadd($t, ''.ord($code[5]));
+						// tmp array for the 6 bytes block
+						$cw6 = array();
+						do {
+							$d = bcmod($t, '900', 0);
+							$t = bcdiv($t, '900', 0);
+							// prepend the value to the beginning of the array
+							array_unshift($cw6, $d);
+						} while ($t != '0');
+						// append the result array at the end
+						$cw = array_merge($cw, $cw6);
+					} else {
+						for ($i = 0; $i < $sublen; ++$i) {
+							$cw[] = ord($code[$i]);
+						}
+					}
+					$code = $rest;
+				}
+				break;
+			}
+			case 902: { // Numeric Compaction mode latch
+				while (($codelen = strlen($code)) > 0) {
+					if ($codelen > 44) {
+						$rest = substr($code, 44);
+						$code = substr($code, 0, 44);
+					} else {
+						$rest = '';
+					}
+					$t = '1'.$code;
+					do {
+						$d = bcmod($t, '900', 0);
+						$t = bcdiv($t, '900', 0);
+						array_unshift($cw, $d);
+					} while ($t != '0');
+					$code = $rest;
+				}
+				break;
+			}
+			case 913: { // Byte Compaction mode shift
+				$cw[] = ord($code);
+				break;
+			}
+		}
+		if ($addmode) {
+			// add the compaction mode codeword at the beginning
+			array_unshift($cw, $mode);
+		}
+		return $cw;
+	}
+
+} // end PDF417 class
+
+//============================================================+
+// END OF FILE
+//============================================================+

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/include/tcpdf_colors.php

@@ -0,0 +1,482 @@
+<?php
+//============================================================+
+// File name   : tcpdf_colors.php
+// Version     : 1.0.004
+// Begin       : 2002-04-09
+// Last Update : 2014-04-25
+// Author      : Nicola Asuni - Tecnick.com LTD - www.tecnick.com - info@tecnick.com
+// License     : GNU-LGPL v3 (https://www.gnu.org/copyleft/lesser.html)
+// -------------------------------------------------------------------
+// Copyright (C) 2002-2013 2026 Nicola Asuni - Tecnick.com LTD
+//
+// This file is part of TCPDF software library.
+//
+// TCPDF is free software: you can redistribute it and/or modify it
+// under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// TCPDF is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with TCPDF.  If not, see <https://www.gnu.org/licenses/>.
+//
+// See LICENSE.TXT file for more information.
+// -------------------------------------------------------------------
+//
+// Description : Array of WEB safe colors
+//
+//============================================================+
+
+/**
+ * @file
+ * PHP color class for TCPDF
+ * @author Nicola Asuni
+ * @package com.tecnick.tcpdf
+ */
+
+/**
+ * @class TCPDF_COLORS
+ * PHP color class for TCPDF
+ * @package com.tecnick.tcpdf
+ * @version 1.0.004
+ * @author Nicola Asuni - info@tecnick.com
+ */
+class TCPDF_COLORS {
+
+	/**
+	 * Array of WEB safe colors
+	 * @public static
+	 */
+	public static $webcolor = array (
+		'aliceblue' => 'f0f8ff',
+		'antiquewhite' => 'faebd7',
+		'aqua' => '00ffff',
+		'aquamarine' => '7fffd4',
+		'azure' => 'f0ffff',
+		'beige' => 'f5f5dc',
+		'bisque' => 'ffe4c4',
+		'black' => '000000',
+		'blanchedalmond' => 'ffebcd',
+		'blue' => '0000ff',
+		'blueviolet' => '8a2be2',
+		'brown' => 'a52a2a',
+		'burlywood' => 'deb887',
+		'cadetblue' => '5f9ea0',
+		'chartreuse' => '7fff00',
+		'chocolate' => 'd2691e',
+		'coral' => 'ff7f50',
+		'cornflowerblue' => '6495ed',
+		'cornsilk' => 'fff8dc',
+		'crimson' => 'dc143c',
+		'cyan' => '00ffff',
+		'darkblue' => '00008b',
+		'darkcyan' => '008b8b',
+		'darkgoldenrod' => 'b8860b',
+		'dkgray' => 'a9a9a9',
+		'darkgray' => 'a9a9a9',
+		'darkgrey' => 'a9a9a9',
+		'darkgreen' => '006400',
+		'darkkhaki' => 'bdb76b',
+		'darkmagenta' => '8b008b',
+		'darkolivegreen' => '556b2f',
+		'darkorange' => 'ff8c00',
+		'darkorchid' => '9932cc',
+		'darkred' => '8b0000',
+		'darksalmon' => 'e9967a',
+		'darkseagreen' => '8fbc8f',
+		'darkslateblue' => '483d8b',
+		'darkslategray' => '2f4f4f',
+		'darkslategrey' => '2f4f4f',
+		'darkturquoise' => '00ced1',
+		'darkviolet' => '9400d3',
+		'deeppink' => 'ff1493',
+		'deepskyblue' => '00bfff',
+		'dimgray' => '696969',
+		'dimgrey' => '696969',
+		'dodgerblue' => '1e90ff',
+		'firebrick' => 'b22222',
+		'floralwhite' => 'fffaf0',
+		'forestgreen' => '228b22',
+		'fuchsia' => 'ff00ff',
+		'gainsboro' => 'dcdcdc',
+		'ghostwhite' => 'f8f8ff',
+		'gold' => 'ffd700',
+		'goldenrod' => 'daa520',
+		'gray' => '808080',
+		'grey' => '808080',
+		'green' => '008000',
+		'greenyellow' => 'adff2f',
+		'honeydew' => 'f0fff0',
+		'hotpink' => 'ff69b4',
+		'indianred' => 'cd5c5c',
+		'indigo' => '4b0082',
+		'ivory' => 'fffff0',
+		'khaki' => 'f0e68c',
+		'lavender' => 'e6e6fa',
+		'lavenderblush' => 'fff0f5',
+		'lawngreen' => '7cfc00',
+		'lemonchiffon' => 'fffacd',
+		'lightblue' => 'add8e6',
+		'lightcoral' => 'f08080',
+		'lightcyan' => 'e0ffff',
+		'lightgoldenrodyellow' => 'fafad2',
+		'ltgray' => 'd3d3d3',
+		'lightgray' => 'd3d3d3',
+		'lightgrey' => 'd3d3d3',
+		'lightgreen' => '90ee90',
+		'lightpink' => 'ffb6c1',
+		'lightsalmon' => 'ffa07a',
+		'lightseagreen' => '20b2aa',
+		'lightskyblue' => '87cefa',
+		'lightslategray' => '778899',
+		'lightslategrey' => '778899',
+		'lightsteelblue' => 'b0c4de',
+		'lightyellow' => 'ffffe0',
+		'lime' => '00ff00',
+		'limegreen' => '32cd32',
+		'linen' => 'faf0e6',
+		'magenta' => 'ff00ff',
+		'maroon' => '800000',
+		'mediumaquamarine' => '66cdaa',
+		'mediumblue' => '0000cd',
+		'mediumorchid' => 'ba55d3',
+		'mediumpurple' => '9370d8',
+		'mediumseagreen' => '3cb371',
+		'mediumslateblue' => '7b68ee',
+		'mediumspringgreen' => '00fa9a',
+		'mediumturquoise' => '48d1cc',
+		'mediumvioletred' => 'c71585',
+		'midnightblue' => '191970',
+		'mintcream' => 'f5fffa',
+		'mistyrose' => 'ffe4e1',
+		'moccasin' => 'ffe4b5',
+		'navajowhite' => 'ffdead',
+		'navy' => '000080',
+		'oldlace' => 'fdf5e6',
+		'olive' => '808000',
+		'olivedrab' => '6b8e23',
+		'orange' => 'ffa500',
+		'orangered' => 'ff4500',
+		'orchid' => 'da70d6',
+		'palegoldenrod' => 'eee8aa',
+		'palegreen' => '98fb98',
+		'paleturquoise' => 'afeeee',
+		'palevioletred' => 'd87093',
+		'papayawhip' => 'ffefd5',
+		'peachpuff' => 'ffdab9',
+		'peru' => 'cd853f',
+		'pink' => 'ffc0cb',
+		'plum' => 'dda0dd',
+		'powderblue' => 'b0e0e6',
+		'purple' => '800080',
+		'red' => 'ff0000',
+		'rosybrown' => 'bc8f8f',
+		'royalblue' => '4169e1',
+		'saddlebrown' => '8b4513',
+		'salmon' => 'fa8072',
+		'sandybrown' => 'f4a460',
+		'seagreen' => '2e8b57',
+		'seashell' => 'fff5ee',
+		'sienna' => 'a0522d',
+		'silver' => 'c0c0c0',
+		'skyblue' => '87ceeb',
+		'slateblue' => '6a5acd',
+		'slategray' => '708090',
+		'slategrey' => '708090',
+		'snow' => 'fffafa',
+		'springgreen' => '00ff7f',
+		'steelblue' => '4682b4',
+		'tan' => 'd2b48c',
+		'teal' => '008080',
+		'thistle' => 'd8bfd8',
+		'tomato' => 'ff6347',
+		'turquoise' => '40e0d0',
+		'violet' => 'ee82ee',
+		'wheat' => 'f5deb3',
+		'white' => 'ffffff',
+		'whitesmoke' => 'f5f5f5',
+		'yellow' => 'ffff00',
+		'yellowgreen' => '9acd32'
+	); // end of web colors
+
+	/**
+	 * Array of valid JavaScript color names
+	 * @public static
+	 */
+	public static $jscolor = array ('transparent', 'black', 'white', 'red', 'green', 'blue', 'cyan', 'magenta', 'yellow', 'dkGray', 'gray', 'ltGray');
+
+	/**
+	 * Array of Spot colors (C,M,Y,K,name)
+	 * Color keys must be in lowercase and without spaces.
+	 * As long as no open standard for spot colours exists, you have to buy a colour book by one of the colour manufacturers and insert the values and names of spot colours directly.
+	 * Common industry standard spot colors are: ANPA-COLOR, DIC, FOCOLTONE, GCMI, HKS, PANTONE, TOYO, TRUMATCH.
+	 * @public static
+	 */
+	public static $spotcolor = array (
+		// special registration colors
+		'none'    => array(  0,   0,   0,   0, 'None'),
+		'all'     => array(100, 100, 100, 100, 'All'),
+		// standard CMYK colors
+		'cyan'    => array(100,   0,   0,   0, 'Cyan'),
+		'magenta' => array(  0, 100,   0,   0, 'Magenta'),
+		'yellow'  => array(  0,   0, 100,   0, 'Yellow'),
+		'key'     => array(  0,   0,   0, 100, 'Key'),
+		// alias
+		'white'   => array(  0,   0,   0,   0, 'White'),
+		'black'   => array(  0,   0,   0, 100, 'Black'),
+		// standard RGB colors
+		'red'     => array(  0, 100, 100,   0, 'Red'),
+		'green'   => array(100,   0, 100,   0, 'Green'),
+		'blue'    => array(100, 100,   0,   0, 'Blue'),
+		// Add here standard spot colors or dynamically define them with AddSpotColor()
+		// ...
+	); // end of spot colors
+
+	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	/**
+	 * Return the Spot color array.
+	 * @param string $name Name of the spot color.
+	 * @param array $spotc Reference to an array of spot colors.
+	 * @return array|false Spot color array or false if not defined.
+	 * @since 5.9.125 (2011-10-03)
+	 * @public static
+	 */
+	public static function getSpotColor($name, &$spotc) {
+		if (isset($spotc[$name])) {
+			return $spotc[$name];
+		}
+		$color = preg_replace('/[\s]*/', '', $name); // remove extra spaces
+		$color = strtolower($color);
+		if (isset(self::$spotcolor[$color])) {
+			if (!isset($spotc[$name])) {
+				$i = (1 + count($spotc));
+				$spotc[$name] = array('C' => self::$spotcolor[$color][0], 'M' => self::$spotcolor[$color][1], 'Y' => self::$spotcolor[$color][2], 'K' => self::$spotcolor[$color][3], 'name' => self::$spotcolor[$color][4], 'i' => $i);
+			}
+			return $spotc[self::$spotcolor[$color][4]];
+		}
+		return false;
+	}
+
+	/**
+	 * Returns an array (RGB or CMYK) from an html color name, or a six-digit (i.e. #3FE5AA), or three-digit (i.e. #7FF) hexadecimal color, or a javascript color array, or javascript color name.
+	 * @param string $hcolor HTML color.
+	 * @param array $spotc Reference to an array of spot colors.
+	 * @param array $defcol Color to return in case of error.
+	 * @return array|false RGB or CMYK color, or false in case of error.
+	 * @public static
+	 */
+	public static function convertHTMLColorToDec($hcolor, &$spotc, $defcol=array('R'=>128,'G'=>128,'B'=>128)) {
+		$color = preg_replace('/[\s]*/', '', $hcolor); // remove extra spaces
+		$color = strtolower($color);
+		// check for javascript color array syntax
+		if (strpos($color, '[') !== false) {
+			if (preg_match('/[\[][\"\'](t|g|rgba|rgb|cmyk)[\"\'][\,]?([0-9\.]*+)[\,]?([0-9\.]*+)[\,]?([0-9\.]*+)[\,]?([0-9\.]*+)[\]]/', $color, $m) > 0) {
+				$returncolor = array();
+				switch ($m[1]) {
+					case 'cmyk': {
+						// RGB
+						$returncolor['C'] = max(0, min(100, (floatval($m[2]) * 100)));
+						$returncolor['M'] = max(0, min(100, (floatval($m[3]) * 100)));
+						$returncolor['Y'] = max(0, min(100, (floatval($m[4]) * 100)));
+						$returncolor['K'] = max(0, min(100, (floatval($m[5]) * 100)));
+						break;
+					}
+					case 'rgb':
+					case 'rgba': {
+						// RGB
+						$returncolor['R'] = max(0, min(255, (floatval($m[2]) * 255)));
+						$returncolor['G'] = max(0, min(255, (floatval($m[3]) * 255)));
+						$returncolor['B'] = max(0, min(255, (floatval($m[4]) * 255)));
+						break;
+					}
+					case 'g': {
+						// grayscale
+						$returncolor['G'] = max(0, min(255, (floatval($m[2]) * 255)));
+						break;
+					}
+					case 't':
+					default: {
+						// transparent (empty array)
+						break;
+					}
+				}
+				return $returncolor;
+			}
+		} elseif ((substr($color, 0, 4) != 'cmyk') AND (substr($color, 0, 3) != 'rgb') AND (($dotpos = strpos($color, '.')) !== false)) {
+			// remove class parent (i.e.: color.red)
+			$color = substr($color, ($dotpos + 1));
+			if ($color == 'transparent') {
+				// transparent (empty array)
+				return array();
+			}
+		}
+		if (strlen($color) == 0) {
+			return $defcol;
+		}
+		// RGBA ARRAY
+		if (substr($color, 0, 4) == 'rgba') {
+			$codes = substr($color, 5);
+			$codes = str_replace(')', '', $codes);
+			$returncolor = explode(',', $codes);
+			// remove alpha component
+			array_pop($returncolor);
+			foreach ($returncolor as $key => $val) {
+				if (strpos($val, '%') > 0) {
+					// percentage
+					$returncolor[$key] = (255 * intval($val) / 100);
+				} else {
+					$returncolor[$key] = intval($val); /* floatize */
+				}
+				// normalize value
+				$returncolor[$key] = max(0, min(255, $returncolor[$key]));
+			}
+			return $returncolor;
+		}
+		// RGB ARRAY
+		if (substr($color, 0, 3) == 'rgb') {
+			$codes = substr($color, 4);
+			$codes = str_replace(')', '', $codes);
+			$returncolor = explode(',', $codes);
+			foreach ($returncolor as $key => $val) {
+				if (strpos($val, '%') > 0) {
+					// percentage
+					$returncolor[$key] = (255 * intval($val) / 100);
+				} else {
+					$returncolor[$key] = intval($val);
+				}
+				// normalize value
+				$returncolor[$key] = max(0, min(255, $returncolor[$key]));
+			}
+			return $returncolor;
+		}
+		// CMYK ARRAY
+		if (substr($color, 0, 4) == 'cmyk') {
+			$codes = substr($color, 5);
+			$codes = str_replace(')', '', $codes);
+			$returncolor = explode(',', $codes);
+			foreach ($returncolor as $key => $val) {
+				if (strpos($val, '%') !== false) {
+					// percentage
+					$returncolor[$key] = (100 * intval($val) / 100);
+				} else {
+					$returncolor[$key] = intval($val);
+				}
+				// normalize value
+				$returncolor[$key] = max(0, min(100, $returncolor[$key]));
+			}
+			return $returncolor;
+		}
+		if ($color[0] != '#') {
+			// COLOR NAME
+			if (isset(self::$webcolor[$color])) {
+				// web color
+				$color_code = self::$webcolor[$color];
+			} else {
+				// spot color
+				$returncolor = self::getSpotColor($hcolor, $spotc);
+				if ($returncolor === false) {
+					$returncolor = $defcol;
+				}
+				return $returncolor;
+			}
+		} else {
+			$color_code = substr($color, 1);
+		}
+		// HEXADECIMAL REPRESENTATION
+		switch (strlen($color_code)) {
+			case 3: {
+				// 3-digit RGB hexadecimal representation
+				$r = substr($color_code, 0, 1);
+				$g = substr($color_code, 1, 1);
+				$b = substr($color_code, 2, 1);
+				$returncolor = array();
+				$returncolor['R'] = max(0, min(255, hexdec($r.$r)));
+				$returncolor['G'] = max(0, min(255, hexdec($g.$g)));
+				$returncolor['B'] = max(0, min(255, hexdec($b.$b)));
+				break;
+			}
+			case 6: {
+				// 6-digit RGB hexadecimal representation
+				$returncolor = array();
+				$returncolor['R'] = max(0, min(255, hexdec(substr($color_code, 0, 2))));
+				$returncolor['G'] = max(0, min(255, hexdec(substr($color_code, 2, 2))));
+				$returncolor['B'] = max(0, min(255, hexdec(substr($color_code, 4, 2))));
+				break;
+			}
+			case 8: {
+				// 8-digit CMYK hexadecimal representation
+				$returncolor = array();
+				$returncolor['C'] = max(0, min(100, round(hexdec(substr($color_code, 0, 2)) / 2.55)));
+				$returncolor['M'] = max(0, min(100, round(hexdec(substr($color_code, 2, 2)) / 2.55)));
+				$returncolor['Y'] = max(0, min(100, round(hexdec(substr($color_code, 4, 2)) / 2.55)));
+				$returncolor['K'] = max(0, min(100, round(hexdec(substr($color_code, 6, 2)) / 2.55)));
+				break;
+			}
+			default: {
+				$returncolor = $defcol;
+				break;
+			}
+		}
+		return $returncolor;
+	}
+
+	/**
+	 * Convert a color array into a string representation.
+	 * @param array $c Array of colors.
+	 * @return string The color array representation.
+	 * @since 5.9.137 (2011-12-01)
+	 * @public static
+	 */
+	public static function getColorStringFromArray($c) {
+		$c = array_values($c);
+		$color = '[';
+		switch (count($c)) {
+			case 4: {
+				// CMYK
+				$color .= sprintf('%F %F %F %F', (max(0, min(100, floatval($c[0]))) / 100), (max(0, min(100, floatval($c[1]))) / 100), (max(0, min(100, floatval($c[2]))) / 100), (max(0, min(100, floatval($c[3]))) / 100));
+				break;
+			}
+			case 3: {
+				// RGB
+				$color .= sprintf('%F %F %F', (max(0, min(255, floatval($c[0]))) / 255), (max(0, min(255, floatval($c[1]))) / 255), (max(0, min(255, floatval($c[2]))) / 255));
+				break;
+			}
+			case 1: {
+				// grayscale
+				$color .= sprintf('%F', (max(0, min(255, floatval($c[0]))) / 255));
+				break;
+			}
+		}
+		$color .= ']';
+		return $color;
+	}
+
+	/**
+	 * Convert color to javascript color.
+	 * @param string $color color name or "#RRGGBB"
+	 * @protected
+	 * @since 2.1.002 (2008-02-12)
+	 * @public static
+	 */
+	public static function _JScolor($color) {
+		if (substr($color, 0, 1) == '#') {
+			return sprintf("['RGB',%F,%F,%F]", (hexdec(substr($color, 1, 2)) / 255), (hexdec(substr($color, 3, 2)) / 255), (hexdec(substr($color, 5, 2)) / 255));
+		}
+		if (!in_array($color, self::$jscolor)) {
+			// default transparent color
+			$color = self::$jscolor[0];
+		}
+		return 'color.'.$color;
+	}
+
+
+} // END OF TCPDF_COLORS CLASS
+
+//============================================================+
+// END OF FILE
+//============================================================+

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/include/tcpdf_filters.php

@@ -0,0 +1,481 @@
+<?php
+//============================================================+
+// File name   : tcpdf_filters.php
+// Version     : 1.0.001
+// Begin       : 2011-05-23
+// Last Update : 2014-04-25
+// Author      : Nicola Asuni - Tecnick.com LTD - www.tecnick.com - info@tecnick.com
+// License     : GNU-LGPL v3 (https://www.gnu.org/copyleft/lesser.html)
+// -------------------------------------------------------------------
+// Copyright (C) 2011-2026 Nicola Asuni - Tecnick.com LTD
+//
+// This file is part of TCPDF software library.
+//
+// TCPDF is free software: you can redistribute it and/or modify it
+// under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// TCPDF is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the License
+// along with TCPDF. If not, see
+// <http://www.tecnick.com/pagefiles/tcpdf/LICENSE.TXT>.
+//
+// See LICENSE.TXT file for more information.
+// -------------------------------------------------------------------
+//
+// Description : This is a PHP class for decoding common PDF filters (PDF 32000-2008 - 7.4 Filters).
+//
+//============================================================+
+
+/**
+ * @file
+ * This is a PHP class for decoding common PDF filters (PDF 32000-2008 - 7.4 Filters).<br>
+ * @package com.tecnick.tcpdf
+ * @author Nicola Asuni
+ * @version 1.0.001
+ */
+
+/**
+ * @class TCPDF_FILTERS
+ * This is a PHP class for decoding common PDF filters (PDF 32000-2008 - 7.4 Filters).<br>
+ * @package com.tecnick.tcpdf
+ * @brief This is a PHP class for decoding common PDF filters.
+ * @version 1.0.001
+ * @author Nicola Asuni - info@tecnick.com
+ */
+class TCPDF_FILTERS {
+
+	/**
+	 * Define a list of available filter decoders.
+	 * @private static
+	 */
+	private static $available_filters = array('ASCIIHexDecode', 'ASCII85Decode', 'LZWDecode', 'FlateDecode', 'RunLengthDecode');
+
+// -----------------------------------------------------------------------------
+
+	/**
+	 * Get a list of available decoding filters.
+	 * @return array Array of available filter decoders.
+	 * @since 1.0.000 (2011-05-23)
+	 * @public static
+	 */
+	public static function getAvailableFilters() {
+		return self::$available_filters;
+	}
+
+	/**
+	 * Decode data using the specified filter type.
+	 * @param string $filter Filter name.
+	 * @param string $data Data to decode.
+	 * @return string Decoded data string.
+	 * @since 1.0.000 (2011-05-23)
+	 * @public static
+	 */
+	public static function decodeFilter($filter, $data) {
+		switch ($filter) {
+			case 'ASCIIHexDecode': {
+				return self::decodeFilterASCIIHexDecode($data);
+				break;
+			}
+			case 'ASCII85Decode': {
+				return self::decodeFilterASCII85Decode($data);
+				break;
+			}
+			case 'LZWDecode': {
+				return self::decodeFilterLZWDecode($data);
+				break;
+			}
+			case 'FlateDecode': {
+				return self::decodeFilterFlateDecode($data);
+				break;
+			}
+			case 'RunLengthDecode': {
+				return self::decodeFilterRunLengthDecode($data);
+				break;
+			}
+			case 'CCITTFaxDecode': {
+				return self::decodeFilterCCITTFaxDecode($data);
+				break;
+			}
+			case 'JBIG2Decode': {
+				return self::decodeFilterJBIG2Decode($data);
+				break;
+			}
+			case 'DCTDecode': {
+				return self::decodeFilterDCTDecode($data);
+				break;
+			}
+			case 'JPXDecode': {
+				return self::decodeFilterJPXDecode($data);
+				break;
+			}
+			case 'Crypt': {
+				return self::decodeFilterCrypt($data);
+				break;
+			}
+			default: {
+				return self::decodeFilterStandard($data);
+				break;
+			}
+		}
+	}
+
+	// --- FILTERS (PDF 32000-2008 - 7.4 Filters) ------------------------------
+
+	/**
+	 * Standard
+	 * Default decoding filter (leaves data unchanged).
+	 * @param string $data Data to decode.
+	 * @return string Decoded data string.
+	 * @since 1.0.000 (2011-05-23)
+	 * @public static
+	 */
+	public static function decodeFilterStandard($data) {
+		return $data;
+	}
+
+	/**
+	 * ASCIIHexDecode
+	 * Decodes data encoded in an ASCII hexadecimal representation, reproducing the original binary data.
+	 * @param string $data Data to decode.
+	 * @return string Decoded data string.
+	 * @since 1.0.000 (2011-05-23)
+	 * @public static
+	 */
+	public static function decodeFilterASCIIHexDecode($data) {
+		// initialize string to return
+		$decoded = '';
+		// all white-space characters shall be ignored
+		$data = preg_replace('/[\s]/', '', $data);
+		// check for EOD character: GREATER-THAN SIGN (3Eh)
+		$eod = strpos($data, '>');
+		if ($eod !== false) {
+			// remove EOD and extra data (if any)
+			$data = substr($data, 0, $eod);
+			$eod = true;
+		}
+		// get data length
+		$data_length = strlen($data);
+		if (($data_length % 2) != 0) {
+			// odd number of hexadecimal digits
+			if ($eod) {
+				// EOD shall behave as if a 0 (zero) followed the last digit
+				$data = substr($data, 0, -1).'0'.substr($data, -1);
+			} else {
+				self::Error('decodeFilterASCIIHexDecode: invalid code');
+			}
+		}
+		// check for invalid characters
+		if (preg_match('/[^a-fA-F\d]/', $data) > 0) {
+			self::Error('decodeFilterASCIIHexDecode: invalid code');
+		}
+		// get one byte of binary data for each pair of ASCII hexadecimal digits
+		$decoded = pack('H*', $data);
+		return $decoded;
+	}
+
+	/**
+	 * ASCII85Decode
+	 * Decodes data encoded in an ASCII base-85 representation, reproducing the original binary data.
+	 * @param string $data Data to decode.
+	 * @return string Decoded data string.
+	 * @since 1.0.000 (2011-05-23)
+	 * @public static
+	 */
+	public static function decodeFilterASCII85Decode($data) {
+		// initialize string to return
+		$decoded = '';
+		// all white-space characters shall be ignored
+		$data = preg_replace('/[\s]/', '', $data);
+		// remove start sequence 2-character sequence <~ (3Ch)(7Eh)
+		if (strpos($data, '<~') !== false) {
+			// remove EOD and extra data (if any)
+			$data = substr($data, 2);
+		}
+		// check for EOD: 2-character sequence ~> (7Eh)(3Eh)
+		$eod = strpos($data, '~>');
+		if ($eod !== false) {
+			// remove EOD and extra data (if any)
+			$data = substr($data, 0, $eod);
+		}
+		// data length
+		$data_length = strlen($data);
+		// check for invalid characters
+		if (preg_match('/[^\x21-\x75,\x74]/', $data) > 0) {
+			self::Error('decodeFilterASCII85Decode: invalid code');
+		}
+		// z sequence
+		$zseq = chr(0).chr(0).chr(0).chr(0);
+		// position inside a group of 4 bytes (0-3)
+		$group_pos = 0;
+		$tuple = 0;
+		$pow85 = array((85*85*85*85), (85*85*85), (85*85), 85, 1);
+		$last_pos = ($data_length - 1);
+		// for each byte
+		for ($i = 0; $i < $data_length; ++$i) {
+			// get char value
+			$char = ord($data[$i]);
+			if ($char == 122) { // 'z'
+				if ($group_pos == 0) {
+					$decoded .= $zseq;
+				} else {
+					self::Error('decodeFilterASCII85Decode: invalid code');
+				}
+			} else {
+				// the value represented by a group of 5 characters should never be greater than 2^32 - 1
+				$tuple += (($char - 33) * $pow85[$group_pos]);
+				if ($group_pos == 4) {
+					$decoded .= chr($tuple >> 24).chr($tuple >> 16).chr($tuple >> 8).chr($tuple);
+					$tuple = 0;
+					$group_pos = 0;
+				} else {
+					++$group_pos;
+				}
+			}
+		}
+		if ($group_pos > 1) {
+			$tuple += $pow85[($group_pos - 1)];
+		}
+		// last tuple (if any)
+		switch ($group_pos) {
+			case 4: {
+				$decoded .= chr($tuple >> 24).chr($tuple >> 16).chr($tuple >> 8);
+				break;
+			}
+			case 3: {
+				$decoded .= chr($tuple >> 24).chr($tuple >> 16);
+				break;
+			}
+			case 2: {
+				$decoded .= chr($tuple >> 24);
+				break;
+			}
+			case 1: {
+				self::Error('decodeFilterASCII85Decode: invalid code');
+				break;
+			}
+		}
+		return $decoded;
+	}
+
+	/**
+	 * LZWDecode
+	 * Decompresses data encoded using the LZW (Lempel-Ziv-Welch) adaptive compression method, reproducing the original text or binary data.
+	 * @param string $data Data to decode.
+	 * @return string Decoded data string.
+	 * @since 1.0.000 (2011-05-23)
+	 * @public static
+	 */
+	public static function decodeFilterLZWDecode($data) {
+		// initialize string to return
+		$decoded = '';
+		// data length
+		$data_length = strlen($data);
+		// convert string to binary string
+		$bitstring = '';
+		for ($i = 0; $i < $data_length; ++$i) {
+			$bitstring .= sprintf('%08b', ord($data[$i]));
+		}
+		// get the number of bits
+		$data_length = strlen($bitstring);
+		// initialize code length in bits
+		$bitlen = 9;
+		// initialize dictionary index
+		$dix = 258;
+		// initialize the dictionary (with the first 256 entries).
+		$dictionary = array();
+		for ($i = 0; $i < 256; ++$i) {
+			$dictionary[$i] = chr($i);
+		}
+		// previous val
+		$prev_index = 0;
+		// while we encounter EOD marker (257), read code_length bits
+		while (($data_length > 0) AND (($index = bindec(substr($bitstring, 0, $bitlen))) != 257)) {
+			// remove read bits from string
+			$bitstring = substr($bitstring, $bitlen);
+			// update number of bits
+			$data_length -= $bitlen;
+			if ($index == 256) { // clear-table marker
+				// reset code length in bits
+				$bitlen = 9;
+				// reset dictionary index
+				$dix = 258;
+				$prev_index = 256;
+				// reset the dictionary (with the first 256 entries).
+				$dictionary = array();
+				for ($i = 0; $i < 256; ++$i) {
+					$dictionary[$i] = chr($i);
+				}
+			} elseif ($prev_index == 256) {
+				// first entry
+				$decoded .= $dictionary[$index];
+				$prev_index = $index;
+			} else {
+				// check if index exist in the dictionary
+				if ($index < $dix) {
+					// index exist on dictionary
+					$decoded .= $dictionary[$index];
+					$dic_val = $dictionary[$prev_index].$dictionary[$index][0];
+					// store current index
+					$prev_index = $index;
+				} else {
+					// index do not exist on dictionary
+					$dic_val = $dictionary[$prev_index].$dictionary[$prev_index][0];
+					$decoded .= $dic_val;
+				}
+				// update dictionary
+				$dictionary[$dix] = $dic_val;
+				++$dix;
+				// change bit length by case
+				if ($dix == 2047) {
+					$bitlen = 12;
+				} elseif ($dix == 1023) {
+					$bitlen = 11;
+				} elseif ($dix == 511) {
+					$bitlen = 10;
+				}
+			}
+		}
+		return $decoded;
+	}
+
+	/**
+	 * FlateDecode
+	 * Decompresses data encoded using the zlib/deflate compression method, reproducing the original text or binary data.
+	 * @param string $data Data to decode.
+	 * @return string Decoded data string.
+	 * @since 1.0.000 (2011-05-23)
+	 * @public static
+	 */
+	public static function decodeFilterFlateDecode($data) {
+		// initialize string to return
+		$decoded = @gzuncompress($data);
+		if ($decoded === false) {
+			self::Error('decodeFilterFlateDecode: invalid code');
+		}
+		return $decoded;
+	}
+
+	/**
+	 * RunLengthDecode
+	 * Decompresses data encoded using a byte-oriented run-length encoding algorithm.
+	 * @param string $data Data to decode.
+	 * @since 1.0.000 (2011-05-23)
+	 * @public static
+	 */
+	public static function decodeFilterRunLengthDecode($data) {
+		// initialize string to return
+		$decoded = '';
+		// data length
+		$data_length = strlen($data);
+		$i = 0;
+		while($i < $data_length) {
+			// get current byte value
+			$byte = ord($data[$i]);
+			if ($byte == 128) {
+				// a length value of 128 denote EOD
+				break;
+			} elseif ($byte < 128) {
+				// if the length byte is in the range 0 to 127
+				// the following length + 1 (1 to 128) bytes shall be copied literally during decompression
+				$decoded .= substr($data, ($i + 1), ($byte + 1));
+				// move to next block
+				$i += ($byte + 2);
+			} else {
+				// if length is in the range 129 to 255,
+				// the following single byte shall be copied 257 - length (2 to 128) times during decompression
+				$decoded .= str_repeat($data[($i + 1)], (257 - $byte));
+				// move to next block
+				$i += 2;
+			}
+		}
+		return $decoded;
+	}
+
+	/**
+	 * CCITTFaxDecode (NOT IMPLEMETED - RETURN AN EXCEPTION)
+	 * Decompresses data encoded using the CCITT facsimile standard, reproducing the original data (typically monochrome image data at 1 bit per pixel).
+	 * @param string $data Data to decode.
+	 * @return string Decoded data string.
+	 * @since 1.0.000 (2011-05-23)
+	 * @public static
+	 */
+	public static function decodeFilterCCITTFaxDecode($data) {
+		self::Error('~decodeFilterCCITTFaxDecode: this method has not been yet implemented');
+		//return $data;
+	}
+
+	/**
+	 * JBIG2Decode (NOT IMPLEMETED - RETURN AN EXCEPTION)
+	 * Decompresses data encoded using the JBIG2 standard, reproducing the original monochrome (1 bit per pixel) image data (or an approximation of that data).
+	 * @param string $data Data to decode.
+	 * @return string Decoded data string.
+	 * @since 1.0.000 (2011-05-23)
+	 * @public static
+	 */
+	public static function decodeFilterJBIG2Decode($data) {
+		self::Error('~decodeFilterJBIG2Decode: this method has not been yet implemented');
+		//return $data;
+	}
+
+	/**
+	 * DCTDecode (NOT IMPLEMETED - RETURN AN EXCEPTION)
+	 * Decompresses data encoded using a DCT (discrete cosine transform) technique based on the JPEG standard, reproducing image sample data that approximates the original data.
+	 * @param string $data Data to decode.
+	 * @return string Decoded data string.
+	 * @since 1.0.000 (2011-05-23)
+	 * @public static
+	 */
+	public static function decodeFilterDCTDecode($data) {
+		self::Error('~decodeFilterDCTDecode: this method has not been yet implemented');
+		//return $data;
+	}
+
+	/**
+	 * JPXDecode (NOT IMPLEMETED - RETURN AN EXCEPTION)
+	 * Decompresses data encoded using the wavelet-based JPEG2000 standard, reproducing the original image data.
+	 * @param string $data Data to decode.
+	 * @return string Decoded data string.
+	 * @since 1.0.000 (2011-05-23)
+	 * @public static
+	 */
+	public static function decodeFilterJPXDecode($data) {
+		self::Error('~decodeFilterJPXDecode: this method has not been yet implemented');
+		//return $data;
+	}
+
+	/**
+	 * Crypt (NOT IMPLEMETED - RETURN AN EXCEPTION)
+	 * Decrypts data encrypted by a security handler, reproducing the data as it was before encryption.
+	 * @param string $data Data to decode.
+	 * @return string Decoded data string.
+	 * @since 1.0.000 (2011-05-23)
+	 * @public static
+	 */
+	public static function decodeFilterCrypt($data) {
+		self::Error('~decodeFilterCrypt: this method has not been yet implemented');
+		//return $data;
+	}
+
+	// --- END FILTERS SECTION -------------------------------------------------
+
+	/**
+	 * Throw an exception.
+	 * @param string $msg The error message
+	 * @since 1.0.000 (2011-05-23)
+	 * @public static
+	 */
+	public static function Error($msg) {
+		throw new Exception('TCPDF_PARSER ERROR: '.$msg);
+	}
+
+} // END OF TCPDF_FILTERS CLASS
+
+//============================================================+
+// END OF FILE
+//============================================================+

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/include/tcpdf_images.php

@@ -0,0 +1,363 @@
+<?php
+//============================================================+
+// File name   : tcpdf_images.php
+// Version     : 1.0.005
+// Begin       : 2002-08-03
+// Last Update : 2014-11-15
+// Author      : Nicola Asuni - Tecnick.com LTD - www.tecnick.com - info@tecnick.com
+// License     : GNU-LGPL v3 (https://www.gnu.org/copyleft/lesser.html)
+// -------------------------------------------------------------------
+// Copyright (C) 2002-2026 Nicola Asuni - Tecnick.com LTD
+//
+// This file is part of TCPDF software library.
+//
+// TCPDF is free software: you can redistribute it and/or modify it
+// under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// TCPDF is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the License
+// along with TCPDF. If not, see
+// <http://www.tecnick.com/pagefiles/tcpdf/LICENSE.TXT>.
+//
+// See LICENSE.TXT file for more information.
+// -------------------------------------------------------------------
+//
+// Description :
+//   Static image methods used by the TCPDF class.
+//
+//============================================================+
+
+/**
+ * @file
+ * This is a PHP class that contains static image methods for the TCPDF class.<br>
+ * @package com.tecnick.tcpdf
+ * @author Nicola Asuni
+ * @version 1.0.005
+ */
+
+/**
+ * @class TCPDF_IMAGES
+ * Static image methods used by the TCPDF class.
+ * @package com.tecnick.tcpdf
+ * @brief PHP class for generating PDF documents without requiring external extensions.
+ * @version 1.0.005
+ * @author Nicola Asuni - info@tecnick.com
+ */
+class TCPDF_IMAGES {
+
+	/**
+	 * Array of hinheritable SVG properties.
+	 * @since 5.0.000 (2010-05-02)
+	 * @public static
+	 * 
+	 * @var string[]
+	 */
+	public static $svginheritprop = array('clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cursor', 'direction', 'display', 'fill', 'fill-opacity', 'fill-rule', 'font', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'glyph-orientation-horizontal', 'glyph-orientation-vertical', 'image-rendering', 'kerning', 'letter-spacing', 'marker', 'marker-end', 'marker-mid', 'marker-start', 'pointer-events', 'shape-rendering', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'text-anchor', 'text-rendering', 'visibility', 'word-spacing', 'writing-mode');
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	/**
+	 * Return the image type given the file name or array returned by getimagesize() function.
+	 * @param string $imgfile image file name
+	 * @param array $iminfo array of image information returned by getimagesize() function.
+	 * @return string image type
+	 * @since 4.8.017 (2009-11-27)
+	 * @public static
+	 */
+	public static function getImageFileType($imgfile, $iminfo=array()) {
+		$type = '';
+		if (isset($iminfo['mime']) AND !empty($iminfo['mime'])) {
+			$mime = explode('/', $iminfo['mime']);
+			if ((count($mime) > 1) AND ($mime[0] == 'image') AND (!empty($mime[1]))) {
+				$type = strtolower(trim($mime[1]));
+			}
+		}
+		if (empty($type)) {
+            $type = strtolower(trim(pathinfo(parse_url($imgfile, PHP_URL_PATH), PATHINFO_EXTENSION)));
+		}
+		if ($type == 'jpg') {
+			$type = 'jpeg';
+		}
+		return $type;
+	}
+
+	/**
+	 * Set the transparency for the given GD image.
+	 * @param resource $new_image GD image object
+	 * @param resource $image GD image object.
+	 * @return resource GD image object $new_image
+	 * @since 4.9.016 (2010-04-20)
+	 * @public static
+	 */
+	public static function setGDImageTransparency($new_image, $image) {
+		// default transparency color (white)
+		$tcol = array('red' => 255, 'green' => 255, 'blue' => 255);
+		// transparency index
+		$tid = imagecolortransparent($image);
+		$palletsize = imagecolorstotal($image);
+		if (($tid >= 0) AND ($tid < $palletsize)) {
+			// get the colors for the transparency index
+			$tcol = imagecolorsforindex($image, $tid);
+		}
+		$tid = imagecolorallocate($new_image, $tcol['red'], $tcol['green'], $tcol['blue']);
+		imagefill($new_image, 0, 0, $tid);
+		imagecolortransparent($new_image, $tid);
+		return $new_image;
+	}
+
+	/**
+	 * Convert the loaded image to a PNG and then return a structure for the PDF creator.
+	 * This function requires GD library and write access to the directory defined on K_PATH_CACHE constant.
+	 * @param resource $image Image object.
+	 * @param string $tempfile Temporary file name.
+	 * return image PNG image object.
+	 * @since 4.9.016 (2010-04-20)
+	 * @public static
+	 */
+	public static function _toPNG($image, $tempfile) {
+		// turn off interlaced mode
+		imageinterlace($image, 0);
+		// create temporary PNG image
+		imagepng($image, $tempfile);
+		// remove image from memory
+		if (PHP_VERSION_ID < 80000) {
+			imagedestroy($image);
+		}
+		// get PNG image data
+		$retvars = self::_parsepng($tempfile);
+		// tidy up by removing temporary image
+		unlink($tempfile);
+		return $retvars;
+	}
+
+	/**
+	 * Convert the loaded image to a JPEG and then return a structure for the PDF creator.
+	 * This function requires GD library and write access to the directory defined on K_PATH_CACHE constant.
+	 * @param resource $image Image object.
+	 * @param int $quality JPEG quality.
+	 * @param string $tempfile Temporary file name.
+	 * return array|false image JPEG image object.
+	 * @public static
+	 */
+	public static function _toJPEG($image, $quality, $tempfile) {
+		imagejpeg($image, $tempfile, $quality);
+		if (PHP_VERSION_ID < 80000) {
+			imagedestroy($image);
+		}
+		$retvars = self::_parsejpeg($tempfile);
+		// tidy up by removing temporary image
+		unlink($tempfile);
+		return $retvars;
+	}
+
+	/**
+	 * Extract info from a JPEG file without using the GD library.
+	 * @param string $file image file to parse
+	 * @return array|false structure containing the image data
+	 * @public static
+	 */
+	public static function _parsejpeg($file) {
+		// check if is a local file
+		if (!@TCPDF_STATIC::file_exists($file)) {
+			return false;
+		}
+		$a = getimagesize($file);
+		if (empty($a)) {
+			//Missing or incorrect image file
+			return false;
+		}
+		if ($a[2] != 2) {
+			// Not a JPEG file
+			return false;
+		}
+		// bits per pixel
+		$bpc = isset($a['bits']) ? intval($a['bits']) : 8;
+		// number of image channels
+		if (!isset($a['channels'])) {
+			$channels = 3;
+		} else {
+			$channels = intval($a['channels']);
+		}
+		// default colour space
+		switch ($channels) {
+			case 1: {
+				$colspace = 'DeviceGray';
+				break;
+			}
+			case 3: {
+				$colspace = 'DeviceRGB';
+				break;
+			}
+			case 4: {
+				$colspace = 'DeviceCMYK';
+				break;
+			}
+			default: {
+				$channels = 3;
+				$colspace = 'DeviceRGB';
+				break;
+			}
+		}
+		// get file content
+		$data = file_get_contents($file);
+		// check for embedded ICC profile
+		$icc = array();
+		$offset = 0;
+		while (($pos = strpos($data, "ICC_PROFILE\0", $offset)) !== false) {
+			// get ICC sequence length
+			$length = (TCPDF_STATIC::_getUSHORT($data, ($pos - 2)) - 16);
+			// marker sequence number
+			$msn = max(1, ord($data[($pos + 12)]));
+			// number of markers (total of APP2 used)
+			$nom = max(1, ord($data[($pos + 13)]));
+			// get sequence segment
+			$icc[($msn - 1)] = substr($data, ($pos + 14), $length);
+			// move forward to next sequence
+			$offset = ($pos + 14 + $length);
+		}
+		// order and compact ICC segments
+		if (count($icc) > 0) {
+			ksort($icc);
+			$icc = implode('', $icc);
+			if ((ord($icc[36]) != 0x61) OR (ord($icc[37]) != 0x63) OR (ord($icc[38]) != 0x73) OR (ord($icc[39]) != 0x70)) {
+				// invalid ICC profile
+				$icc = false;
+			}
+		} else {
+			$icc = false;
+		}
+		return array('w' => $a[0], 'h' => $a[1], 'ch' => $channels, 'icc' => $icc, 'cs' => $colspace, 'bpc' => $bpc, 'f' => 'DCTDecode', 'data' => $data);
+	}
+
+	/**
+	 * Extract info from a PNG file without using the GD library.
+	 * @param string $file image file to parse
+	 * @return array|false structure containing the image data
+	 * @public static
+	 */
+	public static function _parsepng($file) {
+		$f = @fopen($file, 'rb');
+		if ($f === false) {
+			// Can't open image file
+			return false;
+		}
+		//Check signature
+		if (fread($f, 8) != chr(137).'PNG'.chr(13).chr(10).chr(26).chr(10)) {
+			// Not a PNG file
+			return false;
+		}
+		//Read header chunk
+		fread($f, 4);
+		if (fread($f, 4) != 'IHDR') {
+			//Incorrect PNG file
+			return false;
+		}
+		$w = TCPDF_STATIC::_freadint($f);
+		$h = TCPDF_STATIC::_freadint($f);
+		$bpc = ord(fread($f, 1));
+		$ct = ord(fread($f, 1));
+		if ($ct == 0) {
+			$colspace = 'DeviceGray';
+		} elseif ($ct == 2) {
+			$colspace = 'DeviceRGB';
+		} elseif ($ct == 3) {
+			$colspace = 'Indexed';
+		} else {
+			// alpha channel
+			fclose($f);
+			return 'pngalpha';
+		}
+		if (ord(fread($f, 1)) != 0) {
+			// Unknownn compression method
+			fclose($f);
+			return false;
+		}
+		if (ord(fread($f, 1)) != 0) {
+			// Unknownn filter method
+			fclose($f);
+			return false;
+		}
+		if (ord(fread($f, 1)) != 0) {
+			// Interlacing not supported
+			fclose($f);
+			return false;
+		}
+		fread($f, 4);
+		$channels = ($ct == 2 ? 3 : 1);
+		$parms = '/DecodeParms << /Predictor 15 /Colors '.$channels.' /BitsPerComponent '.$bpc.' /Columns '.$w.' >>';
+		//Scan chunks looking for palette, transparency and image data
+		$pal = '';
+		$trns = '';
+		$data = '';
+		$icc = false;
+		$n = TCPDF_STATIC::_freadint($f);
+		do {
+			$type = fread($f, 4);
+			if ($type == 'PLTE') {
+				// read palette
+				$pal = TCPDF_STATIC::rfread($f, $n);
+				fread($f, 4);
+			} elseif ($type == 'tRNS') {
+				// read transparency info
+				$t = TCPDF_STATIC::rfread($f, $n);
+				if ($ct == 0) { // DeviceGray
+					$trns = array(ord($t[1]));
+				} elseif ($ct == 2) { // DeviceRGB
+					$trns = array(ord($t[1]), ord($t[3]), ord($t[5]));
+				} else { // Indexed
+					if ($n > 0) {
+						$trns = array();
+						for ($i = 0; $i < $n; ++ $i) {
+							$trns[] = ord($t[$i]);
+						}
+					}
+				}
+				fread($f, 4);
+			} elseif ($type == 'IDAT') {
+				// read image data block
+				$data .= TCPDF_STATIC::rfread($f, $n);
+				fread($f, 4);
+			} elseif ($type == 'iCCP') {
+				// skip profile name
+				$len = 0;
+				while ((ord(fread($f, 1)) != 0) AND ($len < 80)) {
+					++$len;
+				}
+				// get compression method
+				if (ord(fread($f, 1)) != 0) {
+					// Unknownn filter method
+					fclose($f);
+					return false;
+				}
+				// read ICC Color Profile
+				$icc = TCPDF_STATIC::rfread($f, ($n - $len - 2));
+				// decompress profile
+				$icc = gzuncompress($icc);
+				fread($f, 4);
+			} elseif ($type == 'IEND') {
+				break;
+			} else {
+				TCPDF_STATIC::rfread($f, $n + 4);
+			}
+			$n = TCPDF_STATIC::_freadint($f);
+		} while ($n);
+		if (($colspace == 'Indexed') AND (empty($pal))) {
+			// Missing palette
+			fclose($f);
+			return false;
+		}
+		fclose($f);
+		return array('w' => $w, 'h' => $h, 'ch' => $channels, 'icc' => $icc, 'cs' => $colspace, 'bpc' => $bpc, 'f' => 'FlateDecode', 'parms' => $parms, 'pal' => $pal, 'trns' => $trns, 'data' => $data);
+	}
+
+} // END OF TCPDF_IMAGES CLASS
+
+//============================================================+
+// END OF FILE
+//============================================================+

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/tcpdf_autoconfig.php

@@ -0,0 +1,255 @@
+<?php
+//============================================================+
+// File name   : tcpdf_autoconfig.php
+// Version     : 1.1.1
+// Begin       : 2013-05-16
+// Last Update : 2025-04-18
+// Authors     : Nicola Asuni - Tecnick.com LTD - www.tecnick.com - info@tecnick.com
+// License     : GNU-LGPL v3 (https://www.gnu.org/copyleft/lesser.html)
+// -------------------------------------------------------------------
+// Copyright (C) 2011-2026 Nicola Asuni - Tecnick.com LTD
+//
+// This file is part of TCPDF software library.
+//
+// TCPDF is free software: you can redistribute it and/or modify it
+// under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// TCPDF is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the License
+// along with TCPDF. If not, see
+// <http://www.tecnick.com/pagefiles/tcpdf/LICENSE.TXT>.
+//
+// See LICENSE.TXT file for more information.
+// -------------------------------------------------------------------
+//
+// Description : Try to automatically configure some TCPDF
+//               constants if not defined.
+//
+//============================================================+
+
+/**
+ * @file
+ * Try to automatically configure some TCPDF constants if not defined.
+ * @package com.tecnick.tcpdf
+ * @version 1.2.1
+ */
+
+// Disable phar stream wrapper globally.
+// if (in_array('phar', stream_get_wrappers(), true)) {
+//     stream_wrapper_unregister('phar');
+// }
+
+// DOCUMENT_ROOT fix for IIS Webserver
+if ((!isset($_SERVER['DOCUMENT_ROOT'])) OR (empty($_SERVER['DOCUMENT_ROOT']))) {
+	if(isset($_SERVER['SCRIPT_FILENAME'])) {
+		$_SERVER['DOCUMENT_ROOT'] = str_replace( '\\', '/', substr($_SERVER['SCRIPT_FILENAME'], 0, 0-strlen($_SERVER['PHP_SELF'])));
+	} elseif(isset($_SERVER['PATH_TRANSLATED'])) {
+		$_SERVER['DOCUMENT_ROOT'] = str_replace( '\\', '/', substr(str_replace('\\\\', '\\', $_SERVER['PATH_TRANSLATED']), 0, 0-strlen($_SERVER['PHP_SELF'])));
+	} else {
+		// define here your DOCUMENT_ROOT path if the previous fails (e.g. '/var/www')
+		$_SERVER['DOCUMENT_ROOT'] = '/';
+	}
+}
+$_SERVER['DOCUMENT_ROOT'] = str_replace('//', '/', $_SERVER['DOCUMENT_ROOT']);
+if (substr($_SERVER['DOCUMENT_ROOT'], -1) != '/') {
+	$_SERVER['DOCUMENT_ROOT'] .= '/';
+}
+
+// Load main configuration file only if the K_TCPDF_EXTERNAL_CONFIG constant is set to false.
+if (!defined('K_TCPDF_EXTERNAL_CONFIG') OR !K_TCPDF_EXTERNAL_CONFIG) {
+	// define a list of default config files in order of priority
+	$tcpdf_config_files = array(dirname(__FILE__).'/config/tcpdf_config.php', '/etc/php-tcpdf/tcpdf_config.php', '/etc/tcpdf/tcpdf_config.php', '/etc/tcpdf_config.php');
+	foreach ($tcpdf_config_files as $tcpdf_config) {
+		if (@file_exists($tcpdf_config) AND is_readable($tcpdf_config)) {
+			require_once($tcpdf_config);
+			break;
+		}
+	}
+}
+
+if (!defined('K_PATH_MAIN')) {
+	define ('K_PATH_MAIN', dirname(__FILE__).'/');
+}
+
+if (!defined('K_PATH_FONTS')) {
+	define ('K_PATH_FONTS', K_PATH_MAIN.'fonts/');
+}
+
+if (!defined('K_PATH_URL')) {
+	$k_path_url = K_PATH_MAIN; // default value for console mode
+	if (isset($_SERVER['HTTP_HOST']) AND (!empty($_SERVER['HTTP_HOST']))) {
+		if(isset($_SERVER['HTTPS']) AND (!empty($_SERVER['HTTPS'])) AND (strtolower($_SERVER['HTTPS']) != 'off')) {
+			$k_path_url = 'https://';
+		} else {
+			$k_path_url = 'http://';
+		}
+		$k_path_url .= $_SERVER['HTTP_HOST'];
+		$k_path_url .= str_replace( '\\', '/', substr(K_PATH_MAIN, (strlen($_SERVER['DOCUMENT_ROOT']) - 1)));
+	}
+	define ('K_PATH_URL', $k_path_url);
+}
+
+if (!defined('K_PATH_IMAGES')) {
+	$tcpdf_images_dirs = array(K_PATH_MAIN.'examples/images/', K_PATH_MAIN.'images/', '/usr/share/doc/php-tcpdf/examples/images/', '/usr/share/doc/tcpdf/examples/images/', '/usr/share/doc/php/tcpdf/examples/images/', '/var/www/tcpdf/images/', '/var/www/html/tcpdf/images/', '/usr/local/apache2/htdocs/tcpdf/images/', K_PATH_MAIN);
+	foreach ($tcpdf_images_dirs as $tcpdf_images_path) {
+		if (@file_exists($tcpdf_images_path)) {
+			define ('K_PATH_IMAGES', $tcpdf_images_path);
+			break;
+		}
+	}
+}
+
+if (!defined('PDF_HEADER_LOGO')) {
+	$tcpdf_header_logo = '';
+	if (@file_exists(K_PATH_IMAGES.'tcpdf_logo.jpg')) {
+		$tcpdf_header_logo = 'tcpdf_logo.jpg';
+	}
+	define ('PDF_HEADER_LOGO', $tcpdf_header_logo);
+}
+
+if (!defined('PDF_HEADER_LOGO_WIDTH')) {
+	if (!empty($tcpdf_header_logo)) {
+		define ('PDF_HEADER_LOGO_WIDTH', 30);
+	} else {
+		define ('PDF_HEADER_LOGO_WIDTH', 0);
+	}
+}
+
+if (!defined('K_PATH_CACHE')) {
+	$K_PATH_CACHE = ini_get('upload_tmp_dir') ? ini_get('upload_tmp_dir') : sys_get_temp_dir();
+	if (substr($K_PATH_CACHE, -1) != '/') {
+		$K_PATH_CACHE .= '/';
+	}
+	define ('K_PATH_CACHE', $K_PATH_CACHE);
+}
+
+if (!defined('K_BLANK_IMAGE')) {
+	define ('K_BLANK_IMAGE', '_blank.png');
+}
+
+if (!defined('PDF_PAGE_FORMAT')) {
+	define ('PDF_PAGE_FORMAT', 'A4');
+}
+
+if (!defined('PDF_PAGE_ORIENTATION')) {
+	define ('PDF_PAGE_ORIENTATION', 'P');
+}
+
+if (!defined('PDF_CREATOR')) {
+	define ('PDF_CREATOR', 'TCPDF');
+}
+
+if (!defined('PDF_AUTHOR')) {
+	define ('PDF_AUTHOR', 'TCPDF');
+}
+
+if (!defined('PDF_HEADER_TITLE')) {
+	define ('PDF_HEADER_TITLE', 'TCPDF Example');
+}
+
+if (!defined('PDF_HEADER_STRING')) {
+	define ('PDF_HEADER_STRING', "by2026 Nicola Asuni - Tecnick.com\nwww.tcpdf.org");
+}
+
+if (!defined('PDF_UNIT')) {
+	define ('PDF_UNIT', 'mm');
+}
+
+if (!defined('PDF_MARGIN_HEADER')) {
+	define ('PDF_MARGIN_HEADER', 5);
+}
+
+if (!defined('PDF_MARGIN_FOOTER')) {
+	define ('PDF_MARGIN_FOOTER', 10);
+}
+
+if (!defined('PDF_MARGIN_TOP')) {
+	define ('PDF_MARGIN_TOP', 27);
+}
+
+if (!defined('PDF_MARGIN_BOTTOM')) {
+	define ('PDF_MARGIN_BOTTOM', 25);
+}
+
+if (!defined('PDF_MARGIN_LEFT')) {
+	define ('PDF_MARGIN_LEFT', 15);
+}
+
+if (!defined('PDF_MARGIN_RIGHT')) {
+	define ('PDF_MARGIN_RIGHT', 15);
+}
+
+if (!defined('PDF_FONT_NAME_MAIN')) {
+	define ('PDF_FONT_NAME_MAIN', 'helvetica');
+}
+
+if (!defined('PDF_FONT_SIZE_MAIN')) {
+	define ('PDF_FONT_SIZE_MAIN', 10);
+}
+
+if (!defined('PDF_FONT_NAME_DATA')) {
+	define ('PDF_FONT_NAME_DATA', 'helvetica');
+}
+
+if (!defined('PDF_FONT_SIZE_DATA')) {
+	define ('PDF_FONT_SIZE_DATA', 8);
+}
+
+if (!defined('PDF_FONT_MONOSPACED')) {
+	define ('PDF_FONT_MONOSPACED', 'courier');
+}
+
+if (!defined('PDF_IMAGE_SCALE_RATIO')) {
+	define ('PDF_IMAGE_SCALE_RATIO', 96/72);
+}
+
+if (!defined('HEAD_MAGNIFICATION')) {
+	define('HEAD_MAGNIFICATION', 1.1);
+}
+
+if (!defined('K_CELL_HEIGHT_RATIO')) {
+	define('K_CELL_HEIGHT_RATIO', 1.25);
+}
+
+if (!defined('K_TITLE_MAGNIFICATION')) {
+	define('K_TITLE_MAGNIFICATION', 1.3);
+}
+
+if (!defined('K_SMALL_RATIO')) {
+	define('K_SMALL_RATIO', 2/3);
+}
+
+if (!defined('K_THAI_TOPCHARS')) {
+	define('K_THAI_TOPCHARS', true);
+}
+
+if (!defined('K_TCPDF_CALLS_IN_HTML')) {
+	define('K_TCPDF_CALLS_IN_HTML', false);
+}
+
+if (!defined('K_ALLOWED_TCPDF_TAGS')) {
+	define('K_ALLOWED_TCPDF_TAGS', '');
+}
+
+if (!defined('K_TCPDF_THROW_EXCEPTION_ERROR')) {
+	define('K_TCPDF_THROW_EXCEPTION_ERROR', false);
+}
+
+if (!defined('K_TIMEZONE')) {
+	define('K_TIMEZONE', @date_default_timezone_get());
+}
+
+// Custom cURL options for curl_setopt_array.
+if (!defined('K_CURLOPTS')) {
+	define('K_CURLOPTS', array());
+}
+
+//============================================================+
+// END OF FILE
+//============================================================+

Verbrauchskostenreport/libs/vendor/tecnickcom/tcpdf/tcpdf_barcodes_2d.php

@@ -0,0 +1,351 @@
+<?php
+//============================================================+
+// File name   : tcpdf_barcodes_2d.php
+// Version     : 1.0.015
+// Begin       : 2009-04-07
+// Last Update : 2014-05-20
+// Author      : Nicola Asuni - Tecnick.com LTD - www.tecnick.com - info@tecnick.com
+// License     : GNU-LGPL v3 (https://www.gnu.org/copyleft/lesser.html)
+// -------------------------------------------------------------------
+// Copyright (C) 2009-2026 Nicola Asuni - Tecnick.com LTD
+//
+// This file is part of TCPDF software library.
+//
+// TCPDF is free software: you can redistribute it and/or modify it
+// under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// TCPDF is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with TCPDF.  If not, see <https://www.gnu.org/licenses/>.
+//
+// See LICENSE.TXT file for more information.
+// -------------------------------------------------------------------
+//
+// Description : PHP class to creates array representations for
+//               2D barcodes to be used with TCPDF.
+//
+//============================================================+
+
+/**
+ * @file
+ * PHP class to creates array representations for 2D barcodes to be used with TCPDF.
+ * @package com.tecnick.tcpdf
+ * @author Nicola Asuni
+ * @version 1.0.015
+ */
+
+/**
+ * @class TCPDF2DBarcode
+ * PHP class to creates array representations for 2D barcodes to be used with TCPDF (http://www.tcpdf.org).
+ * @package com.tecnick.tcpdf
+ * @version 1.0.015
+ * @author Nicola Asuni
+ */
+class TCPDF2DBarcode {
+
+	/**
+	 * Array representation of barcode.
+	 * @protected
+	 */
+	protected $barcode_array = array();
+
+	/**
+	 * This is the class constructor.
+	 * Return an array representations for 2D barcodes:<ul>
+	 * <li>$arrcode['code'] code to be printed on text label</li>
+	 * <li>$arrcode['num_rows'] required number of rows</li>
+	 * <li>$arrcode['num_cols'] required number of columns</li>
+	 * <li>$arrcode['bcode'][$r][$c] value of the cell is $r row and $c column (0 = transparent, 1 = black)</li></ul>
+	 * @param string $code code to print
+ 	 * @param string $type type of barcode: <ul><li>DATAMATRIX : Datamatrix (ISO/IEC 16022)</li><li>PDF417 : PDF417 (ISO/IEC 15438:2006)</li><li>PDF417,a,e,t,s,f,o0,o1,o2,o3,o4,o5,o6 : PDF417 with parameters: a = aspect ratio (width/height); e = error correction level (0-8); t = total number of macro segments; s = macro segment index (0-99998); f = file ID; o0 = File Name (text); o1 = Segment Count (numeric); o2 = Time Stamp (numeric); o3 = Sender (text); o4 = Addressee (text); o5 = File Size (numeric); o6 = Checksum (numeric). NOTES: Parameters t, s and f are required for a Macro Control Block, all other parameters are optional. To use a comma character ',' on text options, replace it with the character 255: "\xff".</li><li>QRCODE : QRcode Low error correction</li><li>QRCODE,L : QRcode Low error correction</li><li>QRCODE,M : QRcode Medium error correction</li><li>QRCODE,Q : QRcode Better error correction</li><li>QRCODE,H : QR-CODE Best error correction</li><li>RAW: raw mode - comma-separad list of array rows</li><li>RAW2: raw mode - array rows are surrounded by square parenthesis.</li><li>TEST : Test matrix</li></ul>
+	 */
+	public function __construct($code, $type) {
+		$this->setBarcode($code, $type);
+	}
+
+	/**
+	 * Return an array representations of barcode.
+ 	 * @return array
+	 */
+	public function getBarcodeArray() {
+		return $this->barcode_array;
+	}
+
+	/**
+	 * Send barcode as SVG image object to the standard output.
+	 * @param int $w Width of a single rectangle element in user units.
+	 * @param int $h Height of a single rectangle element in user units.
+	 * @param string $color Foreground color (in SVG format) for bar elements (background is transparent).
+ 	 * @public
+	 */
+	public function getBarcodeSVG($w=3, $h=3, $color='black') {
+		// send headers
+		$code = $this->getBarcodeSVGcode($w, $h, $color);
+		header('Content-Type: application/svg+xml');
+		header('Cache-Control: public, must-revalidate, max-age=0'); // HTTP/1.1
+		header('Pragma: public');
+		header('Expires: Sat, 26 Jul 1997 05:00:00 GMT'); // Date in the past
+		header('Last-Modified: '.gmdate('D, d M Y H:i:s').' GMT');
+		header('Content-Disposition: inline; filename="'.md5($code).'.svg";');
+		//header('Content-Length: '.strlen($code));
+		echo $code;
+	}
+
+	/**
+	 * Return a SVG string representation of barcode.
+	 * @param int $w Width of a single rectangle element in user units.
+	 * @param int $h Height of a single rectangle element in user units.
+	 * @param string $color Foreground color (in SVG format) for bar elements (background is transparent).
+ 	 * @return string SVG code.
+ 	 * @public
+	 */
+	public function getBarcodeSVGcode($w=3, $h=3, $color='black') {
+		// replace table for special characters
+		$repstr = array("\0" => '', '&' => '&amp;', '<' => '&lt;', '>' => '&gt;');
+		$svg = '<'.'?'.'xml version="1.0" standalone="no"'.'?'.'>'."\n";
+		$svg .= '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">'."\n";
+		$svg .= '<svg width="'.round(($this->barcode_array['num_cols'] * $w), 3).'" height="'.round(($this->barcode_array['num_rows'] * $h), 3).'" version="1.1" xmlns="http://www.w3.org/2000/svg">'."\n";
+		$svg .= "\t".'<desc>'.strtr($this->barcode_array['code'], $repstr).'</desc>'."\n";
+		$svg .= "\t".'<g id="elements" fill="'.$color.'" stroke="none">'."\n";
+		// print barcode elements
+		$y = 0;
+		// for each row
+		for ($r = 0; $r < $this->barcode_array['num_rows']; ++$r) {
+			$x = 0;
+			// for each column
+			for ($c = 0; $c < $this->barcode_array['num_cols']; ++$c) {
+				if ($this->barcode_array['bcode'][$r][$c] == 1) {
+					// draw a single barcode cell
+					$svg .= "\t\t".'<rect x="'.$x.'" y="'.$y.'" width="'.$w.'" height="'.$h.'" />'."\n";
+				}
+				$x += $w;
+			}
+			$y += $h;
+		}
+		$svg .= "\t".'</g>'."\n";
+		$svg .= '</svg>'."\n";
+		return $svg;
+	}
+
+	/**
+	 * Return an HTML representation of barcode.
+	 * @param int $w Width of a single rectangle element in pixels.
+	 * @param int $h Height of a single rectangle element in pixels.
+	 * @param string $color Foreground color for bar elements (background is transparent).
+ 	 * @return string HTML code.
+ 	 * @public
+	 */
+	public function getBarcodeHTML($w=10, $h=10, $color='black') {
+		$html = '<div style="font-size:0;position:relative;width:'.($w * $this->barcode_array['num_cols']).'px;height:'.($h * $this->barcode_array['num_rows']).'px;">'."\n";
+		// print barcode elements
+		$y = 0;
+		// for each row
+		for ($r = 0; $r < $this->barcode_array['num_rows']; ++$r) {
+			$x = 0;
+			// for each column
+			for ($c = 0; $c < $this->barcode_array['num_cols']; ++$c) {
+				if ($this->barcode_array['bcode'][$r][$c] == 1) {
+					// draw a single barcode cell
+					$html .= '<div style="background-color:'.$color.';width:'.$w.'px;height:'.$h.'px;position:absolute;left:'.$x.'px;top:'.$y.'px;">&nbsp;</div>'."\n";
+				}
+				$x += $w;
+			}
+			$y += $h;
+		}
+		$html .= '</div>'."\n";
+		return $html;
+	}
+
+	/**
+	 * Send a PNG image representation of barcode (requires GD or Imagick library).
+	 * @param int $w Width of a single rectangle element in pixels.
+	 * @param int $h Height of a single rectangle element in pixels.
+	 * @param array $color RGB (0-255) foreground color for bar elements (background is transparent).
+ 	 * @public
+	 */
+	public function getBarcodePNG($w=3, $h=3, $color=array(0,0,0)) {
+		$data = $this->getBarcodePngData($w, $h, $color);
+		// send headers
+		header('Content-Type: image/png');
+		header('Cache-Control: public, must-revalidate, max-age=0'); // HTTP/1.1
+		header('Pragma: public');
+		header('Expires: Sat, 26 Jul 1997 05:00:00 GMT'); // Date in the past
+		header('Last-Modified: '.gmdate('D, d M Y H:i:s').' GMT');
+		//header('Content-Length: '.strlen($data));
+		echo $data;
+
+	}
+
+	/**
+	 * Return a PNG image representation of barcode (requires GD or Imagick library).
+	 * @param int $w Width of a single rectangle element in pixels.
+	 * @param int $h Height of a single rectangle element in pixels.
+	 * @param array $color RGB (0-255) foreground color for bar elements (background is transparent).
+ 	 * @return string|Imagick|false image or false in case of error.
+ 	 * @public
+	 */
+	public function getBarcodePngData($w=3, $h=3, $color=array(0,0,0)) {
+		// calculate image size
+		$width = ($this->barcode_array['num_cols'] * $w);
+		$height = ($this->barcode_array['num_rows'] * $h);
+		if (function_exists('imagecreate')) {
+			// GD library
+			$imagick = false;
+			$png = imagecreate($width, $height);
+			$bgcol = imagecolorallocate($png, 255, 255, 255);
+			imagecolortransparent($png, $bgcol);
+			$fgcol = imagecolorallocate($png, $color[0], $color[1], $color[2]);
+		} elseif (extension_loaded('imagick')) {
+			$imagick = true;
+			$bgcol = new imagickpixel('rgb(255,255,255');
+			$fgcol = new imagickpixel('rgb('.$color[0].','.$color[1].','.$color[2].')');
+			$png = new Imagick();
+			$png->newImage($width, $height, 'none', 'png');
+			$bar = new imagickdraw();
+			$bar->setfillcolor($fgcol);
+		} else {
+			return false;
+		}
+		// print barcode elements
+		$y = 0;
+		// for each row
+		for ($r = 0; $r < $this->barcode_array['num_rows']; ++$r) {
+			$x = 0;
+			// for each column
+			for ($c = 0; $c < $this->barcode_array['num_cols']; ++$c) {
+				if ($this->barcode_array['bcode'][$r][$c] == 1) {
+					// draw a single barcode cell
+					if ($imagick) {
+						$bar->rectangle($x, $y, ($x + $w - 1), ($y + $h - 1));
+					} else {
+						imagefilledrectangle($png, $x, $y, ($x + $w - 1), ($y + $h - 1), $fgcol);
+					}
+				}
+				$x += $w;
+			}
+			$y += $h;
+		}
+		if ($imagick) {
+			$png->drawimage($bar);
+			return $png;
+		} else {
+			ob_start();
+			imagepng($png);
+			$imagedata = ob_get_clean();
+			if (PHP_VERSION_ID < 80000) {
+				imagedestroy($png);
+			}
+			return $imagedata;
+		}
+	}
+
+	/**
+	 * Set the barcode.
+	 * @param string $code code to print
+ 	 * @param string $type type of barcode: <ul><li>DATAMATRIX : Datamatrix (ISO/IEC 16022)</li><li>PDF417 : PDF417 (ISO/IEC 15438:2006)</li><li>PDF417,a,e,t,s,f,o0,o1,o2,o3,o4,o5,o6 : PDF417 with parameters: a = aspect ratio (width/height); e = error correction level (0-8); t = total number of macro segments; s = macro segment index (0-99998); f = file ID; o0 = File Name (text); o1 = Segment Count (numeric); o2 = Time Stamp (numeric); o3 = Sender (text); o4 = Addressee (text); o5 = File Size (numeric); o6 = Checksum (numeric). NOTES: Parameters t, s and f are required for a Macro Control Block, all other parameters are optional. To use a comma character ',' on text options, replace it with the character 255: "\xff".</li><li>QRCODE : QRcode Low error correction</li><li>QRCODE,L : QRcode Low error correction</li><li>QRCODE,M : QRcode Medium error correction</li><li>QRCODE,Q : QRcode Better error correction</li><li>QRCODE,H : QR-CODE Best error correction</li><li>RAW: raw mode - comma-separad list of array rows</li><li>RAW2: raw mode - array rows are surrounded by square parenthesis.</li><li>TEST : Test matrix</li></ul>
+ 	 * @return void
+	 */
+	public function setBarcode($code, $type) {
+		$mode = explode(',', $type);
+		$qrtype = strtoupper($mode[0]);
+		switch ($qrtype) {
+			case 'DATAMATRIX': { // DATAMATRIX (ISO/IEC 16022)
+				require_once(dirname(__FILE__).'/include/barcodes/datamatrix.php');
+				$qrcode = new Datamatrix($code);
+				$this->barcode_array = $qrcode->getBarcodeArray();
+				$this->barcode_array['code'] = $code;
+				break;
+			}
+			case 'PDF417': { // PDF417 (ISO/IEC 15438:2006)
+				require_once(dirname(__FILE__).'/include/barcodes/pdf417.php');
+				if (!isset($mode[1]) OR ($mode[1] === '')) {
+					$aspectratio = 2; // default aspect ratio (width / height)
+				} else {
+					$aspectratio = floatval($mode[1]);
+				}
+				if (!isset($mode[2]) OR ($mode[2] === '')) {
+					$ecl = -1; // default error correction level (auto)
+				} else {
+					$ecl = intval($mode[2]);
+				}
+				// set macro block
+				$macro = array();
+				if (isset($mode[3]) AND ($mode[3] !== '') AND isset($mode[4]) AND ($mode[4] !== '') AND isset($mode[5]) AND ($mode[5] !== '')) {
+					$macro['segment_total'] = intval($mode[3]);
+					$macro['segment_index'] = intval($mode[4]);
+					$macro['file_id'] = strtr($mode[5], "\xff", ',');
+					for ($i = 0; $i < 7; ++$i) {
+						$o = $i + 6;
+						if (isset($mode[$o]) AND ($mode[$o] !== '')) {
+							// add option
+							$macro['option_'.$i] = strtr($mode[$o], "\xff", ',');
+						}
+					}
+				}
+				$qrcode = new PDF417($code, $ecl, $aspectratio, $macro);
+				$this->barcode_array = $qrcode->getBarcodeArray();
+				$this->barcode_array['code'] = $code;
+				break;
+			}
+			case 'QRCODE': { // QR-CODE
+				require_once(dirname(__FILE__).'/include/barcodes/qrcode.php');
+				if (!isset($mode[1]) OR (!in_array($mode[1],array('L','M','Q','H')))) {
+					$mode[1] = 'L'; // Ddefault: Low error correction
+				}
+				$qrcode = new QRcode($code, strtoupper($mode[1]));
+				$this->barcode_array = $qrcode->getBarcodeArray();
+				$this->barcode_array['code'] = $code;
+				break;
+			}
+			case 'RAW':
+			case 'RAW2': { // RAW MODE
+				// remove spaces
+				$code = preg_replace('/[\s]*/si', '', $code);
+				if (strlen($code) < 3) {
+					break;
+				}
+				if ($qrtype == 'RAW') {
+					// comma-separated rows
+					$rows = explode(',', $code);
+				} else { // RAW2
+					// rows enclosed in square parentheses
+					$code = substr($code, 1, -1);
+					$rows = explode('][', $code);
+				}
+				$this->barcode_array['num_rows'] = count($rows);
+				$this->barcode_array['num_cols'] = strlen($rows[0]);
+				$this->barcode_array['bcode'] = array();
+				foreach ($rows as $r) {
+					$this->barcode_array['bcode'][] = str_split($r, 1);
+				}
+				$this->barcode_array['code'] = $code;
+				break;
+			}
+			case 'TEST': { // TEST MODE
+				$this->barcode_array['num_rows'] = 5;
+				$this->barcode_array['num_cols'] = 15;
+				$this->barcode_array['bcode'] = array(
+					array(1,1,1,0,1,1,1,0,1,1,1,0,1,1,1),
+					array(0,1,0,0,1,0,0,0,1,0,0,0,0,1,0),
+					array(0,1,0,0,1,1,0,0,1,1,1,0,0,1,0),
+					array(0,1,0,0,1,0,0,0,0,0,1,0,0,1,0),
+					array(0,1,0,0,1,1,1,0,1,1,1,0,0,1,0));
+				$this->barcode_array['code'] = $code;
+				break;
+			}
+			default: {
+				$this->barcode_array = array();
+			}
+		}
+	}
+} // end of class
+
+//============================================================+
+// END OF FILE
+//============================================================+

Verbrauchskostenreport/module.json

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

VirtuelleBatterie/README.md

@@ -0,0 +1,10 @@
+# Virtuelle Batterie
+
+Installierbares IP-Symcon-Modul fuer Enelix Utils ab Version 8.0.
+
+Es aggregiert mehrere physische Batterien, reserviert einen priorisierten
+SDL-Anteil und stellt dem vorhandenen Enelix-EMS-Batteriemodul generische
+Proxyregister fuer den Eigenverbrauch bereit.
+
+Konfiguration, Verdrahtung und Sicherheitsverhalten stehen in
+[`docs/module/Virtuelle-Batterie/README.md`](../docs/module/Virtuelle-Batterie/README.md).

VirtuelleBatterie/form.json

@@ -0,0 +1,167 @@
+{
+  "elements": [
+    {
+      "type": "Label",
+      "caption": "Fasst mehrere physische Batterien zu einer virtuellen Batterie zusammen. SDL hat bei der Leistungsverteilung Vorrang."
+    },
+    {
+      "type": "List",
+      "name": "Batterieliste",
+      "caption": "Physische Batterien",
+      "rowCount": 5,
+      "add": true,
+      "delete": true,
+      "columns": [
+        {
+          "caption": "Name",
+          "name": "Name",
+          "width": "150px",
+          "add": "",
+          "edit": {"type": "ValidationTextBox"}
+        },
+        {
+          "caption": "Kapazitaet",
+          "name": "Kapazitaet_kWh",
+          "width": "110px",
+          "suffix": " kWh",
+          "add": 0,
+          "edit": {"type": "NumberSpinner", "minimum": 0, "digits": 2}
+        },
+        {
+          "caption": "Max. Laden",
+          "name": "MaxLaden_W",
+          "width": "110px",
+          "suffix": " W",
+          "add": 0,
+          "edit": {"type": "NumberSpinner", "minimum": 0, "digits": 0}
+        },
+        {
+          "caption": "Max. Entladen",
+          "name": "MaxEntladen_W",
+          "width": "120px",
+          "suffix": " W",
+          "add": 0,
+          "edit": {"type": "NumberSpinner", "minimum": 0, "digits": 0}
+        },
+        {
+          "caption": "Ladezustand",
+          "name": "LadezustandVariableID",
+          "width": "130px",
+          "add": 0,
+          "edit": {"type": "SelectVariable"}
+        },
+        {
+          "caption": "Istleistung",
+          "name": "IstleistungVariableID",
+          "width": "130px",
+          "add": 0,
+          "edit": {"type": "SelectVariable"}
+        },
+        {
+          "caption": "Sollleistung",
+          "name": "SollleistungVariableID",
+          "width": "140px",
+          "add": 0,
+          "edit": {"type": "SelectVariable"}
+        }
+      ],
+      "values": []
+    },
+    {
+      "type": "ExpansionPanel",
+      "caption": "SDL-Reserve",
+      "items": [
+        {
+          "type": "NumberSpinner",
+          "name": "SDLReserveLaden",
+          "caption": "Reservierte SDL-Ladeleistung",
+          "suffix": " W",
+          "minimum": 0
+        },
+        {
+          "type": "NumberSpinner",
+          "name": "SDLReserveEntladen",
+          "caption": "Reservierte SDL-Entladeleistung",
+          "suffix": " W",
+          "minimum": 0
+        },
+        {
+          "type": "NumberSpinner",
+          "name": "Reservezeit",
+          "caption": "SDL-Reservezeit",
+          "suffix": " h",
+          "minimum": 0,
+          "maximum": 24,
+          "digits": 2
+        }
+      ]
+    },
+    {
+      "type": "ExpansionPanel",
+      "caption": "Regelung und Sicherheit",
+      "items": [
+        {
+          "type": "NumberSpinner",
+          "name": "Aktualisierungsintervall",
+          "caption": "Aktualisierungsintervall",
+          "suffix": " s",
+          "minimum": 1
+        },
+        {
+          "type": "NumberSpinner",
+          "name": "MesswertMaxAlter",
+          "caption": "Maximales Messwertalter",
+          "suffix": " s",
+          "minimum": 1
+        },
+        {
+          "type": "NumberSpinner",
+          "name": "VorgabeTimeout",
+          "caption": "Timeout fuer EV- und SDL-Vorgaben",
+          "suffix": " s",
+          "minimum": 1
+        },
+        {
+          "type": "NumberSpinner",
+          "name": "EigenverbrauchStart",
+          "caption": "Startwert Eigenverbrauchskonto",
+          "suffix": " %",
+          "minimum": 0,
+          "maximum": 100,
+          "digits": 1
+        },
+        {
+          "type": "NumberSpinner",
+          "name": "SDLStart",
+          "caption": "Startwert SDL-Konto",
+          "suffix": " %",
+          "minimum": 0,
+          "maximum": 100,
+          "digits": 1
+        },
+        {
+          "type": "CheckBox",
+          "name": "DiagnoseAnzeigen",
+          "caption": "Diagnosevariablen anzeigen"
+        },
+        {
+          "type": "CheckBox",
+          "name": "LoggingEin",
+          "caption": "Debug-Logging aktivieren"
+        }
+      ]
+    }
+  ],
+  "actions": [
+    {
+      "type": "Button",
+      "caption": "Virtuelle Konten auf Startwerte zuruecksetzen",
+      "onClick": "IPS_RequestAction($id, 'KontenReset', true);"
+    },
+    {
+      "type": "Button",
+      "caption": "Jetzt aktualisieren",
+      "onClick": "IPS_RequestAction($id, 'Aktualisieren', 0);"
+    }
+  ]
+}

VirtuelleBatterie/libs/VirtuelleBatterieRegler.php

@@ -0,0 +1,220 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Belevo\EnelixUtils;
+
+use InvalidArgumentException;
+
+final class VirtuelleBatterieRegler
+{
+    /**
+     * @param list<array{
+     *   Index:int,
+     *   Name:string,
+     *   Kapazitaet_kWh:float,
+     *   MaxLaden_W:float,
+     *   MaxEntladen_W:float,
+     *   Ladezustand_Prozent:float,
+     *   Istleistung_W:float
+     * }> $batterien
+     * @return array<string, float>
+     */
+    public static function aggregiere(
+        array $batterien,
+        float $sdlReserveLadenW,
+        float $sdlReserveEntladenW,
+        float $reservezeitH
+    ): array {
+        if ($sdlReserveLadenW < 0.0
+            || $sdlReserveEntladenW < 0.0
+            || $reservezeitH < 0.0
+        ) {
+            throw new InvalidArgumentException(
+                'SDL-Reserven und Reservezeit duerfen nicht negativ sein.'
+            );
+        }
+
+        $kapazitaet = 0.0;
+        $energie = 0.0;
+        $maxLaden = 0.0;
+        $maxEntladen = 0.0;
+        $istleistung = 0.0;
+
+        foreach ($batterien as $batterie) {
+            $kapazitaetKWh = (float) $batterie['Kapazitaet_kWh'];
+            $ladezustand = (float) $batterie['Ladezustand_Prozent'];
+            $ladenW = (float) $batterie['MaxLaden_W'];
+            $entladenW = (float) $batterie['MaxEntladen_W'];
+
+            if ($kapazitaetKWh <= 0.0 || $ladenW < 0.0 || $entladenW < 0.0) {
+                throw new InvalidArgumentException(
+                    'Kapazitaet muss positiv und Leistungsgrenzen duerfen nicht negativ sein.'
+                );
+            }
+            if ($ladezustand < 0.0 || $ladezustand > 100.0) {
+                throw new InvalidArgumentException(
+                    'Ladezustand muss zwischen 0 und 100 Prozent liegen.'
+                );
+            }
+
+            $kapazitaet += $kapazitaetKWh;
+            $energie += $kapazitaetKWh * $ladezustand / 100.0;
+            $maxLaden += $ladenW;
+            $maxEntladen += $entladenW;
+            $istleistung += (float) $batterie['Istleistung_W'];
+        }
+
+        if ($kapazitaet <= 0.0) {
+            throw new InvalidArgumentException(
+                'Mindestens eine verfuegbare Batterie ist erforderlich.'
+            );
+        }
+
+        $sdlLadenW = min($sdlReserveLadenW, $maxLaden);
+        $sdlEntladenW = min($sdlReserveEntladenW, $maxEntladen);
+        $untereReserve = $sdlEntladenW * $reservezeitH / 1000.0;
+        $obereReserve = $sdlLadenW * $reservezeitH / 1000.0;
+
+        if ($untereReserve + $obereReserve > $kapazitaet) {
+            throw new InvalidArgumentException(
+                'Die SDL-Energiereserven sind groesser als die Gesamtkapazitaet.'
+            );
+        }
+
+        return [
+            'Kapazitaet_kWh' => $kapazitaet,
+            'Energie_kWh' => $energie,
+            'Ladezustand_Prozent' => $energie / $kapazitaet * 100.0,
+            'Istleistung_W' => $istleistung,
+            'MaxLaden_W' => $maxLaden,
+            'MaxEntladen_W' => $maxEntladen,
+            'SDLKapazitaet_kWh' => $untereReserve + $obereReserve,
+            'EigenverbrauchKapazitaet_kWh' =>
+                $kapazitaet - $untereReserve - $obereReserve,
+            'SDLMaxLaden_W' => $sdlLadenW,
+            'SDLMaxEntladen_W' => $sdlEntladenW,
+            'EigenverbrauchMaxLaden_W' => max(0.0, $maxLaden - $sdlLadenW),
+            'EigenverbrauchMaxEntladen_W' => max(0.0, $maxEntladen - $sdlEntladenW),
+            'UntereSDLReserve_kWh' => $untereReserve,
+            'ObereSDLReserve_kWh' => $obereReserve,
+        ];
+    }
+
+    /**
+     * SDL wird zuerst begrenzt. Eigenverbrauch erhaelt die verbleibende
+     * physische Leistung derselben Richtung.
+     *
+     * @param array<string, float> $aggregat
+     * @return array{Eigenverbrauch_W:float, SDL_W:float, Gesamt_W:float}
+     */
+    public static function kombiniere(
+        float $eigenverbrauchW,
+        float $sdlW,
+        array $aggregat
+    ): array {
+        $sdl = self::begrenze(
+            $sdlW,
+            (float) $aggregat['SDLMaxLaden_W'],
+            (float) $aggregat['SDLMaxEntladen_W']
+        );
+        $ev = self::begrenze(
+            $eigenverbrauchW,
+            (float) $aggregat['EigenverbrauchMaxLaden_W'],
+            (float) $aggregat['EigenverbrauchMaxEntladen_W']
+        );
+
+        if ($sdl > 0.0 && $ev > 0.0) {
+            $ev = min($ev, max(0.0, (float) $aggregat['MaxLaden_W'] - $sdl));
+        } elseif ($sdl < 0.0 && $ev < 0.0) {
+            $ev = max($ev, -max(
+                0.0,
+                (float) $aggregat['MaxEntladen_W'] - abs($sdl)
+            ));
+        }
+
+        $gesamt = self::begrenze(
+            $sdl + $ev,
+            (float) $aggregat['MaxLaden_W'],
+            (float) $aggregat['MaxEntladen_W']
+        );
+
+        return [
+            'Eigenverbrauch_W' => $ev,
+            'SDL_W' => $sdl,
+            'Gesamt_W' => $gesamt,
+        ];
+    }
+
+    /**
+     * @param list<array{
+     *   Index:int,
+     *   Name:string,
+     *   Kapazitaet_kWh:float,
+     *   MaxLaden_W:float,
+     *   MaxEntladen_W:float,
+     *   Ladezustand_Prozent:float,
+     *   Istleistung_W:float
+     * }> $batterien
+     * @return array<int, float>
+     */
+    public static function verteile(float $gesamtW, array $batterien): array
+    {
+        $ergebnis = [];
+        foreach ($batterien as $batterie) {
+            $ergebnis[(int) $batterie['Index']] = 0.0;
+        }
+        if (abs($gesamtW) < 0.5) {
+            return $ergebnis;
+        }
+
+        $laden = $gesamtW > 0.0;
+        usort(
+            $batterien,
+            static function (array $a, array $b) use ($laden): int {
+                $vergleich = (float) $a['Ladezustand_Prozent']
+                    <=> (float) $b['Ladezustand_Prozent'];
+                return $laden ? $vergleich : -$vergleich;
+            }
+        );
+
+        $rest = abs($gesamtW);
+        foreach ($batterien as $batterie) {
+            if ($rest < 0.5) {
+                break;
+            }
+            $grenze = $laden
+                ? (float) $batterie['MaxLaden_W']
+                : (float) $batterie['MaxEntladen_W'];
+            $anteil = min($rest, max(0.0, $grenze));
+            $ergebnis[(int) $batterie['Index']] = $laden ? $anteil : -$anteil;
+            $rest -= $anteil;
+        }
+
+        return $ergebnis;
+    }
+
+    /**
+     * Die SDL-Leistung wird bilanziell zuerst bedient. Die Differenz zur
+     * gemessenen Gesamtleistung wird dem Eigenverbrauch zugeordnet.
+     *
+     * @return array{Eigenverbrauch_W:float, SDL_W:float}
+     */
+    public static function ordneIstleistungZu(
+        float $gesamtIstW,
+        float $sdlAuftragW
+    ): array {
+        return [
+            'Eigenverbrauch_W' => $gesamtIstW - $sdlAuftragW,
+            'SDL_W' => $sdlAuftragW,
+        ];
+    }
+
+    private static function begrenze(
+        float $leistungW,
+        float $maxLadenW,
+        float $maxEntladenW
+    ): float {
+        return min($maxLadenW, max(-$maxEntladenW, $leistungW));
+    }
+}

VirtuelleBatterie/module.json

@@ -0,0 +1,12 @@
+{
+  "id": "{5B2A199B-2226-411F-B83B-FC1CBA58496B}",
+  "name": "Virtuelle Batterie",
+  "type": 3,
+  "vendor": "Enelix",
+  "aliases": [],
+  "parentRequirements": [],
+  "childRequirements": [],
+  "implemented": [],
+  "prefix": "ENLVB",
+  "url": ""
+}

VirtuelleBatterie/module.php

@@ -0,0 +1,781 @@
+<?php
+
+declare(strict_types=1);
+
+require_once __DIR__ . '/libs/VirtuelleBatterieRegler.php';
+
+use Belevo\EnelixUtils\VirtuelleBatterieRegler;
+
+class VirtuelleBatterie extends IPSModule
+{
+    private const STATUS_AKTIV = 102;
+    private const STATUS_INAKTIV = 104;
+    private const STATUS_KONFIGURATION_UNGUELTIG = 201;
+    private const STATUS_MESSWERTE_UNGUELTIG = 202;
+    private const STATUS_AUSGABE_FEHLER = 203;
+    private const VM_UPDATE = 10603;
+
+    public function Create(): void
+    {
+        parent::Create();
+
+        $this->RegisterPropertyString('Batterieliste', '[]');
+        $this->RegisterPropertyInteger('SDLReserveLaden', 0);
+        $this->RegisterPropertyInteger('SDLReserveEntladen', 0);
+        $this->RegisterPropertyFloat('Reservezeit', 0.5);
+        $this->RegisterPropertyInteger('Aktualisierungsintervall', 2);
+        $this->RegisterPropertyInteger('MesswertMaxAlter', 30);
+        $this->RegisterPropertyInteger('VorgabeTimeout', 30);
+        $this->RegisterPropertyFloat('EigenverbrauchStart', 50.0);
+        $this->RegisterPropertyFloat('SDLStart', 50.0);
+        $this->RegisterPropertyBoolean('DiagnoseAnzeigen', false);
+        $this->RegisterPropertyBoolean('LoggingEin', false);
+
+        $this->RegisterVariableBoolean('Aktiv', 'Aktiv', '~Switch', 10);
+        $this->EnableAction('Aktiv');
+
+        $this->RegisterVariableInteger(
+            'EVManagement',
+            'EV Managementregister',
+            '',
+            20
+        );
+        $this->EnableAction('EVManagement');
+        $this->RegisterVariableInteger('EVModus', 'EV Modusregister', '', 30);
+        $this->EnableAction('EVModus');
+        $this->RegisterVariableFloat(
+            'EVLadeleistung',
+            'EV Laderegister',
+            '',
+            40
+        );
+        $this->EnableAction('EVLadeleistung');
+        $this->RegisterVariableFloat(
+            'EVEntladeleistung',
+            'EV Entladeregister',
+            '',
+            50
+        );
+        $this->EnableAction('EVEntladeleistung');
+
+        $this->RegisterVariableFloat(
+            'SDLSollleistung',
+            'SDL Sollleistung',
+            '',
+            60
+        );
+        $this->EnableAction('SDLSollleistung');
+
+        $this->RegisterVariableFloat(
+            'GesamtLadezustand',
+            'Gesamtladezustand',
+            '',
+            100
+        );
+        $this->RegisterVariableFloat(
+            'GesamtIstleistung',
+            'Gesamte Istleistung',
+            '',
+            110
+        );
+        $this->RegisterVariableFloat(
+            'GesamtMaxLaden',
+            'Gesamte maximale Ladeleistung',
+            '',
+            120
+        );
+        $this->RegisterVariableFloat(
+            'GesamtMaxEntladen',
+            'Gesamte maximale Entladeleistung',
+            '',
+            130
+        );
+
+        $this->RegisterVariableFloat(
+            'EigenverbrauchLadezustand',
+            'Eigenverbrauch Ladezustand',
+            '',
+            200
+        );
+        $this->RegisterVariableFloat(
+            'EigenverbrauchSollleistung',
+            'Eigenverbrauch Sollleistung',
+            '',
+            210
+        );
+        $this->RegisterVariableFloat(
+            'EigenverbrauchIstleistung',
+            'Eigenverbrauch Istleistung',
+            '',
+            220
+        );
+        $this->RegisterVariableFloat(
+            'EigenverbrauchMaxLaden',
+            'Eigenverbrauch maximal Laden',
+            '',
+            230
+        );
+        $this->RegisterVariableFloat(
+            'EigenverbrauchMaxEntladen',
+            'Eigenverbrauch maximal Entladen',
+            '',
+            240
+        );
+
+        $this->RegisterVariableFloat(
+            'SDLLadezustand',
+            'SDL Ladezustand',
+            '',
+            300
+        );
+        $this->RegisterVariableFloat(
+            'SDLIstleistung',
+            'SDL Istleistung',
+            '',
+            310
+        );
+        $this->RegisterVariableFloat(
+            'SDLMaxLaden',
+            'SDL maximal Laden',
+            '',
+            320
+        );
+        $this->RegisterVariableFloat(
+            'SDLMaxEntladen',
+            'SDL maximal Entladen',
+            '',
+            330
+        );
+
+        $this->RegisterVariableBoolean('Stoerung', 'Stoerung', '~Switch', 400);
+        $this->RegisterVariableString('Stoertext', 'Stoertext', '', 410);
+        $this->RegisterVariableString(
+            'Verteilstatus',
+            'Verteilstatus',
+            '',
+            420
+        );
+
+        $this->RegisterAttributeString('RegistrierteMesswerte', '[]');
+        $this->RegisterAttributeString('LetzteZielwerte', '{}');
+        $this->RegisterAttributeFloat('EigenverbrauchEnergie_kWh', 0.0);
+        $this->RegisterAttributeFloat('SDLEnergie_kWh', 0.0);
+        $this->RegisterAttributeBoolean('KontenInitialisiert', false);
+        $this->RegisterAttributeInteger('LetzteIntegration', 0);
+        $this->RegisterAttributeInteger('LetzteEVVorgabe', 0);
+        $this->RegisterAttributeInteger('LetzteSDLVorgabe', 0);
+        $this->RegisterAttributeFloat('EigenverbrauchAuftrag_W', 0.0);
+
+        $this->RegisterTimer(
+            'Aktualisierung',
+            0,
+            'IPS_RequestAction($_IPS["TARGET"], "Aktualisieren", 0);'
+        );
+        $this->RegisterTimer(
+            'EVUebernahme',
+            0,
+            'IPS_RequestAction($_IPS["TARGET"], "EVUebernehmen", 0);'
+        );
+    }
+
+    public function ApplyChanges(): void
+    {
+        parent::ApplyChanges();
+
+        $this->SetTimerInterval('Aktualisierung', 0);
+        $this->SetTimerInterval('EVUebernahme', 0);
+        $this->registriereMesswertmeldungen();
+
+        try {
+            $this->pruefeKonfiguration();
+            $this->SetTimerInterval(
+                'Aktualisierung',
+                $this->ReadPropertyInteger('Aktualisierungsintervall') * 1000
+            );
+            $this->aktualisiere();
+        } catch (Throwable $fehler) {
+            $this->sichererZustand($fehler->getMessage());
+            $this->SetStatus(self::STATUS_KONFIGURATION_UNGUELTIG);
+        }
+    }
+
+    public function MessageSink($zeitstempel, $senderID, $nachricht, $daten): void
+    {
+        if ((int) $nachricht !== self::VM_UPDATE) {
+            return;
+        }
+        $ids = json_decode(
+            $this->ReadAttributeString('RegistrierteMesswerte'),
+            true
+        );
+        if (is_array($ids) && in_array((int) $senderID, $ids, true)) {
+            $this->aktualisiere();
+        }
+    }
+
+    public function RequestAction($ident, $wert): void
+    {
+        switch ($ident) {
+            case 'Aktiv':
+                $this->SetValue('Aktiv', (bool) $wert);
+                if (!(bool) $wert) {
+                    $this->WriteAttributeFloat('EigenverbrauchAuftrag_W', 0.0);
+                    $this->SetValue('SDLSollleistung', 0.0);
+                    $this->sichererZustand('');
+                    $this->SetStatus(self::STATUS_INAKTIV);
+                    return;
+                }
+                $this->aktualisiere();
+                return;
+
+            case 'EVManagement':
+                $this->SetValue('EVManagement', (int) $wert);
+                $this->uebernehmeEVVorgabe();
+                return;
+
+            case 'EVModus':
+                $this->SetValue('EVModus', (int) $wert);
+                $this->planeEVUebernahme();
+                return;
+
+            case 'EVLadeleistung':
+                $this->SetValue(
+                    'EVLadeleistung',
+                    max(0.0, (float) $wert)
+                );
+                $this->planeEVUebernahme();
+                return;
+
+            case 'EVEntladeleistung':
+                $this->SetValue(
+                    'EVEntladeleistung',
+                    max(0.0, (float) $wert)
+                );
+                $this->planeEVUebernahme();
+                return;
+
+            case 'SDLSollleistung':
+                $this->SetValue('SDLSollleistung', (float) $wert);
+                $this->WriteAttributeInteger('LetzteSDLVorgabe', time());
+                $this->aktualisiere();
+                return;
+
+            case 'EVUebernehmen':
+                $this->SetTimerInterval('EVUebernahme', 0);
+                $this->uebernehmeEVVorgabe();
+                return;
+
+            case 'Aktualisieren':
+                $this->aktualisiere();
+                return;
+
+            case 'KontenReset':
+                $this->WriteAttributeBoolean('KontenInitialisiert', false);
+                $this->WriteAttributeInteger('LetzteIntegration', time());
+                $this->aktualisiere();
+                return;
+        }
+
+        throw new InvalidArgumentException('Unbekannte Aktion: ' . $ident);
+    }
+
+    private function planeEVUebernahme(): void
+    {
+        $this->SetTimerInterval('EVUebernahme', 50);
+    }
+
+    private function uebernehmeEVVorgabe(): void
+    {
+        $management = (int) $this->GetValue('EVManagement');
+        $modus = (int) $this->GetValue('EVModus');
+        $ziel = 0.0;
+        if ($management === 1) {
+            $ziel = $modus === 1
+                ? -(float) $this->GetValue('EVEntladeleistung')
+                : (float) $this->GetValue('EVLadeleistung');
+        }
+
+        $this->WriteAttributeFloat('EigenverbrauchAuftrag_W', $ziel);
+        $this->WriteAttributeInteger('LetzteEVVorgabe', time());
+        $this->SetValue('EigenverbrauchSollleistung', $ziel);
+        $this->aktualisiere();
+    }
+
+    private function aktualisiere(): void
+    {
+        $semaphore = 'EnelixVirtuelleBatterie_' . $this->InstanceID;
+        if (!IPS_SemaphoreEnter($semaphore, 1000)) {
+            return;
+        }
+
+        try {
+            if (!(bool) $this->GetValue('Aktiv')) {
+                $this->sichererZustand('');
+                $this->SetStatus(self::STATUS_INAKTIV);
+                return;
+            }
+
+            $this->pruefeKonfiguration();
+            [$batterien, $fehler] = $this->leseBatterien();
+            if ($batterien === []) {
+                throw new RuntimeException(
+                    'Keine Batterie besitzt aktuelle gueltige Messwerte.'
+                );
+            }
+
+            $aggregat = VirtuelleBatterieRegler::aggregiere(
+                $batterien,
+                (float) $this->ReadPropertyInteger('SDLReserveLaden'),
+                (float) $this->ReadPropertyInteger('SDLReserveEntladen'),
+                $this->ReadPropertyFloat('Reservezeit')
+            );
+            $this->initialisiereKonten($aggregat);
+
+            $jetzt = time();
+            $timeout = $this->ReadPropertyInteger('VorgabeTimeout');
+            $ev = $jetzt - $this->ReadAttributeInteger('LetzteEVVorgabe')
+                <= $timeout
+                ? $this->ReadAttributeFloat('EigenverbrauchAuftrag_W')
+                : 0.0;
+            $sdl = $jetzt - $this->ReadAttributeInteger('LetzteSDLVorgabe')
+                <= $timeout
+                ? (float) $this->GetValue('SDLSollleistung')
+                : 0.0;
+
+            $auftrag = VirtuelleBatterieRegler::kombiniere(
+                $ev,
+                $sdl,
+                $aggregat
+            );
+            $verteilung = VirtuelleBatterieRegler::verteile(
+                $auftrag['Gesamt_W'],
+                $batterien
+            );
+            $this->schreibeVerteilung($verteilung);
+            $zuordnung = VirtuelleBatterieRegler::ordneIstleistungZu(
+                $aggregat['Istleistung_W'],
+                $auftrag['SDL_W']
+            );
+            $integrationsfehler = $this->integriereKonten(
+                $zuordnung,
+                $aggregat,
+                $jetzt
+            );
+
+            $this->SetValue(
+                'GesamtLadezustand',
+                $aggregat['Ladezustand_Prozent']
+            );
+            $this->SetValue(
+                'GesamtIstleistung',
+                $aggregat['Istleistung_W']
+            );
+            $this->SetValue('GesamtMaxLaden', $aggregat['MaxLaden_W']);
+            $this->SetValue(
+                'GesamtMaxEntladen',
+                $aggregat['MaxEntladen_W']
+            );
+            $this->SetValue(
+                'EigenverbrauchSollleistung',
+                $auftrag['Eigenverbrauch_W']
+            );
+            $this->SetValue(
+                'EigenverbrauchIstleistung',
+                $zuordnung['Eigenverbrauch_W']
+            );
+            $this->SetValue(
+                'EigenverbrauchMaxLaden',
+                $aggregat['EigenverbrauchMaxLaden_W']
+            );
+            $this->SetValue(
+                'EigenverbrauchMaxEntladen',
+                $aggregat['EigenverbrauchMaxEntladen_W']
+            );
+            $this->SetValue('SDLIstleistung', $zuordnung['SDL_W']);
+            $this->SetValue('SDLMaxLaden', $aggregat['SDLMaxLaden_W']);
+            $this->SetValue(
+                'SDLMaxEntladen',
+                $aggregat['SDLMaxEntladen_W']
+            );
+            $this->aktualisiereKontenanzeigen($aggregat);
+
+            $status = [
+                'Eigenverbrauch_W' => round($auftrag['Eigenverbrauch_W'], 1),
+                'SDL_W' => round($auftrag['SDL_W'], 1),
+                'Gesamt_W' => round($auftrag['Gesamt_W'], 1),
+                'Batterien' => count($batterien),
+                'Verteilung_W' => $verteilung,
+            ];
+            $this->SetValue(
+                'Verteilstatus',
+                json_encode($status, JSON_THROW_ON_ERROR)
+            );
+
+            $fehler = array_values(array_filter(array_merge(
+                $fehler,
+                $integrationsfehler === '' ? [] : [$integrationsfehler]
+            )));
+            $this->setzeFehler(implode(' ', $fehler));
+            $this->SetStatus(
+                $fehler === []
+                    ? self::STATUS_AKTIV
+                    : self::STATUS_MESSWERTE_UNGUELTIG
+            );
+            $this->protokolliere('Verteilung', $status);
+        } catch (InvalidArgumentException $fehler) {
+            $this->sichererZustand($fehler->getMessage());
+            $this->SetStatus(self::STATUS_KONFIGURATION_UNGUELTIG);
+        } catch (Throwable $fehler) {
+            $this->sichererZustand($fehler->getMessage());
+            $this->SetStatus(self::STATUS_AUSGABE_FEHLER);
+        } finally {
+            IPS_SemaphoreLeave($semaphore);
+        }
+    }
+
+    /**
+     * @return array{0:list<array<string, int|float|string>>, 1:list<string>}
+     */
+    private function leseBatterien(): array
+    {
+        $konfiguration = $this->leseBatterieliste();
+        $batterien = [];
+        $fehler = [];
+        $maxAlter = $this->ReadPropertyInteger('MesswertMaxAlter');
+
+        foreach ($konfiguration as $index => $eintrag) {
+            $name = trim((string) ($eintrag['Name'] ?? ''));
+            if ($name === '') {
+                $name = 'Batterie ' . ($index + 1);
+            }
+            $socID = (int) ($eintrag['LadezustandVariableID'] ?? 0);
+            $leistungID = (int) ($eintrag['IstleistungVariableID'] ?? 0);
+            if (!$this->istAktuellerMesswert($socID, $maxAlter)
+                || !$this->istAktuellerMesswert($leistungID, $maxAlter)
+            ) {
+                $fehler[] = $name . ': Messwerte fehlen oder sind veraltet.';
+                continue;
+            }
+
+            $batterien[] = [
+                'Index' => $index,
+                'Name' => $name,
+                'Kapazitaet_kWh' =>
+                    (float) ($eintrag['Kapazitaet_kWh'] ?? 0.0),
+                'MaxLaden_W' => (float) ($eintrag['MaxLaden_W'] ?? 0.0),
+                'MaxEntladen_W' =>
+                    (float) ($eintrag['MaxEntladen_W'] ?? 0.0),
+                'Ladezustand_Prozent' => (float) GetValue($socID),
+                'Istleistung_W' => (float) GetValue($leistungID),
+            ];
+        }
+
+        return [$batterien, $fehler];
+    }
+
+    /** @return list<array<string, mixed>> */
+    private function leseBatterieliste(): array
+    {
+        $liste = json_decode(
+            $this->ReadPropertyString('Batterieliste'),
+            true,
+            512,
+            JSON_THROW_ON_ERROR
+        );
+        if (!is_array($liste)) {
+            throw new InvalidArgumentException(
+                'Batterieliste muss eine JSON-Liste sein.'
+            );
+        }
+
+        return array_values($liste);
+    }
+
+    private function pruefeKonfiguration(): void
+    {
+        foreach ([
+            'Aktualisierungsintervall',
+            'MesswertMaxAlter',
+            'VorgabeTimeout',
+        ] as $property) {
+            if ($this->ReadPropertyInteger($property) <= 0) {
+                throw new InvalidArgumentException(
+                    $property . ' muss groesser als 0 sein.'
+                );
+            }
+        }
+        if ($this->ReadPropertyFloat('Reservezeit') < 0.0) {
+            throw new InvalidArgumentException(
+                'Reservezeit darf nicht negativ sein.'
+            );
+        }
+
+        $liste = $this->leseBatterieliste();
+        if ($liste === []) {
+            throw new InvalidArgumentException(
+                'Mindestens eine physische Batterie ist erforderlich.'
+            );
+        }
+
+        $zielIDs = [];
+        foreach ($liste as $index => $eintrag) {
+            $name = 'Batterie ' . ($index + 1);
+            if ((float) ($eintrag['Kapazitaet_kWh'] ?? 0.0) <= 0.0) {
+                throw new InvalidArgumentException(
+                    $name . ': Kapazitaet muss groesser als 0 sein.'
+                );
+            }
+            foreach ([
+                'LadezustandVariableID',
+                'IstleistungVariableID',
+            ] as $feld) {
+                $this->pruefeNumerischeVariable(
+                    (int) ($eintrag[$feld] ?? 0),
+                    $name . ' ' . $feld,
+                    false
+                );
+            }
+            $zielID = (int) ($eintrag['SollleistungVariableID'] ?? 0);
+            $this->pruefeNumerischeVariable(
+                $zielID,
+                $name . ' SollleistungVariableID',
+                true
+            );
+            if (isset($zielIDs[$zielID])) {
+                throw new InvalidArgumentException(
+                    'Jede Batterie benoetigt eine eigene Sollleistungsvariable.'
+                );
+            }
+            $zielIDs[$zielID] = true;
+        }
+    }
+
+    private function pruefeNumerischeVariable(
+        int $id,
+        string $name,
+        bool $aktion
+    ): 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.');
+        }
+        if ($aktion
+            && (int) ($variable['VariableAction'] ?? 0) <= 0
+            && (int) ($variable['VariableCustomAction'] ?? 0) <= 0
+        ) {
+            throw new InvalidArgumentException(
+                $name . ' benoetigt eine Variablenaktion.'
+            );
+        }
+    }
+
+    private function istAktuellerMesswert(int $id, int $maxAlter): bool
+    {
+        if ($id <= 0 || !IPS_VariableExists($id)) {
+            return false;
+        }
+        $variable = IPS_GetVariable($id);
+        if (!in_array((int) $variable['VariableType'], [1, 2], true)) {
+            return false;
+        }
+        $aktualisiert = (int) ($variable['VariableUpdated'] ?? 0);
+
+        return $aktualisiert > 0 && time() - $aktualisiert <= $maxAlter;
+    }
+
+    /** @param array<int, float> $verteilung */
+    private function schreibeVerteilung(array $verteilung): void
+    {
+        $alt = json_decode(
+            $this->ReadAttributeString('LetzteZielwerte'),
+            true
+        );
+        if (!is_array($alt)) {
+            $alt = [];
+        }
+        $neu = [];
+        foreach ($this->leseBatterieliste() as $index => $eintrag) {
+            $zielID = (int) ($eintrag['SollleistungVariableID'] ?? 0);
+            $ziel = (float) ($verteilung[$index] ?? 0.0);
+            $neu[(string) $zielID] = $ziel;
+            if (!isset($alt[(string) $zielID])
+                || abs((float) $alt[(string) $zielID] - $ziel) >= 0.5
+            ) {
+                RequestAction($zielID, $ziel);
+            }
+        }
+        $this->WriteAttributeString(
+            'LetzteZielwerte',
+            json_encode($neu, JSON_THROW_ON_ERROR)
+        );
+    }
+
+    private function sichererZustand(string $fehler): void
+    {
+        try {
+            $this->schreibeVerteilung([]);
+        } catch (Throwable $ausgabeFehler) {
+            if ($fehler === '') {
+                $fehler = $ausgabeFehler->getMessage();
+            } else {
+                $fehler .= ' ' . $ausgabeFehler->getMessage();
+            }
+        }
+        $this->SetValue('EigenverbrauchSollleistung', 0.0);
+        $this->SetValue('EigenverbrauchIstleistung', 0.0);
+        $this->SetValue('SDLIstleistung', 0.0);
+        $this->setzeFehler($fehler);
+    }
+
+    /** @param array<string, float> $aggregat */
+    private function initialisiereKonten(array $aggregat): void
+    {
+        if ($this->ReadAttributeBoolean('KontenInitialisiert')) {
+            return;
+        }
+        $evProzent = min(
+            100.0,
+            max(0.0, $this->ReadPropertyFloat('EigenverbrauchStart'))
+        );
+        $sdlProzent = min(
+            100.0,
+            max(0.0, $this->ReadPropertyFloat('SDLStart'))
+        );
+        $this->WriteAttributeFloat(
+            'EigenverbrauchEnergie_kWh',
+            $aggregat['EigenverbrauchKapazitaet_kWh'] * $evProzent / 100.0
+        );
+        $this->WriteAttributeFloat(
+            'SDLEnergie_kWh',
+            $aggregat['SDLKapazitaet_kWh'] * $sdlProzent / 100.0
+        );
+        $this->WriteAttributeInteger('LetzteIntegration', time());
+        $this->WriteAttributeBoolean('KontenInitialisiert', true);
+    }
+
+    /**
+     * @param array{Eigenverbrauch_W:float, SDL_W:float} $zuordnung
+     * @param array<string, float> $aggregat
+     */
+    private function integriereKonten(
+        array $zuordnung,
+        array $aggregat,
+        int $jetzt
+    ): string {
+        $letzteZeit = $this->ReadAttributeInteger('LetzteIntegration');
+        $this->WriteAttributeInteger('LetzteIntegration', $jetzt);
+        if ($letzteZeit <= 0 || $jetzt <= $letzteZeit) {
+            return '';
+        }
+        $dauer = $jetzt - $letzteZeit;
+        $maxLuecke = max(
+            $this->ReadPropertyInteger('MesswertMaxAlter'),
+            $this->ReadPropertyInteger('Aktualisierungsintervall') * 3
+        );
+        if ($dauer > $maxLuecke) {
+            return 'Integrationsluecke erkannt; Konten wurden nicht fortgeschrieben.';
+        }
+
+        $evKapazitaet = $aggregat['EigenverbrauchKapazitaet_kWh'];
+        $sdlKapazitaet = $aggregat['SDLKapazitaet_kWh'];
+        $evEnergie = $this->ReadAttributeFloat('EigenverbrauchEnergie_kWh')
+            + $zuordnung['Eigenverbrauch_W'] * $dauer / 3600000.0;
+        $sdlEnergie = $this->ReadAttributeFloat('SDLEnergie_kWh')
+            + $zuordnung['SDL_W'] * $dauer / 3600000.0;
+        $this->WriteAttributeFloat(
+            'EigenverbrauchEnergie_kWh',
+            min($evKapazitaet, max(0.0, $evEnergie))
+        );
+        $this->WriteAttributeFloat(
+            'SDLEnergie_kWh',
+            min($sdlKapazitaet, max(0.0, $sdlEnergie))
+        );
+
+        return '';
+    }
+
+    /** @param array<string, float> $aggregat */
+    private function aktualisiereKontenanzeigen(array $aggregat): void
+    {
+        $evKapazitaet = $aggregat['EigenverbrauchKapazitaet_kWh'];
+        $sdlKapazitaet = $aggregat['SDLKapazitaet_kWh'];
+        $this->SetValue(
+            'EigenverbrauchLadezustand',
+            $evKapazitaet > 0.0
+                ? $this->ReadAttributeFloat('EigenverbrauchEnergie_kWh')
+                    / $evKapazitaet * 100.0
+                : 0.0
+        );
+        $this->SetValue(
+            'SDLLadezustand',
+            $sdlKapazitaet > 0.0
+                ? $this->ReadAttributeFloat('SDLEnergie_kWh')
+                    / $sdlKapazitaet * 100.0
+                : 0.0
+        );
+    }
+
+    private function registriereMesswertmeldungen(): void
+    {
+        $alteIDs = json_decode(
+            $this->ReadAttributeString('RegistrierteMesswerte'),
+            true
+        );
+        if (!is_array($alteIDs)) {
+            $alteIDs = [];
+        }
+        $neueIDs = [];
+        try {
+            foreach ($this->leseBatterieliste() as $eintrag) {
+                foreach ([
+                    'LadezustandVariableID',
+                    'IstleistungVariableID',
+                ] as $feld) {
+                    $id = (int) ($eintrag[$feld] ?? 0);
+                    if ($id > 0 && IPS_VariableExists($id)) {
+                        $neueIDs[] = $id;
+                    }
+                }
+            }
+        } catch (Throwable $fehler) {
+            $neueIDs = [];
+        }
+        $neueIDs = array_values(array_unique($neueIDs));
+
+        foreach ($alteIDs as $id) {
+            if (!in_array((int) $id, $neueIDs, true)) {
+                $this->UnregisterMessage((int) $id, self::VM_UPDATE);
+            }
+        }
+        foreach ($neueIDs as $id) {
+            if (!in_array($id, $alteIDs, true)) {
+                $this->RegisterMessage($id, self::VM_UPDATE);
+            }
+        }
+        $this->WriteAttributeString(
+            'RegistrierteMesswerte',
+            json_encode($neueIDs, JSON_THROW_ON_ERROR)
+        );
+    }
+
+    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);
+    }
+}

composer.json

@@ -2,6 +2,7 @@
     "name": "belevo/enelix-utils",
     "description": "Unabhaengige Zusatzmodule fuer IP-Symcon",
     "type": "library",
+    "license": "proprietary",
     "require": {
         "php": ">=8.0"
     },
@@ -16,6 +17,9 @@
     "scripts": {
         "lint": "find . -path ./vendor -prune -o -name '*.php' -print0 | xargs -0 -n1 php -l",
         "test": "phpunit",
+        "symcon:all": "bash tests/Symcon/bin/run-symcon-tests.sh all",
+        "symcon:single": "bash tests/Symcon/bin/run-symcon-tests.sh single",
+        "symcon:affected": "bash tests/Symcon/bin/run-symcon-tests.sh affected",
         "check": [
             "@lint",
             "@test"

docs/module/CC100-Hardware/README.md

@@ -0,0 +1,136 @@
+# CC100 Hardware
+
+> Status: Implementiert fuer den WAGO Compact Controller 100, Artikel 751-9301,
+> mit IP-Symcon ab Version 8.0.
+
+Das Modul bindet die komplette Onboard-I/O des CC100 direkt ueber die von WAGO
+dokumentierten Linux-Schnittstellen an:
+
+- 8 digitale Eingaenge (DI)
+- 4 digitale Ausgaenge (DO)
+- 2 analoge Eingaenge 0 bis 10 V (AI)
+- 2 analoge Ausgaenge 0 bis 10 V (AO)
+- 2 PT1000-Temperatureingaenge (PT)
+
+## Kanalauswahl
+
+Die Property 'Kanalauswahl' enthaelt alle 18 Kanaele. Pro Zeile werden
+Aktivierung, Typ, Kanalnummer, Anzeigename und Abfrageintervall festgelegt.
+Nur aktive Kanaele werden als IP-Symcon-Variablen angelegt. Wird ein Kanal
+deaktiviert, entfernt das Modul seine dynamische Variable beim naechsten
+Uebernehmen der Konfiguration.
+
+DO- und AO-Variablen sind bedienbar. DI, AI und PT sind reine Messwerte.
+AI und AO werden in Volt dargestellt, PT in Grad Celsius.
+
+## Properties
+
+| Property | Standard | Bedeutung |
+| --- | --- | --- |
+| 'Kanalauswahl' | alle Kanaele inaktiv | Sichtbare und abgefragte Kanaele |
+| 'DigitalInputPath' | WAGO-DI-Sammelpfad | 8-Bit-Eingangswert, LSB ist DI1 |
+| 'DigitalOutputPath' | '/sys/kernel/dout_drv/DOUT_DATA' | 4-Bit-Ausgangswert, LSB ist DO1 |
+| 'CalibrationPath' | '/etc/calib' | WAGO-Zweipunktkalibrierung |
+| 'AI1Path', 'AI2Path' | WAGO-IIO-Pfade | Analoge Eingangswerte |
+| 'AO1ValuePath', 'AO2ValuePath' | WAGO-IIO-Pfade | Analoge Ausgangswerte |
+| 'AO1PowerPath', 'AO2PowerPath' | WAGO-IIO-Pfade | Freigabe der analogen Ausgaenge |
+| 'PT1Path', 'PT2Path' | WAGO-IIO-Pfade | PT1000-Rohwerte |
+| 'Debug' | 'false' | Zusaetzliche Diagnose im Debug-Log |
+
+Die Hardwarepfade sind im Konfigurationsformular unter **Erweiterte
+Hardwarepfade** sichtbar. Dadurch koennen Firmwarevarianten angepasst werden,
+ohne den Modulcode zu aendern.
+
+## Aktualisierung
+
+Die CC100-Treiber stellen die Onboard-I/O als lesbare beziehungsweise
+schreibbare Systemdateien bereit. Fuer diese Dateien ist von WAGO kein
+zuverlaessiger Aenderungs-Eventkanal dokumentiert. Das Modul verwendet deshalb
+einen gemeinsamen Timer:
+
+1. Das kleinste aktive Kanalintervall bestimmt den Timer.
+2. Pro Lauf werden nur faellige Kanaele verarbeitet.
+3. DI beziehungsweise DO werden je Lauf nur einmal als Sammelwert gelesen.
+4. IP-Symcon-Werte werden nur bei einer echten Wertaenderung geschrieben.
+
+Das Intervall kann pro Kanal zwischen 100 ms und 3 600 000 ms eingestellt
+werden. Kurze Intervalle erhoehen CPU- und I/O-Last.
+
+## Kalibrierung
+
+AI, AO und PT verwenden die individuellen Zweipunktwerte aus '/etc/calib'.
+Das Modul akzeptiert die WAGO-Bezeichnungen 'AO1'/'AO2' sowie die in der
+WAGO-Beispieldatei vorkommenden Schreibweisen 'A01'/'A02'.
+
+- AI-Rohwerte werden kalibriert und von mV nach V umgerechnet.
+- AO-Sollwerte werden von V nach mV und danach invers in den Rohwert umgerechnet.
+- PT-Rohwerte werden zuerst in Ohm und anschliessend mit der
+  Callendar-Van-Dusen-Kennlinie in Grad Celsius umgerechnet.
+
+## Ausgangssicherheit
+
+'ApplyChanges()' schreibt keine Ausgaenge. Beim Start werden DO und AO nur
+eingelesen. Ein DO-Schaltbefehl liest zuerst den gesamten Ausgangswert, aendert
+genau das gewaehlte Bit und erhaelt die anderen Ausgaenge. AO akzeptiert nur
+Werte von 0 bis 10 V und schreibt zuerst die WAGO-Freigabe, danach den
+kalibrierten Rohwert.
+
+Die rekursive Schreibschleife des Enelix-1-Moduls wurde verworfen. Ein
+fehlgeschlagener Schreibzugriff blockiert IP-Symcon nicht bis zu fuenf Sekunden,
+sondern liefert sofort Status '203' und einen Stoertext.
+
+## Variablen
+
+| Ident | Typ | Zugriff |
+| --- | --- | --- |
+| 'DI1' bis 'DI8' | Boolean | Anzeige, nur wenn aktiviert |
+| 'DO1' bis 'DO4' | Boolean | Bedienbar, nur wenn aktiviert |
+| 'AI1', 'AI2' | Float / V | Anzeige, nur wenn aktiviert |
+| 'AO1', 'AO2' | Float / V | Bedienbar, nur wenn aktiviert |
+| 'PT1', 'PT2' | Float / Grad Celsius | Anzeige, nur wenn aktiviert |
+| 'Hardwarestatus' | Integer | '0' unkonfiguriert, '1' bereit, '2' Lesefehler, '3' Fehler |
+| 'Stoertext' | String | Letzter zusammengefasster Fehler |
+
+## Migration aus Enelix 1
+
+### Unveraendert uebernommen
+
+- vier DO, acht DI und zwei PT-Kanaele
+- Bitreihenfolge mit DI1 beziehungsweise DO1 als LSB
+- die vorhandenen WAGO-Systempfade als Standardwerte
+
+### Angepasst
+
+- getrennte feste Timer durch einen gruppierten, kanalspezifischen Poller ersetzt
+- DO-Aktionen lesen den Sammelwert und aendern nur das gewaehlte Bit
+- PT-Auswertung verwendet die individuelle Kalibrierung und Kennlinie
+
+### Neu implementiert
+
+- beide AI- und AO-Kanaele
+- frei waehlbare Kanaele und dynamische Variablen
+- konfigurierbare Intervalle und ueberschreibbare Hardwarepfade
+- Status-, Fehler- und Debugdiagnose
+
+### Verworfen
+
+- rekursives Schreiben mit bis zu fuenf Sekunden Blockierzeit
+- zyklisches Neuschreiben aller DO ohne neuen Schaltbefehl
+- feste PT-Rohwertbereiche und nicht kalibrierte Skalierungsfaktoren
+
+Das alte Modul kann nicht in-place aktualisiert werden. Fuer die Umstellung:
+
+1. Vorhandene Ausgangszustaende und verwendete Kanaele dokumentieren.
+2. Eine neue Instanz 'CC100 Hardware' anlegen.
+3. Benoetigte Kanaele aktivieren und Anzeigenamen vergeben.
+4. Hardwarepfade und Kalibrierdatei pruefen.
+5. Zuerst nur Eingaenge testen.
+6. Ausgaenge einzeln und unter Aufsicht freigeben.
+
+## RS-485
+
+RS-485 gehoert nicht zur Onboard-I/O-Abbildung dieses Moduls. Der CC100 stellt
+die Schnittstelle als '/dev/ttySTM1' bereit. Protokoll, Teilnehmeradressen,
+Baudrate, Paritaet, Registerbereiche und Zeitvorgaben gehoeren in eine separate
+serielle beziehungsweise Modbus-Instanz. So bleibt die I/O-Abfrage unabhaengig
+von langsamen oder fehlerhaften Busteilnehmern.

docs/module/Energiediagramm/README.md

@@ -0,0 +1,59 @@
+# Energiediagramm
+
+> Status: Implementiert fuer IP-Symcon 8.0+.
+
+Das Modul adaptiert `Energy_Pie` als unabhaengiges Enelix-Utils-Modul. Es
+wertet fortlaufende Energiezaehler aus dem IP-Symcon-Archiv aus und zeigt die
+Energiebilanz sowie Eigenverbrauchsquote und Autarkiegrad in einer individuellen
+HTML-SDK-Darstellung.
+
+## Properties
+
+| Ident | Typ | Standard / Beschreibung |
+| --- | --- | --- |
+| `ProduktionZaehlerID` | Integer | Pflichtquelle fuer produzierte Energie |
+| `EinspeisungZaehlerID` | Integer | Pflichtquelle fuer eingespeiste Energie |
+| `NetzbezugZaehlerID` | Integer | Pflichtquelle fuer bezogene Energie |
+| `VerbrauchZaehlerID` | Integer | Optionale direkte Hausverbrauchsquelle |
+| `Zaehlerfaktor` | Float | `1.0`; gemeinsamer Faktor auf kWh |
+| `Standardzeitraum` | String | `day`; Tag, Woche, Monat, Jahr oder Gesamt |
+| `Aktualisierungsintervall` | Integer | `60 s`; 10 bis 3600 Sekunden |
+| `FarbeEigenverbrauch` | String | Farbe der Eigenverbrauchsquote |
+| `FarbeAutarkie` | String | Farbe des Autarkiegrads |
+| `Debug` | Boolean | Zusaetzliche Diagnoseausgaben |
+
+## Zeitraeume und Bedienung
+
+Die Visualisierung bietet Tag, Woche, Monat, Jahr, Gesamt und Datumsbereich.
+Der freie Datumsbereich umfasst Start- und Enddatum jeweils vollstaendig. Fuer
+die Kalenderzeitraeume kann vor- und zuruecknavigiert oder direkt zum aktuellen
+Zeitraum gesprungen werden. Zukuenftige Datumswerte werden nicht akzeptiert.
+
+## Darstellung
+
+Kachel und vergroesserte Ansicht enthalten bereits beim ersten HTML-Aufbau
+einen vollstaendigen Datenstand. Ein nachgelagertes Refresh aktualisiert die
+Werte; beim erneuten Sichtbarwerden wird ebenfalls aktualisiert. Das
+Diagrammraster zeigt bei ausreichender Breite zwei Kreisdiagramme nebeneinander
+und bei geringer Breite automatisch untereinander.
+
+## Daten und Fehlerverhalten
+
+Die drei Pflichtzaehler muessen numerisch und im Archiv vorhanden sein. Der
+Hausverbrauch wird aus einer optionalen direkten Quelle gelesen oder aus
+Produktion minus Einspeisung plus Netzbezug berechnet. Bei fehlendem Archiv
+oder fehlenden Werten zeigt die Darstellung einen Diagnosehinweis statt einer
+leeren Flaeche.
+
+## Adaption aus Enelix 1
+
+| Bereich | Behandlung |
+| --- | --- |
+| Archivierte Produktions-, Einspeise- und Netzbezugszaehler | angepasst uebernommen |
+| Tag, Woche, Monat, Jahr und Gesamt | uebernommen |
+| Frei waehlbarer Datumsbereich | neu implementiert |
+| Standardzeitraum in der Konfiguration | neu implementiert |
+| Farben der Kreisdiagramme | neu konfigurierbar |
+| Vergroesserte Ansicht | mit eingebetteten Initialdaten stabilisiert |
+| Starres Zwei-Spalten-Layout | durch responsives Raster ersetzt |
+| Erzwungener Sprung auf Heute beim Laden | verworfen |

docs/module/README.md

@@ -0,0 +1,19 @@
+# Modulübersicht Enelix Utils
+
+> Status: Alle dokumentierten Enelix-Utils-Module sind implementiert.
+
+| Modul | Herkunft | EMS-Abhängigkeit |
+| --- | --- | --- |
+| [Verbrauchskostenreport](Verbrauchskostenreport/README.md) | Kosten- und Verbrauchsauswertung | Keine |
+| [Virtuelle Batterie](Virtuelle-Batterie/README.md) | Bat_EV_SDL_V4 (implementiert) | Optionaler Vertrag, keine Code-Abhängigkeit |
+| [CC100 Hardware](CC100-Hardware/README.md) | CC100_HW (implementiert) | Keine |
+| [Energiediagramm](Energiediagramm/README.md) | Energy_Pie (implementiert) | Keine |
+| [VGT-Schnittstelle](VGT-Schnittstelle/README.md) | MQTTPVSDL + MQTTBatterySDL (implementiert) | Optional konfigurierbar |
+| [Shelly Modul](Shelly-Modul/README.md) | Shelly_Parser_MQTT | Keine |
+
+Utils-Module beeinflussen sich nicht gegenseitig. Prognose, Lizenzierung und
+Störüberwachung sind keine Module dieses Repositories.
+
+`0*` bezeichnet einen noch nicht eingerichteten Anlagenwert. Jedes Modul
+besitzt `module.json`, `form.json`, `module.php`, Unit-Tests und einen
+registrierten IP-Symcon-Laufzeittest.

docs/module/Shelly-Modul/README.md

@@ -0,0 +1,114 @@
+# Shelly Modul
+
+> Status: Implementiert. Der Parser verarbeitet Shelly-NG-Komponenten der
+> Generationen 2, 3 und 4 generisch und unabhängig vom Gerätenamen.
+
+Das Modul verarbeitet Shelly-RPC- und Statusmeldungen über das native
+IP-Symcon-MQTT-Datenflussinterface. Es gehört zu Enelix Utils und besitzt
+keine Abhängigkeit zum Enelix EMS.
+
+## Ziel und Abgrenzung
+
+- freie MQTT-Client-ID und freie ein- oder mehrstufige Topic-Präfixe
+- automatische Erkennung aller gemeldeten Komponenten und skalaren Werte
+- vollständige Speicherung von Listen als JSON-String
+- konfigurierbare Erzeugung nach Datenpunktgruppen
+- weiterhin schaltbare `Switch.Set`-Ausgänge
+- keine Verwaltung von Broker- oder Shelly-Zugangsdaten
+- keine Shelly-Gen1-`shellies/...`-Topics
+
+Die generische Verarbeitung ist absichtlich nicht an eine statische Liste von
+Gerätemodellen gekoppelt. Neue Komponenten landen in der Gruppe `Other` und
+können damit ohne Moduländerung eingelesen werden.
+
+## MQTT-Datenfluss
+
+| Richtung | Topic | Inhalt |
+| --- | --- | --- |
+| Shelly nach Symcon | `<Prefix>/online` | Online-Status |
+| Shelly nach Symcon | `<Prefix>/events/rpc` | `NotifyStatus` oder `NotifyEvent` |
+| Shelly nach Symcon | `<Prefix>/status/<Komponente>` | Komponentenstatus |
+| Shelly nach Symcon | `<Prefix>/status` | Gerätestatus |
+| Shelly nach Symcon | `<Prefix>/announce` | Geräteinformationen |
+| Symcon nach Shelly | `<Prefix>/rpc` | RPC-Aufruf `Switch.Set` |
+
+Der Gerätepräfix wird vom bekannten Topic-Ende her bestimmt. Dadurch sind
+`symcon/events/rpc` und `gebaeude/etage/aktor/events/rpc` gleichermassen
+gültig. Die MQTT-Client-ID ist nicht Bestandteil der Erkennungslogik.
+
+## Properties
+
+| Ident | Standard | Beschreibung |
+| --- | --- | --- |
+| `UseDeviceTopicFilter` | `false` | Aktiviert den optionalen Präfixfilter. |
+| `DeviceTopicPrefix` | `shelly` | Filterwert; ohne aktivierten Filter wirkungslos. |
+| `CreateOnline` | `true` | Online-Status. |
+| `CreateDeviceInfo` | `true` | Modell- und Geräteinformationen. |
+| `CreateInputs` | `true` | Inputs und Eingangsereignisse. |
+| `CreateSwitches` | `true` | Schaltausgänge und Schalterstatus. |
+| `CreateCovers` | `true` | Cover- und Beschattungswerte. |
+| `CreateLights` | `true` | Licht-, Dimm- und Farbwerte. |
+| `CreatePower` | `true` | Wirk- und Scheinleistung. |
+| `CreateVoltage` | `true` | Spannungswerte. |
+| `CreateCurrent` | `true` | Stromwerte. |
+| `CreateEnergy` | `true` | Bezogene und zurückgelieferte Energie. |
+| `CreateFrequency` | `true` | Netzfrequenz. |
+| `CreatePowerFactor` | `true` | Leistungsfaktor. |
+| `CreateMeterDetails` | `true` | Weitere Zählerdaten. |
+| `CreateTemperature` | `true` | Temperaturwerte. |
+| `CreateHumidity` | `true` | Feuchtewerte. |
+| `CreateIlluminance` | `true` | Helligkeit und Beleuchtungsstärke. |
+| `CreateBattery` | `true` | Batterie- und Versorgungswerte. |
+| `CreateEnvironment` | `true` | Weitere Umweltsensoren. |
+| `CreateSystem` | `false` | System- und Netzwerkstatus. |
+| `CreateOther` | `false` | Unbekannte und zukünftige Komponenten. |
+| `Debug` | `false` | Diagnoseausgaben der Instanz. |
+
+Ein deaktivierter Bereich wird weder neu angelegt noch aktualisiert. Eine
+automatische Löschung bestehender Objekte findet nicht statt.
+
+## Typabbildung
+
+| Shelly-Wert | IP-Symcon-Typ |
+| --- | --- |
+| Boolean | Boolean |
+| bekannte IDs, Revisionen und Zeitangaben | Integer |
+| übrige numerische Messwerte | Float |
+| String | String |
+| Liste | JSON-String |
+| `null` | wird ignoriert |
+
+Verschachtelte Objekte werden rekursiv in stabile Pfade wie
+`switch:0.aenergy.total` zerlegt. Technische Idents enthalten einen kurzen
+Hash, damit Sonderzeichen, lange Pfade und ähnlich benannte Punkte nicht
+kollidieren.
+
+## Öffentliche Funktion
+
+```php
+SHELLY_SetOutput(
+    int $InstanzID,
+    string $DeviceTopic,
+    int $Output,
+    bool $Value
+): void;
+```
+
+Die Funktion validiert das Topic und den Ausgangsindex. Ein fehlendes oder
+inaktives MQTT-Gateway erzeugt eine verständliche Exception.
+
+## Kompatibilität
+
+Die bestehenden Variablen für Online, Typ, Inputs, Switch-Ausgänge und die
+Switch-Temperatur behalten ihre bisherigen Idents. Der frühere Präfixwert
+`shelly` wirkt nach dem Update nur noch, wenn der neue Filter explizit
+aktiviert wird.
+
+## Prüfung
+
+- Parser-Tests für freie und mehrstufige Topics
+- Tests für unbekannte Modelle und generische Komponenten
+- Tests für Gruppenklassifikation, Ereignisse und Typabbildung
+- PHP-Syntaxprüfung und JSON-Prüfung
+- Praxistest in IP-Symcon 8.0 mit projektseitigen Gen2-, Gen3- und
+  Gen4-Geräten bleibt nach dem Merge erforderlich

docs/module/VGT-Schnittstelle/README.md

@@ -0,0 +1,103 @@
+# VGT-Schnittstelle
+
+> Status: Implementiert fuer IP-Symcon 8.0. Fuehrt `MQTTPVSDL` und
+> `MQTTBatterySDL` zusammen.
+
+Die bestehende MQTT-Schnittstelle wurde unveraendert uebernommen. Weder
+Topic-Namen noch Request- und Response-Felder wurden erweitert oder
+umbenannt. Die Geraeteart bestimmt nur Regelverhalten und sichtbare Messwerte.
+
+## Feste MQTT-Schnittstelle
+
+| Richtung | Topic |
+| --- | --- |
+| Lesen | `feedback-request/{TopicSuffix}` |
+| Leseantwort | `feedback-response/{TopicSuffix}` |
+| Steuern | `remote-control-request/{TopicSuffix}` |
+| Steuerantwort | `remote-control-response/{TopicSuffix}` |
+
+Ein Steuerauftrag verwendet weiterhin:
+
+```json
+{
+  "power_setpoint": 3500,
+  "strategy": "activate"
+}
+```
+
+Die Steuerantwort enthaelt weiterhin ausschliesslich
+`power_setpoint` und `strategy`.
+
+Die Leseantwort enthaelt fuer PV:
+
+- `power_production`
+- `is_ready`
+- `is_running`
+
+Bei der Geraeteart Batterie kommen unveraendert hinzu:
+
+- `state_of_charge`
+- `min_soc`
+- `max_soc`
+
+MQTT wird weiterhin mit Pakettyp 3, QoS 0 und `Retain=false` ueber den
+IP-Symcon-MQTT-Parent verwendet.
+
+## Batterie und virtuelle Batterie
+
+Im Batteriemodus wird `ReqActionID` auf die Variable `SDLSollleistung`
+der virtuellen Batterie gelegt. `PowerProductionID` verweist auf
+`SDLIstleistung`, `SoCID` auf `SDLLadezustand`.
+
+Die VGT-Schnittstelle schreibt niemals physische Batterieregister. Die
+virtuelle Batterie priorisiert den SDL-Auftrag und verteilt den gemeinsamen
+Nettosollwert.
+
+Die Vorzeichenumkehr von Enelix 1 bleibt erhalten: Bei `activate` wird der
+empfangene Batterie-`power_setpoint` mit umgekehrtem Vorzeichen an die
+Zielvariable uebergeben.
+
+## Strategien
+
+| Strategie | PV | Batterie |
+| --- | --- | --- |
+| `activate` | Setpoint zwischen 0 und Maximum | invertierter Setpoint |
+| `stop` | Freigabe auf konfiguriertes Maximum | 0 W |
+| `restore` | keine aktive Fernbegrenzung | Regelung auf `TargetSoC` |
+
+Im Batteriemodus verhindern `MinSoC` und `MaxSoC` eine Vorgabe in die
+falsche Richtung an der jeweiligen Ladezustandsgrenze.
+
+## Properties
+
+| Property | Standard | Beschreibung |
+| --- | ---: | --- |
+| `Geraeteart` | PV | PV oder Batterie |
+| `TopicSuffix` | leer | Unveraenderter MQTT-Suffix |
+| `ReqActionID` | 0 | Bedienbare Zielvariable |
+| `PowerProductionID` | 0 | Aktuelle SDL-/PV-Leistung |
+| `SoCID` | 0 | Ladezustand im Batteriemodus |
+| `TargetSoC` | 50 % | Zielwert fuer `restore` |
+| `ChargePower` | 2500 W | Ladeleistung fuer `restore` |
+| `DischargePower` | 2500 W | Entladeleistung fuer `restore` |
+| `MaxPowerSetpoint` | 10000 W | Begrenzung eingehender Setpoints |
+| `LoggingEin` | false | Debug-Ausgaben |
+
+## Robustheit
+
+- Zielvariablen muessen numerisch und bedienbar sein.
+- MQTT-Antworten werden in einer FIFO-Warteschlange verarbeitet; schnelle
+  parallele Anfragen ueberschreiben sich nicht mehr.
+- Fehler der Zielaktion werden als Instanzstatus und Stoertext angezeigt.
+- Ungueltige JSON-Nutzdaten werden ohne Hardwareaktion verworfen.
+- MQTT-Payload und Topic-Vertrag bleiben dabei vollstaendig kompatibel.
+
+## Inbetriebnahme
+
+1. Vorhandenen MQTT-Parent zuordnen.
+2. Geraeteart und bisherigen `TopicSuffix` uebernehmen.
+3. Ziel- und Messvariablen konfigurieren.
+4. Im Batteriemodus die Variablen der virtuellen Batterie verwenden.
+5. `MinSoC`, `MaxSoC` und `TargetSoC` pruefen.
+6. Zuerst `feedback-request`, danach `stop`, `activate` und
+   gegebenenfalls `restore` testen.

docs/module/Verbrauchskostenreport/README.md

@@ -0,0 +1,67 @@
+# Verbrauchskostenreport
+
+> Status: Implementiert. Die fachliche Kosten- und Verbrauchsauswertung aus
+> Enelix 1 wurde ohne EMS-Abhängigkeit mit einer neutralen öffentlichen API
+> adaptiert.
+
+Der Modulpräfix lautet `VKR`. Der Report wird über die Aktion `CreateReport`
+erstellt und im Medium `ReportPDF` bereitgestellt.
+
+## Lizenzierung
+
+Die Freigabe besteht aus einer Grundlizenz und getrennten Kontingenten fuer
+Stromzaehler und Nebenzaehler. Der konfigurierte Umfang darf die vom
+Lizenzdienst bestaetigten Mengen nicht ueberschreiten.
+
+## Variablen
+
+| Technischer Ident / Anzeige | Typ / Zugriff | Beschreibung |
+| --- | --- | --- |
+| `FromDate` / Startdatum | Integer / bedienbar | Unixzeit. |
+| `ToDate` / Enddatum | Integer / bedienbar | Unixzeit; nach Startdatum. |
+| `LastResult` / Letzter Report | String / Anzeige | Ergebnisstatus. |
+| `VisuTariffOverview` / Tarife bearbeiten | String / Anzeige | Bestehende Tarifdarstellung. |
+| `VisuTariffType` / Tarifart | Integer / bedienbar | Vorhandene Tarifarten. |
+| `VisuTariffStart` / Tarif Startdatum | Integer / bedienbar | Unixzeit. |
+| `VisuTariffEnd` / Tarif Enddatum | Integer / bedienbar | Unixzeit. |
+| `VisuTariffPrice` / Tarifpreis | Float / bedienbar | Rp/Einheit gemäss bestehender Logik. |
+| `VisuTariffStatus` / Tarifstatus | String / Anzeige | Bearbeitungsergebnis. |
+| `VisuTariffPayload` / Tarifdaten | String / bedienbar | Interner JSON-Eingang. |
+| `VisuUserOverview` / Benutzer bearbeiten | String / Anzeige | Benutzerdarstellung. |
+| `VisuUserStatus` / Benutzerstatus | String / Anzeige | Bearbeitungsergebnis. |
+
+## Properties
+
+| Technischer Ident / Anzeige | Typ | Standard / Beschreibung |
+| --- | --- | --- |
+| `Lizenzcode` / Lizenzcode | String | leer; wird zur Laufzeit am Lizenzdienst geprueft. |
+| `Users` / Benutzer | String/JSON | `[]`; Benutzerstruktur. |
+| `PowerMeters` / Stromzähler | String/JSON | `[]`; Zuordnungen. |
+| `WaterMeters` / Wasserzähler | String/JSON | `[]`; Zuordnungen. |
+| `Tariffs` / Tarife | String/JSON | `[]`; Tarifstruktur und Einheiten. |
+| `LogoMediaID` / Logo | Integer | `0`; Medienobjekt. |
+| `PropertyText` / Liegenschaft | String | `Liegenschaft`. |
+| `FooterText` / Fusstext | String | Bestehender editierbarer Text. |
+| `EnableVAT` / MWST aktiv | Boolean | `false`. |
+| `VATPercentage` / MWST-Satz | Float | Code-Default `8.1`; kein automatisch gültiger Steuersatz. |
+| `CreditorName` / Zahlungsempfänger | String | leer; Pflichtfeld bei aktivem QR-Zahlteil. |
+| `CreditorStreet` / Strasse | String | leer; strukturierter Adressbestandteil. |
+| `CreditorBuildingNumber` / Hausnummer | String | leer; strukturierter Adressbestandteil. |
+| `CreditorPostalCode` / PLZ | String | leer; Pflichtfeld bei aktivem QR-Zahlteil. |
+| `CreditorTown` / Ort | String | leer; Pflichtfeld bei aktivem QR-Zahlteil. |
+| `CreditorCountry` / Land | String | ISO-2-Code; Standard `CH`. |
+| `BankIBAN` / IBAN | String | normale CH/LI-IBAN; leer deaktiviert den QR-Zahlteil. |
+
+## Migration der QR-Adressen
+
+Bestehende kombinierte Adresswerte werden nicht automatisch aufgeteilt. Vor dem
+nächsten QR-Report müssen Strasse, Hausnummer, PLZ, Ort und Land kontrolliert und
+strukturiert gespeichert werden. Bei aktiver IBAN verhindern fehlende Pflichtfelder
+die Reporterzeugung mit einer verständlichen Fehlermeldung.
+
+## Offene Punkte
+
+- Die Kosten- und Verbrauchsauswertung mit anonymisierten Referenzdaten
+  vollständig regressionsprüfen.
+- Rechtliche und kaufmännische Vorgaben wie MWST-Satz bleiben
+  Projektkonfiguration.

docs/module/Virtuelle-Batterie/README.md

@@ -0,0 +1,115 @@
+# Virtuelle Batterie
+
+> Status: Implementiert fuer IP-Symcon 8.0. Adaptiert das Grundkonzept aus
+> `Bat_EV_SDL_V4`, ohne dessen herstellerspezifische Typnamen zu uebernehmen.
+
+Das Modul fasst mehrere physische Batterien zu genau einer grossen virtuellen
+Batterie zusammen. Diese Gesamtbatterie wird in einen Eigenverbrauchs- und
+einen SDL-Anteil aufgeteilt. SDL hat bei der Leistungsverteilung Vorrang.
+
+## Verantwortlichkeiten
+
+```text
+Enelix Batterie-Modul -> EV-Proxyregister --+
+                                             +-> Virtuelle Batterie -> physische Sollwerte
+VGT-Schnittstelle ----> SDLSollleistung ----+
+```
+
+Die virtuelle Batterie ist die einzige Instanz, die die konfigurierten
+physischen Sollleistungsvariablen beschreibt. Das bestehende EMS-Batteriemodul
+regelt den Eigenverbrauchsanteil. Die VGT-Schnittstelle regelt ausschliesslich
+den SDL-Anteil.
+
+Positive Leistung bedeutet Laden, negative Leistung bedeutet Entladen.
+
+## Physische Batterien
+
+Die Property `Batterieliste` enthaelt pro Batterie:
+
+| Feld | Bedeutung |
+| --- | --- |
+| `Name` | Lesbare Kennung |
+| `Kapazitaet_kWh` | Nutzbare Kapazitaet |
+| `MaxLaden_W` | Maximale Ladeleistung |
+| `MaxEntladen_W` | Maximale Entladeleistung |
+| `LadezustandVariableID` | Aktueller Ladezustand in Prozent |
+| `IstleistungVariableID` | Gemessene Leistung in W |
+| `SollleistungVariableID` | Bedienbare Zielvariable mit Vorzeichen |
+
+Der Gesamtladezustand ist kapazitaetsgewichtet. Beim Laden werden Batterien mit
+tieferem Ladezustand zuerst verwendet, beim Entladen Batterien mit hoeherem
+Ladezustand.
+
+## Anschluss des bestehenden Batteriemoduls
+
+Eine Enelix-EMS-Instanz **Batterie** wird als herstellerunabhaengige, von Enelix
+gesteuerte Batterie eingerichtet. Ihre Messwerte und Register werden auf die
+Variablen der virtuellen Batterie gelegt:
+
+| Property im EMS-Batteriemodul | Variable der virtuellen Batterie |
+| --- | --- |
+| `MaxLadeleistungVariableID` | `EigenverbrauchMaxLaden` |
+| `MaxEntladeleistungVariableID` | `EigenverbrauchMaxEntladen` |
+| `LadezustandVariableID` | `EigenverbrauchLadezustand` |
+| `IstleistungVariableID` | `EigenverbrauchIstleistung` |
+| `ManagementRegisterVariableID` | `EVManagement` |
+| `ModusRegisterVariableID` | `EVModus` |
+| `LadeleistungRegisterVariableID` | `EVLadeleistung` |
+| `EntladeleistungRegisterVariableID` | `EVEntladeleistung` |
+
+Die Netzleistungsvariable bleibt die reale Messung des Anlagenanschlusspunktes.
+Das Batteriemodul schreibt die vier Proxyregister atomar in seiner bestehenden
+Reihenfolge. Erst das Managementregister uebernimmt den vollstaendigen
+Eigenverbrauchsauftrag.
+
+## Anschluss der VGT-Schnittstelle
+
+| Property der VGT-Schnittstelle | Variable der virtuellen Batterie |
+| --- | --- |
+| `ReqActionID` | `SDLSollleistung` |
+| `PowerProductionID` | `SDLIstleistung` |
+| `SoCID` | `SDLLadezustand` |
+
+Damit erreicht kein MQTT-Befehl direkt eine physische Batterie.
+
+## Properties
+
+| Property | Standard | Beschreibung |
+| --- | ---: | --- |
+| `Batterieliste` | `[]` | Physische Batterien und Zielvariablen |
+| `SDLReserveLaden` | 0 W | Fuer SDL reservierte Ladeleistung |
+| `SDLReserveEntladen` | 0 W | Fuer SDL reservierte Entladeleistung |
+| `Reservezeit` | 0.5 h | Energetische Reserve je Richtung |
+| `Aktualisierungsintervall` | 2 s | Zyklische Sicherheitsaktualisierung |
+| `MesswertMaxAlter` | 30 s | Zulaessiges Alter physischer Messwerte |
+| `VorgabeTimeout` | 30 s | Gueltigkeit der EV- und SDL-Vorgaben |
+| `EigenverbrauchStart` | 50 % | Startwert des EV-Kontos |
+| `SDLStart` | 50 % | Startwert des SDL-Kontos |
+| `LoggingEin` | false | Debug-Ausgaben |
+
+## Verhalten und Sicherheit
+
+- SDL wird vor dem Eigenverbrauch auf die reservierte Leistung begrenzt.
+- Gleichgerichtete Eigenverbrauchsleistung erhaelt nur die verbleibende
+  physische Leistung.
+- Gegenlaeufige Auftraege werden bilanziell getrennt und physisch als
+  Nettosollwert verteilt.
+- Fehlende oder veraltete Batterien werden aus der aktuellen Aggregation
+  entfernt und auf 0 W gesetzt.
+- Bei Deaktivierung, ungueltiger Konfiguration oder ohne gueltige Batterie
+  werden alle physischen Sollleistungsvariablen auf 0 W gesetzt.
+- Eine erkannte Integrationsluecke wird gemeldet und nicht still auf eine
+  kuerzere Dauer begrenzt.
+- Physische Zielvariablen werden ausschliesslich mit `RequestAction`
+  geschrieben.
+
+## Inbetriebnahme
+
+1. Mess- und Sollleistungsvariablen aller physischen Batterien festlegen.
+2. Batterieliste konfigurieren und Messwertalter kontrollieren.
+3. SDL-Leistungsreserve und Reservezeit eintragen.
+4. Das vorhandene EMS-Batteriemodul auf die EV-Proxyregister konfigurieren.
+5. Die VGT-Schnittstelle auf die drei SDL-Variablen konfigurieren.
+6. Zuerst mit deaktivierter virtueller Batterie alle Vorzeichen pruefen.
+7. Danach Eigenverbrauch und SDL einzeln testen.
+8. Erst abschliessend gleich- und gegenlaeufige Auftraege pruefen.

docs/testing/README.md

@@ -0,0 +1,105 @@
+# Standardisierte Tests
+
+## Ziel
+
+Dieses Repository verwendet zwei verbindliche Testebenen:
+
+1. PHPUnit prüft reine PHP-Logik und Struktur bei jedem Push.
+2. Symcon-Modultests prüfen reale Instanzen, Variablen, Actions und Zusammenspiel
+   in IP-Symcon 8.x.
+
+Alle implementierten Module müssen in `tests/Symcon/manifest.php` eingetragen
+sein und ein eigenes Skript in `tests/Symcon/modules/` besitzen. Der
+PHPUnit-Test `SymconTestContractTest` erzwingt diese Regel auch für künftig
+hinzugefügte Module.
+
+## Testvertrag
+
+Ein Modultest gibt eine aufrufbare Funktion mit dieser Signatur zurück:
+
+```php
+use Belevo\EnelixUtils\SymconTest\TestContext;
+
+return static function (TestContext $test): void {
+    $test->runCase('Beschreibung', static function (TestContext $test): void {
+        // Instanz aufbauen, Eingang simulieren und Ergebnis prüfen.
+    });
+};
+```
+
+Das Framework erzeugt für jeden Modultest eine eindeutige Kategorie unterhalb
+der Objektwurzel. Instanzen und Hilfsobjekte werden ausschließlich dort
+angelegt. Der Runner entfernt den vollständigen Baum in einem `finally`-Pfad.
+Ein fehlgeschlagener Cleanup macht den Gesamtlauf rot.
+
+Tests dürfen keine vorhandenen Objekte verändern oder anhand ihres Namens
+löschen. Globale Variablenprofile müssen nur dann registriert und entfernt
+werden, wenn sie vor dem Lauf nicht existierten.
+
+## Modi
+
+- `all`: alle registrierten Module
+- `single`: genau die als Auswahl übergebenen Module
+- `affected`: die durch geänderte Pfade ermittelten Module
+
+Verfügbare Module: `CC100Hardware`, `Energiediagramm`, `ShellyModul`,
+`VGTSchnittstelle`, `Verbrauchskostenreport` und `VirtuelleBatterie`.
+
+Die Utils-Module werden jeweils eigenständig und ohne Abhängigkeit zu Enelix EMS getestet.
+
+## Manuelle Ausführung in IP-Symcon
+
+Das Repository muss über die Modulverwaltung installiert und auf dem zu
+prüfenden Stand sein. In der Schnellausführung:
+
+```php
+require_once IPS_GetKernelDir() . 'modules/Enelix-Utils/tests/Symcon/bootstrap.php';
+
+$result = enelixUtilsRunSymconTests('all');
+echo $result['console'];
+```
+
+Ein Einzeltest wird beispielsweise mit
+`enelixUtilsRunSymconTests('single', 'ShellyModul')` gestartet.
+
+Auf dem Agent-Server kann derselbe Lauf über JSON-RPC ausgeführt werden:
+
+```bash
+tests/Symcon/bin/run-symcon-tests.sh all
+tests/Symcon/bin/run-symcon-tests.sh single ShellyModul
+```
+
+Die URL kann ausschließlich zur Laufzeit über `ENELIX_SYMCON_URL` gesetzt
+werden. Zugangsdaten gehören nicht in Repository, Skripte oder Logs.
+
+## Berichte
+
+Jeder Lauf erzeugt:
+
+- eine kurze Konsolenzusammenfassung,
+- `build/symcon-tests/report.json` für Diagnose und Archivierung,
+- `build/symcon-tests/junit.xml` für CI-Auswertung.
+
+Zusätzlich schreibt der Runner die Zusammenfassung in das IP-Symcon-Log.
+
+## CI-Regeln
+
+Bei jedem Push laufen sämtliche PHPUnit-Tests und die PHP-Syntaxprüfung. Die
+Symcon-Modultests werden bis zur Verfügbarkeit eines geschützten Runners auf
+der isolierten IP-Symcon-8.0-Instanz des Agent-Servers ausgeführt. Vor jeder
+Übernahme nach `beta` ist ein erfolgreicher Lauf im Modus `all` verbindlich.
+Der erzeugte JSON- und JUnit-Bericht gehört zum Freigabenachweis.
+
+Eine spätere CI-Automatisierung benötigt einen geschützten Runner mit dem Label
+`symcon-8`, lokalem Zugriff auf die isolierte IP-Symcon-Instanz und den exakt
+zu prüfenden Repository-Stand.
+
+## Checkliste für neue Module
+
+1. PHPUnit-Tests für die reine Logik ergänzen.
+2. `tests/Symcon/modules/<Modul>.php` hinzufügen.
+3. Modul und betroffene Pfade in `tests/Symcon/manifest.php` registrieren.
+4. Instanz, Pflichtvariablen, Actions, Normalfall und mindestens einen
+   Fehler- oder Grenzfall prüfen.
+5. Alle Hilfsobjekte über `TestContext` anlegen.
+6. `composer check`, Einzeltest und Gesamttest erfolgreich ausführen.

library.json

@@ -7,6 +7,6 @@
         "version": "8.0"
     },
     "version": "0.1",
-    "build": 0,
-    "date": 0
+    "build": 1,
+    "date": 1790662541
 }

tests/CC100HardwareModulstrukturTest.php

@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Belevo\EnelixUtils\Tests;
+
+use PHPUnit\Framework\TestCase;
+
+final class CC100HardwareModulstrukturTest extends TestCase
+{
+    public function testModuleMetadataAndFormAreComplete(): void
+    {
+        $module = json_decode(
+            file_get_contents(__DIR__ . '/../CC100Hardware/module.json'),
+            true,
+            512,
+            JSON_THROW_ON_ERROR
+        );
+        $form = json_decode(
+            file_get_contents(__DIR__ . '/../CC100Hardware/form.json'),
+            true,
+            512,
+            JSON_THROW_ON_ERROR
+        );
+
+        self::assertSame('{D62EA550-68A5-48E2-BF31-1C721AA1BD4E}', $module['id']);
+        self::assertSame('CC100 Hardware', $module['name']);
+        self::assertSame('CC100', $module['prefix']);
+        self::assertNotEmpty($form['elements']);
+        self::assertNotEmpty($form['status']);
+    }
+
+    public function testModuleProvidesEveryCc100IoGroupAndConfigurablePolling(): void
+    {
+        $module = file_get_contents(__DIR__ . '/../CC100Hardware/module.php');
+        $form = file_get_contents(__DIR__ . '/../CC100Hardware/form.json');
+
+        self::assertNotFalse($module);
+        self::assertNotFalse($form);
+        foreach ([
+            'DigitalInputPath',
+            'DigitalOutputPath',
+            'AI1Path',
+            'AI2Path',
+            'AO1ValuePath',
+            'AO2ValuePath',
+            'PT1Path',
+            'PT2Path',
+        ] as $property) {
+            self::assertStringContainsString($property, $module);
+            self::assertStringContainsString($property, $form);
+        }
+        self::assertStringContainsString('Abfrageintervall', $form);
+        self::assertStringContainsString("RegisterTimer(\n            'PollChannels'", $module);
+    }
+
+    public function testOutputsAreOnlyWrittenByExplicitActions(): void
+    {
+        $module = file_get_contents(__DIR__ . '/../CC100Hardware/module.php');
+        self::assertNotFalse($module);
+
+        $applyStart = strpos($module, 'public function ApplyChanges');
+        $actionStart = strpos($module, 'public function RequestAction');
+        self::assertNotFalse($applyStart);
+        self::assertNotFalse($actionStart);
+        self::assertStringNotContainsString(
+            'writeFile(',
+            substr($module, $applyStart, $actionStart - $applyStart)
+        );
+        self::assertStringNotContainsString('TryWriteFile', $module);
+        self::assertStringNotContainsString('usleep(', $module);
+    }
+}

tests/CC100HardwareTest.php

@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Belevo\EnelixUtils\Tests;
+
+use Belevo\EnelixUtils\CC100\CC100ChannelModel;
+use InvalidArgumentException;
+use PHPUnit\Framework\TestCase;
+
+require_once __DIR__ . '/../CC100Hardware/libs/CC100ChannelModel.php';
+
+final class CC100HardwareTest extends TestCase
+{
+    public function testDefaultSelectionContainsEveryOnboardChannelExactlyOnce(): void
+    {
+        $selection = CC100ChannelModel::defaultSelection();
+
+        self::assertCount(18, $selection);
+        self::assertCount(
+            18,
+            array_unique(array_map(
+                static fn (array $row): string => $row['Typ'] . $row['Kanal'],
+                $selection
+            ))
+        );
+        self::assertSame([], array_filter(
+            $selection,
+            static fn (array $row): bool => $row['Aktiv']
+        ));
+    }
+
+    public function testSelectionNormalizesNamesAndIntervals(): void
+    {
+        $selection = CC100ChannelModel::normalizeSelection(json_encode([
+            [
+                'Aktiv' => true,
+                'Typ' => 'di',
+                'Kanal' => 1,
+                'Anzeigename' => '',
+                'Abfrageintervall' => 250,
+            ],
+            [
+                'Aktiv' => true,
+                'Typ' => 'AO',
+                'Kanal' => 2,
+                'Anzeigename' => 'Ventil',
+                'Abfrageintervall' => 5000,
+            ],
+        ], JSON_THROW_ON_ERROR));
+
+        self::assertSame('DI1', $selection[0]['key']);
+        self::assertSame('Digitaler Eingang 1', $selection[0]['name']);
+        self::assertSame(250, $selection[0]['pollInterval']);
+        self::assertSame('AO2', $selection[1]['key']);
+        self::assertSame('Ventil', $selection[1]['name']);
+    }
+
+    public function testDuplicateChannelIsRejected(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        CC100ChannelModel::normalizeSelection(json_encode([
+            ['Typ' => 'DI', 'Kanal' => 1, 'Abfrageintervall' => 500],
+            ['Typ' => 'DI', 'Kanal' => 1, 'Abfrageintervall' => 500],
+        ], JSON_THROW_ON_ERROR));
+    }
+
+    public function testCalibrationSupportsWagoAZeroOneHeaderAndBothDirections(): void
+    {
+        $calibration = CC100ChannelModel::parseCalibration(
+            "AI1 A01\n100 0 1100 10000\n200 0 1200 10000\n"
+        );
+
+        self::assertArrayHasKey('AO1', $calibration);
+        self::assertSame(5000.0, CC100ChannelModel::rawToEngineering(600, $calibration['AI1']));
+        self::assertSame(700, CC100ChannelModel::engineeringToRaw(5000, $calibration['AO1']));
+    }
+
+    public function testPt1000CurveAndBitOperationsAreStable(): void
+    {
+        self::assertSame(0.0, CC100ChannelModel::pt1000Temperature(1000.0));
+        self::assertEqualsWithDelta(100.0, CC100ChannelModel::pt1000Temperature(1385.05), 0.1);
+
+        self::assertTrue(CC100ChannelModel::bitState(5, 1));
+        self::assertFalse(CC100ChannelModel::bitState(5, 2));
+        self::assertTrue(CC100ChannelModel::bitState(5, 3));
+        self::assertSame(7, CC100ChannelModel::withBitState(5, 2, true));
+        self::assertSame(4, CC100ChannelModel::withBitState(5, 1, false));
+    }
+}

tests/DokumentationsstrukturTest.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Belevo\EnelixUtils\Tests;
+
+use PHPUnit\Framework\TestCase;
+
+final class DokumentationsstrukturTest extends TestCase
+{
+    /** @return array<string, array{string, string}> */
+    public function modulReadmes(): array
+    {
+        return [
+            'Verbrauchskostenreport' => ['Verbrauchskostenreport', 'Status: Implementiert'],
+            'Virtuelle Batterie' => ['Virtuelle-Batterie', 'Status: Implementiert'],
+            'CC100 Hardware' => ['CC100-Hardware', 'Status: Implementiert'],
+            'Energiediagramm' => ['Energiediagramm', 'Status: Implementiert'],
+            'VGT-Schnittstelle' => ['VGT-Schnittstelle', 'Status: Implementiert'],
+            'Shelly-Modul' => ['Shelly-Modul', 'Status: Implementiert'],
+        ];
+    }
+
+    /** @dataProvider modulReadmes */
+    public function testJedesModulHatEinReadmeMitErwartetemStatus(string $modul, string $status): void
+    {
+        $pfad = __DIR__ . '/../docs/module/' . $modul . '/README.md';
+        self::assertFileExists($pfad);
+
+        $inhalt = file_get_contents($pfad);
+        self::assertNotFalse($inhalt);
+        self::assertStringContainsString($status, $inhalt);
+        self::assertStringContainsString('Properties', $inhalt);
+    }
+}

tests/EnergiediagrammModulstrukturTest.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Belevo\EnelixUtils\Tests;
+
+use PHPUnit\Framework\TestCase;
+
+final class EnergiediagrammModulstrukturTest extends TestCase
+{
+    public function testModuleMetadataAndFormExposeRequiredConfiguration(): void
+    {
+        $module = json_decode(
+            file_get_contents(__DIR__ . '/../Energiediagramm/module.json'),
+            true,
+            512,
+            JSON_THROW_ON_ERROR
+        );
+        $form = json_decode(
+            file_get_contents(__DIR__ . '/../Energiediagramm/form.json'),
+            true,
+            512,
+            JSON_THROW_ON_ERROR
+        );
+
+        self::assertSame('{F73B8F8D-5E36-4B23-B379-4632A517A1D6}', $module['id']);
+        self::assertSame('Energiediagramm', $module['name']);
+        self::assertSame('ENELIXENERGY', $module['prefix']);
+
+        $serialized = json_encode($form, JSON_THROW_ON_ERROR);
+        foreach ([
+            'ProduktionZaehlerID',
+            'EinspeisungZaehlerID',
+            'NetzbezugZaehlerID',
+            'VerbrauchZaehlerID',
+            'Standardzeitraum',
+            'FarbeEigenverbrauch',
+            'FarbeAutarkie',
+        ] as $property) {
+            self::assertStringContainsString($property, $serialized);
+        }
+        self::assertSame(2, substr_count($serialized, 'SelectColor'));
+    }
+
+    public function testHtmlStartsWithDataAndRespondsToAvailableWidth(): void
+    {
+        $html = file_get_contents(__DIR__ . '/../Energiediagramm/module.html');
+        self::assertNotFalse($html);
+        self::assertStringContainsString('__ENELIX_INITIAL_STATE__', $html);
+        self::assertStringContainsString('ResizeObserver', $html);
+        self::assertStringContainsString('grid-template-columns: minmax(0, 1fr)', $html);
+        self::assertStringContainsString('padding: 58px 14px 14px', $html);
+        self::assertStringContainsString('padding: 58px 10px 10px', $html);
+        self::assertStringContainsString('SetCustomRange', $html);
+        self::assertStringNotContainsString("addEventListener('load'", $html);
+    }
+
+    public function testModuleEmbedsInitialPayloadAndEnablesSupportedVisualization(): void
+    {
+        $module = file_get_contents(__DIR__ . '/../Energiediagramm/module.php');
+        self::assertNotFalse($module);
+        self::assertStringContainsString(
+            "str_replace('__ENELIX_INITIAL_STATE__'",
+            $module
+        );
+        self::assertStringContainsString(
+            "version_compare(IPS_GetKernelVersion(), '9.0', '>=')",
+            $module
+        );
+        self::assertStringContainsString('SetVisualizationType($visualizationType)', $module);
+        self::assertStringContainsString('Standardzeitraum', $module);
+        self::assertStringContainsString('CustomStart', $module);
+        self::assertStringContainsString('CustomEnd', $module);
+    }
+}

tests/EnergiediagrammTest.php

@@ -0,0 +1,130 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Belevo\EnelixUtils\Tests;
+
+use Belevo\EnelixUtils\Energiediagramm\EnergyChartCalculator;
+use InvalidArgumentException;
+use PHPUnit\Framework\TestCase;
+
+require_once __DIR__ . '/../Energiediagramm/libs/EnergyChartCalculator.php';
+
+final class EnergiediagrammTest extends TestCase
+{
+    private string $timezone;
+
+    protected function setUp(): void
+    {
+        $this->timezone = date_default_timezone_get();
+        date_default_timezone_set('Europe/Zurich');
+    }
+
+    protected function tearDown(): void
+    {
+        date_default_timezone_set($this->timezone);
+    }
+
+    public function testCalendarRangesUseLocalBoundaries(): void
+    {
+        [$dayStart, $dayEnd] = EnergyChartCalculator::rangeBounds(
+            'day',
+            '2026-09-27',
+            '2026-09-01',
+            '2026-09-02'
+        );
+        self::assertSame('2026-09-27 00:00', date('Y-m-d H:i', $dayStart));
+        self::assertSame('2026-09-28 00:00', date('Y-m-d H:i', $dayEnd));
+
+        [$weekStart, $weekEnd] = EnergyChartCalculator::rangeBounds(
+            'week',
+            '2026-09-27',
+            '2026-09-01',
+            '2026-09-02'
+        );
+        self::assertSame('2026-09-21', date('Y-m-d', $weekStart));
+        self::assertSame('2026-09-28', date('Y-m-d', $weekEnd));
+
+        [$monthStart, $monthEnd] = EnergyChartCalculator::rangeBounds(
+            'month',
+            '2026-09-27',
+            '2026-09-01',
+            '2026-09-02'
+        );
+        self::assertSame('2026-09-01', date('Y-m-d', $monthStart));
+        self::assertSame('2026-10-01', date('Y-m-d', $monthEnd));
+
+        [$yearStart, $yearEnd] = EnergyChartCalculator::rangeBounds(
+            'year',
+            '2026-09-27',
+            '2026-09-01',
+            '2026-09-02'
+        );
+        self::assertSame('2026-01-01', date('Y-m-d', $yearStart));
+        self::assertSame('2027-01-01', date('Y-m-d', $yearEnd));
+    }
+
+    public function testCustomRangeIncludesCompleteEndDateAcrossDstChange(): void
+    {
+        [$start, $end] = EnergyChartCalculator::rangeBounds(
+            'custom',
+            '2026-03-29',
+            '2026-03-28',
+            '2026-03-30'
+        );
+
+        self::assertSame('2026-03-28 00:00', date('Y-m-d H:i', $start));
+        self::assertSame('2026-03-31 00:00', date('Y-m-d H:i', $end));
+    }
+
+    public function testInvalidCustomRangeIsRejected(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        EnergyChartCalculator::rangeBounds(
+            'custom',
+            '2026-09-27',
+            '2026-09-28',
+            '2026-09-27'
+        );
+    }
+
+    public function testMetricsUseDerivedOrExplicitConsumption(): void
+    {
+        $derived = EnergyChartCalculator::metrics(20.0, 5.0, 3.0);
+        self::assertSame(18.0, $derived['Hausverbrauch']);
+        self::assertSame(15.0, $derived['Eigenverbrauch']);
+        self::assertSame(75.0, $derived['Eigenverbrauchsquote']);
+        self::assertEqualsWithDelta(83.3333, $derived['Autarkiegrad'], 0.001);
+
+        $explicit = EnergyChartCalculator::metrics(20.0, 5.0, 3.0, 16.0);
+        self::assertSame(16.0, $explicit['Hausverbrauch']);
+        self::assertSame(13.0, $explicit['Eigenverbrauch']);
+        self::assertSame(65.0, $explicit['Eigenverbrauchsquote']);
+        self::assertSame(81.25, $explicit['Autarkiegrad']);
+    }
+
+    public function testColorsAreValidatedAndNormalized(): void
+    {
+        self::assertSame(
+            '#2F80ED',
+            EnergyChartCalculator::normalizeColor('#2f80ed', '#000000')
+        );
+        self::assertSame(
+            '#00FF4C',
+            EnergyChartCalculator::normalizeColor('65356', '#000000')
+        );
+        self::assertSame(
+            '#000000',
+            EnergyChartCalculator::normalizeColor('0', '#FFFFFF')
+        );
+        self::assertSame(
+            '#22A06B',
+            EnergyChartCalculator::normalizeColor('16777216', '#22a06b')
+        );
+        self::assertSame(
+            '#22A06B',
+            EnergyChartCalculator::normalizeColor('-1', '#22a06b')
+        );
+    }
+}

tests/LibraryMetadataTest.php

@@ -16,7 +16,89 @@ final class LibraryMetadataTest extends TestCase
         $daten = json_decode($inhalt, true, 512, JSON_THROW_ON_ERROR);
         self::assertSame('Enelix Utils', $daten['name']);
         self::assertSame('8.0', $daten['compatibility']['version']);
+        self::assertSame('0.1', $daten['version']);
+        self::assertSame(1, $daten['build']);
+        self::assertGreaterThan(0, $daten['date']);
         self::assertMatchesRegularExpression('/^\{[0-9A-F-]{36}\}$/', $daten['id']);
     }
+
+    public function testVerbrauchskostenreportHatNeutraleMetadaten(): void
+    {
+        $inhalt = file_get_contents(__DIR__ . '/../Verbrauchskostenreport/module.json');
+        self::assertNotFalse($inhalt);
+
+        $daten = json_decode($inhalt, true, 512, JSON_THROW_ON_ERROR);
+        self::assertSame('{9DAC29C7-F381-F2A4-7CE2-F391C4123F38}', $daten['id']);
+        self::assertSame('Verbrauchskostenreport', $daten['name']);
+        self::assertSame([], $daten['aliases']);
+        self::assertSame('VKR', $daten['prefix']);
+        self::assertSame(3, $daten['type']);
+    }
+
+    public function testVerbrauchskostenreportFormularIstGueltigesJson(): void
+    {
+        $inhalt = file_get_contents(__DIR__ . '/../Verbrauchskostenreport/form.json');
+        self::assertNotFalse($inhalt);
+
+        $daten = json_decode($inhalt, true, 512, JSON_THROW_ON_ERROR);
+        self::assertArrayHasKey('elements', $daten);
+        self::assertNotEmpty($daten['elements']);
+    }
+
+    public function testRequestActionSchreibtKeineDirekteAusgabe(): void
+    {
+        $inhalt = file_get_contents(__DIR__ . '/../Verbrauchskostenreport/module.php');
+        self::assertNotFalse($inhalt);
+
+        $anfang = strpos($inhalt, 'public function RequestAction');
+        $ende = strpos($inhalt, 'public function ProcessHookData');
+        self::assertNotFalse($anfang);
+        self::assertNotFalse($ende);
+        self::assertStringNotContainsString('echo ', substr($inhalt, $anfang, $ende - $anfang));
+    }
+
+    public function testQrZahlteilVerwendetStrukturierteAdressenUndAktuellesTcpdf(): void
+    {
+        $formular = file_get_contents(__DIR__ . '/../Verbrauchskostenreport/form.json');
+        $modul = file_get_contents(__DIR__ . '/../Verbrauchskostenreport/module.php');
+        $composer = json_decode(
+            file_get_contents(__DIR__ . '/../Verbrauchskostenreport/libs/composer.json'),
+            true,
+            512,
+            JSON_THROW_ON_ERROR
+        );
+        self::assertNotFalse($formular);
+        self::assertNotFalse($modul);
+
+        foreach (['CreditorStreet', 'CreditorBuildingNumber', 'CreditorPostalCode', 'CreditorTown', 'CreditorCountry'] as $feld) {
+            self::assertStringContainsString('"name": "' . $feld . '"', $formular);
+        }
+        self::assertStringContainsString("\$iban,\n            'S'", $modul);
+        self::assertStringNotContainsString("\$iban, 'K'", $modul);
+        self::assertSame('6.11.3', $composer['require']['tecnickcom/tcpdf']);
+    }
+
+    public function testVerbrauchskostenreportVerwendetNeutraleBegriffe(): void
+    {
+        $dateien = [
+            '/../README.md',
+            '/../docs/module/README.md',
+            '/../docs/module/Verbrauchskostenreport/README.md',
+            '/../Verbrauchskostenreport/README.md',
+            '/../Verbrauchskostenreport/form.json',
+            '/../Verbrauchskostenreport/module.json',
+            '/../Verbrauchskostenreport/module.php',
+        ];
+
+        foreach ($dateien as $datei) {
+            $inhalt = file_get_contents(__DIR__ . $datei);
+            self::assertNotFalse($inhalt);
+            self::assertDoesNotMatchRegularExpression(
+                '/Abrechn|(^|[^A-Za-z])Rechnung([^A-Za-z]|$)|Invoice|Billing/i',
+                $inhalt,
+                $datei
+            );
+        }
+    }
 }
 

tests/NeueModuleStrukturTest.php

@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Belevo\EnelixUtils\Tests;
+
+use PHPUnit\Framework\TestCase;
+
+final class NeueModuleStrukturTest extends TestCase
+{
+    /** @dataProvider module */
+    public function testMetadatenUndFormulareSindGueltig(
+        string $ordner,
+        string $name,
+        string $prefix
+    ): void {
+        $metadata = json_decode(
+            (string) file_get_contents(
+                __DIR__ . '/../' . $ordner . '/module.json'
+            ),
+            true,
+            512,
+            JSON_THROW_ON_ERROR
+        );
+        self::assertSame($name, $metadata['name']);
+        self::assertSame($prefix, $metadata['prefix']);
+        self::assertSame(3, $metadata['type']);
+        self::assertMatchesRegularExpression(
+            '/^\{[0-9A-F-]{36}\}$/',
+            $metadata['id']
+        );
+
+        $formular = json_decode(
+            (string) file_get_contents(
+                __DIR__ . '/../' . $ordner . '/form.json'
+            ),
+            true,
+            512,
+            JSON_THROW_ON_ERROR
+        );
+        self::assertNotEmpty($formular['elements']);
+    }
+
+    /** @return array<string, array{string, string, string}> */
+    public function module(): array
+    {
+        return [
+            'Virtuelle Batterie' => [
+                'VirtuelleBatterie',
+                'Virtuelle Batterie',
+                'ENLVB',
+            ],
+            'VGT-Schnittstelle' => [
+                'VGTSchnittstelle',
+                'VGTSchnittstelle',
+                'ENLVGT',
+            ],
+        ];
+    }
+
+    public function testVirtuelleBatterieStelltEVProxyregisterBereit(): void
+    {
+        $modul = (string) file_get_contents(
+            __DIR__ . '/../VirtuelleBatterie/module.php'
+        );
+        foreach ([
+            "'EVManagement'",
+            "'EVModus'",
+            "'EVLadeleistung'",
+            "'EVEntladeleistung'",
+            "'SDLSollleistung'",
+            'VirtuelleBatterieRegler::kombiniere',
+        ] as $bestandteil) {
+            self::assertStringContainsString($bestandteil, $modul);
+        }
+    }
+
+    public function testPhysischeSollwerteWerdenNurPerActionGeschrieben(): void
+    {
+        $modul = (string) file_get_contents(
+            __DIR__ . '/../VirtuelleBatterie/module.php'
+        );
+        $anfang = strpos($modul, 'private function schreibeVerteilung');
+        $ende = strpos($modul, 'private function sichererZustand');
+        self::assertNotFalse($anfang);
+        self::assertNotFalse($ende);
+        $funktion = substr($modul, $anfang, $ende - $anfang);
+        self::assertStringContainsString('RequestAction(', $funktion);
+        self::assertStringNotContainsString('SetValue($zielID', $funktion);
+    }
+}