Ziel: Nullpunkteinspeisung

• als erstes soll immer die Solaranlage produzieren,
• wenn die Leisung der Solaranlage nicht ausreicht - differenz von Battery,
• wenn Solaranlage mehr Strom als nötig produziert - Einspeisung in Battery
• wenn Battery voll (100%), muss die Solaranlage limitiert werden

Tagsüber funktioniert das erstmal, abends werden wir sehen.
Vielleicht habt ihr noch Ideen, Vorschläge, Änderungen?

// =====================
// Solar / Batterie Nulleinspeisung
// =====================

const DP_PV_POWER = 'opendtu.0.total.power';
const DP_PV_LIMIT = 'opendtu.0.______.power_control.limit_nonpersistent_absolute';

const DP_GRID = 'shelly.0.shelly3em63g3#______#1.EM0.ActivePowerC';

const DP_BAT_POWER = 'hoymiles-ms.0.MSA-______.realtime.bat_p';
const DP_BAT_CTRL  = 'hoymiles-ms.0.MSA-______.power_ctrl.set';
const DP_BAT_SOC   = 'hoymiles-ms.0.MSA-______.realtime.soc';


// =====================
// Einstellungen
// =====================

// +1 = positiver Netz-Wert bedeutet Einspeisung
// -1 = negativer Netz-Wert bedeutet Einspeisung
const GRID_SIGN = -1;

// Zielbereich um 0 W
const DEADBAND = 30;

// Batterie-Limits anpassen!
const BAT_MAX_CHARGE = -800;     // max. Laden, negativer Wert
const BAT_MAX_DISCHARGE = 500;   // max. Entladen, positiver Wert

// PV-Limit
const PV_MAX_LIMIT = 800;       // maximale erlaubte PV-Leistung
const PV_MIN_LIMIT = 50;

// Regelung
const INTERVAL_MS = 5000;
const STEP_BAT = 80;             // max Änderung Batterie pro Regelzyklus
const STEP_PV_LIMIT = 100;       // max Änderung PV-Limit pro Regelzyklus


function num(id, def = 0) {
    const s = getState(id);
    const v = s ? Number(s.val) : def;
    return isNaN(v) ? def : v;
}

function clamp(v, min, max) {
    return Math.max(min, Math.min(max, v));
}

function moveStep(current, target, step) {
    if (target > current + step) return current + step;
    if (target < current - step) return current - step;
    return target;
}

function round(v) {
    return Math.round(v);
}


// =====================
// Hauptregelung
// =====================

function regulateSolarBattery() {
    const pvPower = num(DP_PV_POWER);
    const pvLimit = num(DP_PV_LIMIT, PV_MAX_LIMIT);

    const gridRaw = num(DP_GRID);
    const grid = gridRaw * GRID_SIGN;
    // grid > 0 = Einspeisung
    // grid < 0 = Netzbezug

    const batPower = num(DP_BAT_POWER);
    const batSoc = num(DP_BAT_SOC);

    let batTarget = batPower;
    let pvTargetLimit = pvLimit;

    // Batterie voll?
    const batteryFull = batSoc >= 99;

    // 1. Batterie regelt immer zuerst, solange Akku nicht voll
    if (!batteryFull) {

        // PV soll frei produzieren dürfen
        pvTargetLimit = PV_MAX_LIMIT;

        if (Math.abs(grid) > DEADBAND) {
            // Einspeisung positiv -> Batterie stärker laden
            // Netzbezug negativ -> Batterie stärker entladen
            batTarget = batPower - grid;
        }

        batTarget = clamp(batTarget, BAT_MAX_CHARGE, BAT_MAX_DISCHARGE);
        batTarget = moveStep(batPower, batTarget, STEP_BAT);

    } else {

        // Akku voll: Batterie nicht mehr laden
        if (batPower < 0) {
            batTarget = 0;
        }

        // Bei Einspeisung PV begrenzen
        if (grid > DEADBAND) {
            pvTargetLimit = pvPower - grid;
            pvTargetLimit = clamp(pvTargetLimit, PV_MIN_LIMIT, PV_MAX_LIMIT);
            pvTargetLimit = moveStep(pvLimit, pvTargetLimit, STEP_PV_LIMIT);
        }

        // Wenn keine Einspeisung mehr, PV-Limit langsam wieder erhöhen
        if (grid < -DEADBAND) {
            pvTargetLimit = moveStep(pvLimit, PV_MAX_LIMIT, STEP_PV_LIMIT);
        }
    }

    setState(DP_BAT_CTRL, round(batTarget), false);
    setState(DP_PV_LIMIT, round(pvTargetLimit), false);

    log(
        `SolarRegelung | PV=${pvPower}W | Grid=${grid}W | Bat=${batPower}W | SOC=${batSoc}% | BatSet=${round(batTarget)}W | PVLimit=${round(pvTargetLimit)}W`
    );
}


// alle 5 Sekunden regeln
setInterval(regulateSolarBattery, INTERVAL_MS);

// Start direkt ausführen
regulateSolarBattery();