Zendure SolarFlow2400 AC (EVCC, Tibber und PV-Forecast)

Schimi

ich bin gerade komplett im flow und habe jetzt eine Prognose auf basis der letzten 14 tage (taggenau)... wonach entschieden wird ob aus dem netz geladen wird oder nicht....

Um das aber nun zu testen, muss ich erstmal daten sammeln ;-)
also denke ich, nen update wird nicht vor Weihnachten kommen.... (aktuell Version 2.22)

Ich habe langsam die "angst" das es zuviel ist.... als Backup habe ich ja das Script vor der PV-Prognose... damit war ich eigentlich schon sehr zufrieden

lesiflo

Der solarprognose Adapter rechnet falsch wenn der aktuelle Wert größer ist als die Prognose.

Schimi

Habe mal dein issue im GutHub erstellt

Mabbi

Kleines Update, habe ja schon etwas länger nicht mehr zum eigentlichen thread-topic was gepostet:

Man sieht das Diagramm wie die Akus Laden/Entladen und im Hintergrund die SOC der beiden Akkus,
darunter die Produktivzeiten der Kimas:

Mein script läuft, heute war Schietwetter, morgens schon der akku Ebbe (weil gestern auch Schietwetter war).
Die Akkus haben dann brav geladen, den Start der ersten Klima (Heizung) unterstützt und über den Tag bis zu 3 Klimas parallel am Leben gehalten.
Abends war dann wieder Ebbe in den Akkus.

Ergo... ich brauche wohl mehr PV... lol

Habe nun eine schöne Balance mit wenig Relaisgeglacker.

Realisiert über eine:

Totzone um das Einspeiseziel rum -> weniger Steuerregelungen
AC-Mode Switch Delay das dynamisch ist. Prüfe off-Loop ob die Zendure beide geschaltet haben und das jeweilige Powersetting annehmen und gebe dann erst die eigentliche Steuerung wieder frei
eine permanente Überwachung von Soll- und Istwerten beim Laden/Entladen der Akkus -> weniger Steuereingriffe
Sollten die Akkus mehrere Zyklen von den geforderten Werten abweichen werden Sie per Brute Force in die Spur gebracht während die Dynamik pausiert und dann mit verifizierten Start-Werten anstartet. Ist noch ein alter fail-safe, wird faktich aber nicht mehr getriggert.
etc.

Integration der Ladesäule und Klimageräte ist in die Akkusteuerung abgeschlossen, dort bin ich auch sehr zufrieden mit der Funktionalitätund Stabilität/Vorhersagbarkeit des Systems.

