diff --git a/HauptManager/README.md b/HauptManager/README.md
new file mode 100644
index 0000000..b059e3a
--- /dev/null
+++ b/HauptManager/README.md
@@ -0,0 +1,67 @@
+# Manager_1
+Beschreibung des Moduls.
+
+### Inhaltsverzeichnis
+
+1. [Funktionsumfang](#1-funktionsumfang)
+2. [Voraussetzungen](#2-voraussetzungen)
+3. [Software-Installation](#3-software-installation)
+4. [Einrichten der Instanzen in IP-Symcon](#4-einrichten-der-instanzen-in-ip-symcon)
+5. [Statusvariablen und Profile](#5-statusvariablen-und-profile)
+6. [WebFront](#6-webfront)
+7. [PHP-Befehlsreferenz](#7-php-befehlsreferenz)
+
+### 1. Funktionsumfang
+
+*
+
+### 2. Voraussetzungen
+
+- IP-Symcon ab Version 7.1
+
+### 3. Software-Installation
+
+* Über den Module Store das 'Manager_1'-Modul installieren.
+* Alternativ über das Module Control folgende URL hinzufügen
+
+### 4. Einrichten der Instanzen in IP-Symcon
+
+ Unter 'Instanz hinzufügen' kann das 'Manager_1'-Modul mithilfe des Schnellfilters gefunden werden.  
+	- Weitere Informationen zum Hinzufügen von Instanzen in der [Dokumentation der Instanzen](https://www.symcon.de/service/dokumentation/konzepte/instanzen/#Instanz_hinzufügen)
+
+__Konfigurationsseite__:
+
+Name     | Beschreibung
+-------- | ------------------
+         |
+         |
+
+### 5. Statusvariablen und Profile
+
+Die Statusvariablen/Kategorien werden automatisch angelegt. Das Löschen einzelner kann zu Fehlfunktionen führen.
+
+#### Statusvariablen
+
+Name   | Typ     | Beschreibung
+------ | ------- | ------------
+       |         |
+       |         |
+
+#### Profile
+
+Name   | Typ
+------ | -------
+       |
+       |
+
+### 6. WebFront
+
+Die Funktionalität, die das Modul im WebFront bietet.
+
+### 7. PHP-Befehlsreferenz
+
+`boolean GEF_BeispielFunktion(integer $InstanzID);`
+Erklärung der Funktion.
+
+Beispiel:
+`GEF_BeispielFunktion(12345);`
\ No newline at end of file
diff --git a/HauptManager/form.json b/HauptManager/form.json
new file mode 100644
index 0000000..e3e25f0
--- /dev/null
+++ b/HauptManager/form.json
@@ -0,0 +1,46 @@
+{
+    "elements": [
+        {
+            "type": "Label",
+            "caption": "Einstellungen Energiemanager"
+        },
+
+        {
+            "type": "NumberSpinner",
+            "name": "Peakleistung",
+            "caption": "Sollwertvorgabe für Peakshaving",
+            "suffix": "Watt"
+        },
+        {
+            "type": "NumberSpinner",
+            "name": "Ueberschussleistung",
+            "caption": "Sollwertvorgabe für Solarladen",
+            "suffix": "Watt"
+        }, 
+        {
+            "type": "SelectVariable",
+            "name": "Netzbezug",
+            "caption": "Variable mit dem zu regelnden Netzbezug"
+        }, 
+        {
+            "type": "List",
+            "name": "Verbraucher_Liste",
+            "caption": "Verbraucher, die gemanagt werden sollen.",
+            "add": true,
+            "delete": true,
+            "sortable": true,
+            "columns": [
+                {
+                    "caption": "Energieverbraucher",
+                    "name": "Verbraucher",
+                    "width": "auto",
+                    "add": 0,
+                    "edit": {
+                        "type": "SelectInstance",
+                        "filter": "Verbraucher"
+                    }
+                }
+            ]
+        }
+    ]
+}
diff --git a/HauptManager/module.json b/HauptManager/module.json
new file mode 100644
index 0000000..721695b
--- /dev/null
+++ b/HauptManager/module.json
@@ -0,0 +1,12 @@
+{
+    "id": "{F1F645F9-7F78-2843-2728-5D1708B4F835}",
+    "name": "HauptManager",
+    "type": 3,
+    "vendor": "Belevo AG",
+    "aliases": [],
+    "parentRequirements": [],
+    "childRequirements": [],
+    "implemented": [],
+    "prefix": "GEF",
+    "url": ""
+}
\ No newline at end of file
diff --git a/HauptManager/module.php b/HauptManager/module.php
new file mode 100644
index 0000000..29c1064
--- /dev/null
+++ b/HauptManager/module.php
@@ -0,0 +1,264 @@
+<?php
+
+class HauptManager extends IPSModule
+{
+    public function Create()
+    {
+        parent::Create();
+
+        // Systemvariablen registrieren
+        $this->RegisterPropertyInteger("Peakleistung", 0);
+        $this->RegisterPropertyInteger("Ueberschussleistung", 0);
+        $this->RegisterPropertyInteger("Netzbezug", 0); // Initialisierung mit 0
+        $this->RegisterPropertyString("Verbraucher_Liste", "[]");
+
+        // Timer registrieren
+        $this->RegisterTimer("Timer_DistributeEnergy",5000,"IPS_RequestAction(" .$this->InstanceID .', "DistributeEnergy", "");');
+    }
+
+    public function ApplyChanges()
+    {
+        parent::ApplyChanges();
+        //Liste aller Verbraucher einlesen
+        $Verbraucher_Liste = $this->ReadPropertyString("Verbraucher_Liste");
+    }
+
+    public function RequestAction($Ident, $Value)
+    {
+        switch ($Ident) {
+            case "DistributeEnergy":
+                $this->DistributeEnergy();
+                break;
+            case "ApplyChanges":
+                $this->ApplyChanges();
+                break;
+            default:
+                throw new Exception("Invalid Ident");
+        }
+    }
+
+    public function DistributeEnergy()
+    {
+        // Systemvariablen abrufen
+        $Netzbezug = GetValue($this->ReadPropertyInteger("Netzbezug"));
+        $Peakleistung = $this->ReadPropertyInteger("Peakleistung");
+        $Ueberschussleistung = $this->ReadPropertyInteger("Ueberschussleistung");
+
+        // Fallunterscheidung ob auf Solarladen oder Peakshaving gerregelt wird. 
+        if ($Netzbezug < ($Peakleistung - $Ueberschussleistung) / 2) {
+            $remainingPower = -1 * (-1 * $Ueberschussleistung + $Netzbezug);
+            $Is_Peak_Shaving = false;
+        } else {
+            $remainingPower = $Peakleistung - $Netzbezug;
+            $Is_Peak_Shaving = true;
+        }
+
+        // Alle Energieverbraucher auslesen und dekodieren
+        $Verbraucher_Liste = json_decode($this->ReadPropertyString("Verbraucher_Liste"), true);
+
+        if (empty($Verbraucher_Liste)) {
+            // Liste ist leer, daher nichts zu tun
+            IPS_LogMessage("Manager", "aufgerufen leere liste");
+
+            return;
+        }
+
+        // Frage alle Energieverbraucher ab, was sie für Leistungen benötigen könnten
+        foreach ($Verbraucher_Liste as $user) {
+            if (IPS_InstanceExists($user["Verbraucher"])) {
+                IPS_RequestAction($user["Verbraucher"],"GetCurrentData", $Is_Peak_Shaving);
+                IPS_LogMessage("Manager", "aufgerufen getcurrentdata");
+
+            }
+        }
+
+        $filteredVerbraucher = []; // Array das später mit allen Verbrauchsdaten der Energieverbraucher gefüllt wird
+        $allIdle = true; // Variable zur Überprüfung, ob alle Benutzer Idle = true sind
+        $totalAktuelle_Leistung = 0; // Variable zur Summierung der Aktuelle_Leistung Werte
+
+        // Fülle das Array mit allen entsprechenden Werten der Verbraucher ab
+        foreach ($Verbraucher_Liste as $user) {
+            if (!IPS_InstanceExists($user["Verbraucher"])) {
+                IPS_LogMessage("Manager", "aufgerufen komisch");
+
+                continue;
+            }
+
+            // Werte direkt von der Verbraucher-Instanz abrufen
+            $Aktuelle_Leistung = GetValue(IPS_GetObjectIDByIdent("Aktuelle_Leistung", $user["Verbraucher"]));
+            $Bezogene_Energie = GetValue(IPS_GetObjectIDByIdent("Bezogene_Energie", $user["Verbraucher"]));
+            $PV_Prio = GetValue(IPS_GetObjectIDByIdent("PV_Prio", $user["Verbraucher"]));
+            $Sperre_Prio = GetValue(IPS_GetObjectIDByIdent("Sperre_Prio", $user["Verbraucher"]));
+            $idle = GetValue(IPS_GetObjectIDByIdent("Idle", $user["Verbraucher"]));
+            $powerStepsJson = GetValue(IPS_GetObjectIDByIdent("PowerSteps", $user["Verbraucher"]));
+            $powerSteps = json_decode($powerStepsJson, true);
+
+            // Verbraucher-Daten zum gefilterten Array hinzufügen
+            $filteredVerbraucher[] = [
+                "Verbraucher" => $user["Verbraucher"],
+                "InstanceID" => $user["Verbraucher"],
+                "Aktuelle_Leistung" => $Aktuelle_Leistung,
+                "Bezogene_Energie" => $Bezogene_Energie,
+                "PV_Prio" => $PV_Prio,
+                "Sperre_Prio" => $Sperre_Prio,
+                "Idle" => $idle,
+                "PowerSteps" => $powerSteps,
+            ];
+
+            // Überprüfen, ob alle Benutzer Idle = true sind, wenn einer nicht ist, wird später verworfen...
+            if (!$idle) {
+                $allIdle = false;
+                IPS_LogMessage("Manager", "nciht idle");
+
+            }
+
+            // Addiere die aktuell bereits verwendete Leistung auf, um sie bei der verteilung zu berücksichtigen
+            $totalAktuelle_Leistung += $Aktuelle_Leistung;
+        }
+        // Berücksichtigung der bereits verteilten Leistungen (nachher kann dafür wieder bei 0 begonnen werden zu verteilen)
+        $remainingPower += $totalAktuelle_Leistung;
+
+        // Abbrechen wenn es keine gefilterten User gibt
+        if (empty($filteredVerbraucher)) {
+            return;
+        }
+
+        // Wenn nicht alle Benutzer Idle = true sind, rufe SetAktuelle_Leistung mit Aktuelle_Leistung Werten auf, (alle Verbraucher behalten die aktuelle Leistung)
+        if (!$allIdle) {
+            foreach ($filteredVerbraucher as $user) {
+                IPS_RequestAction($user["InstanceID"],"SetAktuelle_Leistung",$user["Aktuelle_Leistung"]);
+                IPS_LogMessage("Manager", "aufgerufen nicht alle idle");
+
+            }
+            return;
+        }
+
+        // Sortiere die Verbruacher nach Priorität entweder der PV_Prio oder der Peak Prio
+        usort($filteredVerbraucher, function ($a, $b) use (
+            $Is_Peak_Shaving
+        ) {
+            $primaryKey = $Is_Peak_Shaving ? "Sperre_Prio" : "PV_Prio";
+                // Wenn die Prio geleich ist, sortiere danach welcher verbraucher bisher am wenigsten Energie bekommen hat.
+            if ($a[$primaryKey] == $b[$primaryKey]) {
+                return $a["Bezogene_Energie"] <=> $b["Bezogene_Energie"];
+            }
+            return $a[$primaryKey] <=> $b[$primaryKey];
+        });
+
+        // Primärschlüssel für die Priorität basierend auf dem Parameter auswählen (für sortierung in gruppen anschliessend)
+        $priorityKey = $Is_Peak_Shaving ? "Sperre_Prio" : "PV_Prio";
+
+        // Schleife durch alle Prioritäten
+        $priorities = array_unique(
+            array_column($filteredVerbraucher, $priorityKey)
+        );
+        $groupedUsers = [];
+
+        foreach ($priorities as $priority) {
+            $groupedUsers[$priority] = array_filter(
+                $filteredVerbraucher,
+                function ($user) use ($priority, $priorityKey) {
+                    return $user[$priorityKey] == $priority;
+                }
+            );
+        }
+        // Jetzt werden die energien pro gruppe verteilt (Immer alle pro prio in einer gruppe miteinander)
+        foreach ($groupedUsers as $priority => $users) {
+            // Verbraucher mit gleicher Priorität sammeln
+            $samePriorityUsers = isset($groupedUsers[$priority])
+                ? $groupedUsers[$priority]
+                : [];
+
+            // Wenn keine Verbraucher mit gleicher Priorität vorhanden sind, überspringen
+            if (empty($samePriorityUsers)) {
+                continue;
+            }
+            $withZero = [];
+            $withoutZero = [];
+            // Verbraucher die nicht 0 Annhemen können, bekommen einfach den tiefsten wert
+            foreach ($samePriorityUsers as $entry) {
+                if (min($entry["PowerSteps"]) <= 0) {
+                    $withZero[] = $entry;
+                } else {
+                    $withoutZero[] = $entry;
+                }
+            }
+            // Verbraucher die nicht 0 annhemen können erhalten nun den minimalwert
+            if (!empty($withoutZero)) {
+                foreach ($withoutZero as $entry) {
+                    $instanceID = $entry["InstanceID"];
+                    $minPowerStep = min($entry["PowerSteps"]);
+
+                    IPS_RequestAction($instanceID,"SetAktuelle_Leistung",$minPowerStep);
+                    $remainingPower -= $entry["Aktuelle_Leistung"];
+                }
+            }
+
+            // Nun die verteilen, die 0 erhalten können. 
+            $samePriorityUsers = $withZero;
+            // Array für die verteilte Energie pro User erstellen
+            $userEnergyProv = [];
+            $userEnergyProv = array_fill_keys(array_column($samePriorityUsers, "InstanceID"), 0); // Initialisierung für jeden Benutzer auf 0 setzen
+
+            // Alle Schritte der Benutzer in einem Array sammeln
+            $allSteps = [];
+            foreach ($samePriorityUsers as $user) {
+                foreach ($user["PowerSteps"] as $step) {
+                    $allSteps[] = [
+                        "user" => $user["InstanceID"],
+                        "step" => $step,
+                    ];
+                }
+            }
+
+            // Sortiere die Schritte nach Größe
+            usort($allSteps, function ($a, $b) {
+                return $a["step"] <=> $b["step"];
+            });
+
+            // Iteriere durch alle Schritte
+            foreach ($allSteps as $entry) {
+                $user = $entry["user"];
+                $powerstep = $entry["step"];
+
+                // Überprüfe, ob noch genügend verbleibende Energie für den nächsten Schritt vorhanden ist
+                if ($remainingPower >= $powerstep - $userEnergyProv[$user]) {
+                    // Aktualisiere die verbleibende Energie und die bereitgestellte Energie für den Benutzer
+                    $remainingPower -= $powerstep - $userEnergyProv[$user];
+                    $userEnergyProv[$user] = $powerstep;
+                } 
+          
+            }
+
+            // Prüfen, dass jeder User mindestens seinen minimalwert an Leistung bekommt
+            foreach ($userEnergyProv as $userInstanceID => $leistung) {
+                $minimalleitsung = min(
+                    array_column(
+                        array_filter($allSteps, function ($entry) use (
+                             $userInstanceID
+                        ) {
+                            return $entry["user"] == $userInstanceID;
+                        }),
+                        "step"
+                    )
+                );
+
+                // Jedem user den höheren der beiden werte aus minimalwert oder vergebenem zuteilen
+                $leistung = max($leistung, $minimalleitsung); 
+
+                // Methode SetAktuelle_Leistung für jeden Verbraucher mit der entsprechenden Energie aufrufen
+                if (IPS_InstanceExists($userInstanceID)) {
+                    IPS_RequestAction($userInstanceID,"SetAktuelle_Leistung",$leistung);
+                    IPS_LogMessage("Manager", "aufgerufen setleistung normal");
+
+                }
+            }
+        }
+
+        
+
+
+        
+    }
+}
+?>
diff --git a/library.json b/library.json
index 8106bb3..6534e7d 100644
--- a/library.json
+++ b/library.json
@@ -6,7 +6,7 @@
     "compatibility": {
         "version": "7.1"
     },
-    "version": "1.088",
+    "version": "1.089",
     "build": 0,
     "date": 0
 }
\ No newline at end of file