Todo/Vison:
Das eigentliche Ziel fürs kommende WE ist vollkommen aus einem Timed Loop bei der Steuerung auszusteigen.
DIe Überwachung wird dann auch nur dynamisch nach reinem Steuerbefehl aktiviert werden.
Ziel ist es (Ich kann ja sicher nur ca. alle 15 Sekunden zu regeln(kurze Zwischentakte mit ca. 8 Sekunden sind möglich aber nicht bulletproof in der Ausführung), bei Netzbezug im optimalen Fall schon mehr als 15 Sekunden seit der letzten Regelung zu haben und dann instant und nicht erst im Timer reagieren zu können.
Und bei steigendem LADEN-Potenzial reichen mir eigentlich 50 oder 100 Watt Schritte, ich muss da nicht jedem Elektron hinterhecheln denke ich.

Wird aber tricky denke ich, das ganze System dann synchron und ohne flattern zu halten.
Prio sollte sein: Schnell regeln zu können, wenn es anfängt Geld zu Kosten (Netzbezug) und entspannt wenn man lädt.

Idz. ist das schon ein relativ üppiges Blockly geworden:

Und das hier beeinhaltet nicht die Änderungen an den Ansteuerungen der Klimas und WB sowie die ganzen Delta/Zeit Wert Berechnungen im Hintergrund.

Schimi

@Mabbi mega... 💪🏼

Rand

@schimi
So, erste Versuche mit dem Skript,

Eine kleine Verbesserung (zu faul an 10 Stellen zu ändern):

var basePath= "mqtt.0";
var baseID= "ID";

const IDs = {
    // --- HAUPTZÄHLER (Pflicht) ------------------------------------------------------
    // Muss ein Number-Wert sein. Positiv = Netzbezug (Kauf), Negativ = Einspeisung (Verkauf).
    netz: "Zaehler, 
        
    // --- ZENDURE MQTT (Pflicht) -----------------------------------------------------
    // Diese Pfade finden Sie im MQTT-Adapter unter Ihrem Zendure-Topic.
    acMode: `${basePath}.Zendure.select.${baseID}.acMode`,              // Liest Modus
    acModeSet: `${basePath}.Zendure.select.${baseID}.acMode.set`,      // Schaltet Modus
    currentInput: `${basePath}.Zendure.number.${baseID}.inputLimit`,   // Liest Ladelimit
    inputSet: `${basePath}.Zendure.number.${baseID}.inputLimit.set`,   // Setzt Ladelimit
    currentOutput: `{basePath}.Zendure.number.${baseID}.outputLimit`, // Liest Entladelimit
    outputSet: `${basePath}.Zendure.number.${baseID}.outputLimit.set`, // Setzt Entladelimit
    soc: `${basePath}.Zendure.sensor.${baseID}.electricLevel`,         // Akkustand in %

Multiple Konverter sind noch nicht unterstützt?
Hab die ja um die 2400W max Lade und Entladeleistung zu umgehen, da ist dann eine Nacheinander Lösung doof, das sollte schon parallel laufen
(Wobei ich noch schauen muss wie das läuft da ich noch keinen Elektriker da hatte unterschreibt das ich es sauber auf 2 Phasen einspeise) - mag ggf eine Fehlersituation sein die auftaucht - wobei ja pro Konverter 2400 gehen sollte und das System die Gesamt Upload Rate von 4800 nicht sieht...
Muss mal logging aktivieren damit ich nachvollziehen kann was es gerade tut - es schwankt gerade immer um den Eigenverbrauch rum, zu diesig...
Hat jemand eigentlich ein Möglichkeit gefunden die Dinger sauber auszuschalten wenn man sie nicht braucht (Akku auf minimum)? Die idle Entladung ist ja nicht gerade wenig (1% ohne Heizung), da wäre es sicherlich besser die Dinger einfach aus zu machen, aber stromlos funktionier irgendwie nur manchmal...
Hab da Shelly's Sv3 dran gepackt, die könnte ich schön einbinden/einschalten wenn Solar den Eigenverbrauch übersteigt...

Schimi

@rand

Das ist eine sehr gute Idee (habe ich angepasst)
ne, ich hab nur einen, somit wäre das testen recht schwierig

keine anung ob es so funktioniert.

Funktionsweise: Ist Batterie A leer (0%), liefert sie 0W. Der PI-Regler merkt "Oh, reicht nicht" und erhöht die globale Anforderung, wodurch Batterie B&C mehr liefern müssen. Das System regelt sich also selbst aus.

//-------------------------------------------------------------------------------------
// ### ioBroker Skript: Multi-Batteriesteuerung (Zendure) mit PI-Regler ###
//
// v4.2 - 14.12.2025
// - FEATURE: Soft-Start Rampe implementiert (Leistung steigt sanft, fällt schnell).
// - LOGIC:   Unterstützt 3 Hubs + Watchdog (ignoriert Offline-Geräte).
// - CLEAN:   Keine visuellen Datenpunkte, reiner Regelcode.
//
//-------------------------------------------------------------------------------------

// ====================================================================================
// 1. KONFIGURATION
// ====================================================================================

// --- ZENDURE GERÄTE -----------------------------------------------------------------
const ZENDURE_DEVICES = [
   { 
       id: "HOAXXXXXXXXX",          // ID Hub 1
       mqttPath: "mqtt.0.Zendure1",     // Instanz Hub 1
       active: true 
   },
   { 
       id: "HOB2XXXXXXXXXXX",          // ID Hub 2
       mqttPath: "mqtt.0.Zendure2",     // Instanz Hub 2
       active: true 
   },
   { 
       id: "HOC3YYYYYYYYYYY",          // ID Hub 3
       mqttPath: "mqtt.0.Zendure3",     // Instanz Hub 3
       active: true 
   }
];

// ------------------------------------------------------------------------------------

const CONFIG = {
   // --- FUNKTIONSUMFANG ---
   ENABLE_TIBBER: true,             // [true/false] Tibber Preis-Logik nutzen
   ENABLE_EVCC: true,               // [true/false] EVCC Auto-Logik nutzen
   ENABLE_PV_FORECAST: true,        // [true/false] Solarprognose nutzen

   // --- LOGGING ---
   INFO_LOGS: true,                 // [true] Wichtige Infos im Log anzeigen
   DEBUG: false,                    // [false] Technische Details (nur zur Fehlersuche)

   // --- BATTERIE & SYSTEM (PRO GERÄT!) ---
   BATTERY_CAPACITY_KWH: 8.64,      // Akkugröße PRO TURM in kWh
   MAX_CHARGE_W_PER_DEVICE: 2400,   // Max Ladeleistung PRO GERÄT
   MAX_DISCHARGE_W_PER_DEVICE: 2400,// Max Entladeleistung PRO GERÄT
   
   PV_FORECAST_SAFETY_FACTOR: 2.0,  // Sicherheitsfaktor für Wetterprognose

   // --- SICHERHEIT & RAMPE ---
   CONNECTION_TIMEOUT_MS: 300000,   // 5 Min. Wenn Daten älter sind -> Hub offline.
   RAMP_STEP_W: 50,                 // Soft-Start: Max. 50W Änderung pro Intervall (nur beim Erhöhen)

   // --- PI-REGLER (GLOBAL) ---
   KP: 0.7,                         // P-Anteil
   KI: 0.08,                        // I-Anteil
   DEADBAND_W: 15,                  // Totzone
   TARGET_W: 0,                     // Zielwert
   
   INTEGRAL_MAX: 30000,             // Interner Speicher Max
   INTEGRAL_MIN: -30000,            // Interner Speicher Min

   // --- ZEIT ---
   REGEL_INTERVALL_MS: 2000,        // Regelung alle 2 Sekunden
   AC_MODE_COOLDOWN_MS: 5000,       // 5 Sek. Pause bei Moduswechsel
};


// ====================================================================================
// 2. DATENPUNKTE (IDs)
// ====================================================================================

const IDs = {
   // --- HAUPTZÄHLER (Pflicht) ---
   netz: "shelly.0.SHEM-3#8CAAB5619A05#1.Total.InstantPower", 
   
   // --- EXTERNE LOGIK ---
   evccModus:   "0_userdata.0.zendure.EVCC_Modus",                        
   tibberLaden: "0_userdata.0.Tibber.01_Automatisierungs-Kanaele.Batterie_laden", 
   
   // --- WETTER ---
   pvForecastRest:  "solarprognose.0.forecast.00.energy_from_now",      
   pvForecastAcc:   "solarprognose.0.forecast.00.accuracy",               
   pvForecastTotal: "solarprognose.0.forecast.00.energy",               
   pvForecastSoFar: "solarprognose.0.forecast.00.energy_now"            
};

// Generiere dynamische IDs für alle Hubs
let HUB_IDS = [];

function generateHubIDs() {
   HUB_IDS = [];
   ZENDURE_DEVICES.forEach((device, index) => {
       if (!device.active) return;
       const base = device.mqttPath;
       const id = device.id;
       
       HUB_IDS.push({
           index: index,
           id: id,
           acMode:        `${base}.select.${id}.acMode`,
           acModeSet:     `${base}.select.${id}.acMode.set`,
           currentInput:  `${base}.number.${id}.inputLimit`,
           inputSet:      `${base}.number.${id}.inputLimit.set`,
           currentOutput: `${base}.number.${id}.outputLimit`,
           outputSet:     `${base}.number.${id}.outputLimit.set`,
           soc:           `${base}.sensor.${id}.electricLevel`,
           // Interner Status
           lastSwitch:    0,
           lastWatts:     0,    // Für die Rampe
           isOnline:      true 
       });
   });
   if (CONFIG.DEBUG) log(`[Init] ${HUB_IDS.length} Hubs konfiguriert.`, 'info');
}

// ====================================================================================
// AB HIER NICHTS MEHR ÄNDERN (Code-Logik)
// ====================================================================================

const AC_MODES = {
   INPUT: "Input mode",    
   OUTPUT: "Output mode"   
};

let integral = 0.0;                    

// --- 4. HILFSFUNKTIONEN ---

function logInfo(message) {
   if (CONFIG.INFO_LOGS) log(`[Info] ${message}`, 'info');
}

function logDebug(message) {
   if (CONFIG.DEBUG) log(`[Debug] ${message}`, 'info');
}

function getStateSafe(id) {
   if (!id) return 0; 
   try {
       if (!existsState(id)) return 0;
       const val = getState(id).val;
       if (val === null || val === undefined) return 0;
       const num = parseFloat(val);
       return isNaN(num) ? 0 : num;
   } catch (e) {
       return 0;
   }
}

function getStateString(id) {
   if (!id) return ""; 
   try {
       if (!existsState(id)) return "";
       const val = getState(id).val;
       return val ? val.toString() : "";
   } catch (e) {
       return "";
   }
}

/**
* Prüft MQTT Zeitstempel (Watchdog).
*/
function checkHubConnectivity() {
   const now = Date.now();
   let onlineCount = 0;

   HUB_IDS.forEach(hub => {
       let isOnline = false;
       try {
           if (existsState(hub.soc)) {
               const state = getState(hub.soc);
               const age = now - state.ts;
               if (age < CONFIG.CONNECTION_TIMEOUT_MS) {
                   isOnline = true;
               } else {
                   if (hub.isOnline) {
                       logInfo(`WARNUNG: Hub ${hub.id} ist OFFLINE! Keine Daten seit ${(age/1000/60).toFixed(1)} Min.`);
                   }
               }
           }
       } catch(e) { isOnline = false; }

       hub.isOnline = isOnline;
       if (isOnline) onlineCount++;
   });

   return onlineCount;
}

// --- 5. INITIALISIERUNG ---

function initialize() {
   logInfo("--- Multi-Batteriesteuerung (v4.2) gestartet ---");
   generateHubIDs();
   
   if (HUB_IDS.length === 0) {
       log("KEINE aktiven Hubs konfiguriert! Skript stoppt.", 'warn');
       return;
   }

   logInfo(`Konfiguriert: ${HUB_IDS.length} Hubs.`);
   logInfo(`Feature Konfig: Watchdog=${CONFIG.CONNECTION_TIMEOUT_MS/1000}s, Rampe=${CONFIG.RAMP_STEP_W}W`);

   integral = 0;
   const now = Date.now();
   HUB_IDS.forEach(h => {
       h.lastSwitch = now;
       h.lastWatts = 0;
   });

   if (CONFIG.REGEL_INTERVALL_MS < 1000) CONFIG.REGEL_INTERVALL_MS = 1000;
   setInterval(mainControlLoop, CONFIG.REGEL_INTERVALL_MS); 
   
   checkOverridesAndAct(); 
}

// --- 6. TRIGGER ---

if (CONFIG.ENABLE_EVCC && IDs.evccModus) {
   on({ id: IDs.evccModus, change: "any" }, (obj) => {
       logInfo(`Trigger: EVCC Modus auf ${obj.state.val} geändert.`);
       checkOverridesAndAct();
   });
}

if (CONFIG.ENABLE_TIBBER && IDs.tibberLaden) {
   on({ id: IDs.tibberLaden, change: "any" }, (obj) => {
       logInfo(`Trigger: Tibber Laden auf ${obj.state.val} geändert.`);
       checkOverridesAndAct();
   });
}

if (CONFIG.ENABLE_TIBBER && CONFIG.ENABLE_PV_FORECAST) {
   if (IDs.pvForecastRest) on({ id: IDs.pvForecastRest, change: "any" }, () => checkOverridesAndAct());
   if (IDs.pvForecastAcc)  on({ id: IDs.pvForecastAcc, change: "any" }, () => checkOverridesAndAct());
}

// --- 7. LOGIK & REGELUNG ---

function checkOverridesAndAct() {
   checkHubConnectivity(); 
   const onlineHubs = HUB_IDS.filter(h => h.isOnline);

   if (onlineHubs.length === 0) return false;

   // 7.1 Tibber Logik
   if (CONFIG.ENABLE_TIBBER && IDs.tibberLaden) {
       let tibberActive = false;
       try {
           tibberActive = getState(IDs.tibberLaden).val === true;
       } catch(e) { tibberActive = false; }
       
       if (tibberActive) {
           let chargeAllowed = false;
           if (isNight()) {
               chargeAllowed = true;
           } else {
               if (CONFIG.ENABLE_PV_FORECAST) {
                   if (checkPvForecastAllowsDayChargeGlobal(onlineHubs)) {
                       chargeAllowed = true;
                   }
               }
           }
           
           if (chargeAllowed) {
               applyPowerToHubs(onlineHubs, AC_MODES.INPUT, CONFIG.MAX_CHARGE_W_PER_DEVICE);
               integral = CONFIG.INTEGRAL_MIN; 
               return true; 
           }
       }
   }

   // 7.2 EVCC Logik
   if (CONFIG.ENABLE_EVCC && IDs.evccModus) {
       const evccMode = getStateSafe(IDs.evccModus); 
       if (evccMode === 2) {
           applyPowerToHubs(onlineHubs, AC_MODES.OUTPUT, 0); 
           integral = CONFIG.INTEGRAL_MAX; 
           return true; 
       } else if (evccMode === 3) {
           applyPowerToHubs(onlineHubs, AC_MODES.INPUT, CONFIG.MAX_CHARGE_W_PER_DEVICE);
           integral = CONFIG.INTEGRAL_MIN; 
           return true; 
       }
   }

   return false;
}

function mainControlLoop() {
   try {
       if (checkOverridesAndAct()) return;

       const onlineCount = checkHubConnectivity();
       if (onlineCount === 0) return;

       const dt = CONFIG.REGEL_INTERVALL_MS / 1000.0; 
       const gridPower = getStateSafe(IDs.netz); 
       
       if (!IDs.netz) return;

       let error = CONFIG.TARGET_W - gridPower;

       // Deadband
       if (Math.abs(gridPower) <= CONFIG.DEADBAND_W) {
           error = 0.0;
       }

       // I-Anteil
       integral += error * dt;
       integral = Math.max(CONFIG.INTEGRAL_MIN, Math.min(CONFIG.INTEGRAL_MAX, integral));

       // P-Anteil
       const pShare = CONFIG.KP * error;
       const iShare = CONFIG.KI * integral;

       let totalOutputPower = pShare + iShare;

       // --- SPLIT LOGIC ---
       let powerPerDevice = totalOutputPower / onlineCount;

       // Clamping (Limitierung)
       if (powerPerDevice > 0) { 
           powerPerDevice = Math.min(powerPerDevice, CONFIG.MAX_CHARGE_W_PER_DEVICE);
       } else if (powerPerDevice < 0) { 
           powerPerDevice = Math.max(powerPerDevice, -CONFIG.MAX_DISCHARGE_W_PER_DEVICE);
       }

       const onlineHubs = HUB_IDS.filter(h => h.isOnline);
       applyPowerToHubs(onlineHubs, null, powerPerDevice);

   } catch (e) {
       log(`Error in MainLoop: ${e}`, 'error');
   }
}

// --- 8. HELPER ---

function applyPowerToHubs(hubList, modeOverride, targetPower) {
   hubList.forEach(hub => {
       setHubPower(hub, modeOverride, targetPower);
   });
}

function setHubPower(hubConfig, modeOverride, power) {
   if (!hubConfig.acModeSet) return;

   let targetMode = AC_MODES.OUTPUT;
   let targetVal = 0;

   // 1. Ziel-Modus bestimmen
   if (modeOverride) {
       targetMode = modeOverride;
       targetVal = Math.abs(power);
   } else {
       power = Math.round(power);
       targetVal = Math.abs(power);
       targetMode = (power > 0) ? AC_MODES.INPUT : AC_MODES.OUTPUT;
   }

   const currentMode = getStateString(hubConfig.acMode);
   
   // 2. RAMPE IMPLEMENTIERUNG
   // Wir rampen den Wert nur, wenn wir im gleichen Modus bleiben.
   // Bei Moduswechsel wird der Rampen-Speicher zurückgesetzt.
   
   if (currentMode !== targetMode) {
       // Bei Moduswechsel: Zielwert sofort akzeptieren (startet meist bei 0 oder niedrig)
       // und Rampe Reset
       hubConfig.lastWatts = 0; 
   } else {
       // Im gleichen Modus: Soft Start prüfen
       const lastVal = hubConfig.lastWatts;
       const diff = targetVal - lastVal;

       // Rampe nur anwenden, wenn wir die LEISTUNG ERHÖHEN (diff > 0).
       // Wenn wir reduzieren (diff < 0), machen wir das sofort (Sicherheit/Netzbezug vermeiden).
       if (diff > CONFIG.RAMP_STEP_W) {
           targetVal = lastVal + CONFIG.RAMP_STEP_W;
           // Wenn wir rampen, loggen wir das kurz im Debug, damit man es sieht
           logDebug(`[${hubConfig.id}] Rampe aktiv: ${lastVal}W -> ${targetVal}W (Ziel war ${Math.abs(power)}W)`);
       }
   }
   
   // Wert für nächsten Durchlauf speichern
   hubConfig.lastWatts = targetVal;


   // 3. Moduswechsel und Senden
   if (currentMode !== targetMode) {
       const now = Date.now();
       
       if (now - hubConfig.lastSwitch < CONFIG.AC_MODE_COOLDOWN_MS) {
           const currentSetID = (currentMode === AC_MODES.INPUT) ? hubConfig.inputSet : hubConfig.outputSet;
           if (getStateSafe(currentSetID) !== 0) setState(currentSetID, "0", false);
           return;
       }

       logInfo(`[${hubConfig.id}] Wechsel: ${currentMode} -> ${targetMode} (${targetVal}W)`);
       hubConfig.lastSwitch = now;
       
       setState(hubConfig.acModeSet, targetMode, false);
       
       if (targetMode === AC_MODES.INPUT) {
           setState(hubConfig.outputSet, "0", false);
           setState(hubConfig.inputSet, String(targetVal), false);
       } else {
           setState(hubConfig.inputSet, "0", false);
           setState(hubConfig.outputSet, String(targetVal), false);
       }

   } else {
       // Gleicher Modus, nur Wert senden
       const targetStr = String(targetVal);
       if (targetMode === AC_MODES.INPUT) {
           if (getState(hubConfig.inputSet).val != targetStr) setState(hubConfig.inputSet, targetStr, false);
       } else {
           if (getState(hubConfig.outputSet).val != targetStr) setState(hubConfig.outputSet, targetStr, false);
       }
   }
}

/**
* Forecast Berechnung basierend auf den Online-Hubs.
*/
function checkPvForecastAllowsDayChargeGlobal(activeHubs) {
   try {
       let totalSoC = 0;
       let count = 0;
       
       activeHubs.forEach(h => {
           totalSoC += getStateSafe(h.soc);
           count++;
       });
       if (count === 0) return false;
       
       const avgSoc = totalSoC / count;
       const forecastRest = getStateSafe(IDs.pvForecastRest);
       let accuracy = getStateSafe(IDs.pvForecastAcc);
       if (!IDs.pvForecastAcc || accuracy <= 0) accuracy = 50; 
       
       const effectiveRest = forecastRest * (accuracy / 100.0);
       const totalCapacity = CONFIG.BATTERY_CAPACITY_KWH * count; 
       const missingCap = totalCapacity * (100 - avgSoc) / 100.0;
       const threshold = missingCap * CONFIG.PV_FORECAST_SAFETY_FACTOR;

       return effectiveRest < threshold;
   } catch (e) {
       return false; 
   }
}

function isNight() {
   try {
       const sunrise = getAstroDate('sunrise');
       const sunset = getAstroDate('sunset');
       const now = new Date();
       if (!sunrise || !sunset) return false; 
       return (now > sunset || now < sunrise);
   } catch (e) {
       return false;
   }
}

// --- Start ---
initialize();

Rand

@schimi

Das widerspricht aber der Idee das man 2/3 Geräte hat um die maximale Einspeise/Abgabe Leistung zu erhöhen. Eigentlich müssten beide/alle 3 immer als Gruppe geregelt werden (also 50%/33%) der Gesamt Ladung/Ausgabe pro Gerät.
Eine gruppenbasierte Aufteilung sollte auch "trocken" relativ gut entwickelbar sein, hast halt ne Gruppe mit einem Gerät die dann 100%/1 der Eingabe/Ausgabe-Anforderung abdeckt.

Theoretisch mag es auch Leute mit mehr als 3 Geräten geben (was ja technisch kein Problem ist solange sie an unterschiedlichen Sicherungen hängen), aber das wäre denke ich erstmal nur ein relativer kleiner Teil.

Andere Frage: warum ist denn SetSmartmode nicht bei Dir mit drin? Ich meine ja man kann auch das andere Skript nehmen, aber du pollst / setzt ja eh schon regelmäßig da wäre das doch kein Thema...

Und hast Du mal den idle Stromverbrauch betrachtet? Hatte ja im Adapterthread über Shelly's gesprochen aber habe natürlich keine Ahnung ob das gut oder schlecht für den Akku ist, wenn man versucht, ihn per Stromweg auszuschalten - und wann er denn wirklich aus geht (minSoc?) Hab Zendure gefragt aber noch keine Rückmeldung bekommen...

Schimi

schau mal in den Spoiler... das müsste funktionieren...

ich will dieses Script so einfach wie moglich halten...

ich lasse das von maxclaudi auch seperat laufen, eine Fehlerauelle weniger und wenn er was optimiert, kann man es direkt nutzen.

Ich habe noch was "größeres" in der Pipeline (ist gerade im test).... das konnte entweder total speziell auf mich zugeschnitten oder richtig gut fur alle sein, sobald es veröffentlicht ist.

Würde dann mit dem Zendure ZENKO konkurieren....

Die aktuellen tests sind schonmal positiv

Rand

Ok, dann muss ich mal schauen wie man das das eigentlich Set macht...

Re neue Version - Beide Zendures schreiben in den gleichen MQTT Zweig (mqtt.0.Zendure.sensor.HOXXX) und unterscheiden sich dann nur bzgl ID

 // --- HARDWARE LIMITS (ZENDURE HUB) ----------------------------------------------
    MAX_CHARGE_W: 2400,              // Maximale Ladeleistung (Hub 2000 = 1200W, Hub 2000 Dual = 2400W)
    MAX_DISCHARGE_W: 2400,           // Maximale Entladeleistung ins Hausnetz

Ist das pro Gerät oder Total?
Hardware limit klingt nach Gerät, "Entladeleistungs ins Hausnetz" nach Gesamt;)

Schimi

@Rand wo steht das?

Bei mir im Script finde ich das nicht ;-)

https://forum.iobroker.net/post/1314031

Rand

Lol, aber stimmt. Habe ich in der alten Version geschaut;)

Hat soweit ganz gut funktioniert heute, etwas hibbelig um den Break even/ Ladepunkt herum, vlt weil er dann ja auch schon auf 2 aufteilt und dann auch kleine Lichtschwankungen (diesig) schnell unter die Bezugsgrenze fallen.

Community Forum

NEWS

Zendure SolarFlow2400 AC (EVCC, Tibber und PV-Forecast)

Support us

405

32.5k

81.7k

1.3m