Skip to content
  • Recent
  • Tags
  • 0 Unread 0
  • Categories
  • Unreplied
  • Popular
  • GitHub
  • Docu
  • Hilfe
Skins
  • Light
  • Brite
  • Cerulean
  • Cosmo
  • Flatly
  • Journal
  • Litera
  • Lumen
  • Lux
  • Materia
  • Minty
  • Morph
  • Pulse
  • Sandstone
  • Simplex
  • Sketchy
  • Spacelab
  • United
  • Yeti
  • Zephyr
  • Dark
  • Cyborg
  • Darkly
  • Quartz
  • Slate
  • Solar
  • Superhero
  • Vapor

  • Default (No Skin)
  • No Skin
Collapse
Logo
  1. ioBroker Community Home
  2. Deutsch
  3. Skripten / Logik
  4. JavaScript
  5. Zendure SmartMode:1 SolarFlow2400 AC SolarFlow800 ( u. Pro)

NEWS

  • UPDATE 31.10.: Amazon Alexa - ioBroker Skill läuft aus ?
    apollon77A
    apollon77
    48
    3
    8.1k

  • Monatsrückblick – September 2025
    BluefoxB
    Bluefox
    13
    1
    1.8k

  • Neues Video "KI im Smart Home" - ioBroker plus n8n
    BluefoxB
    Bluefox
    15
    1
    2.0k

Zendure SmartMode:1 SolarFlow2400 AC SolarFlow800 ( u. Pro)

Scheduled Pinned Locked Moved JavaScript
174 Posts 6 Posters 7.7k Views 5 Watching
  • Oldest to Newest
  • Newest to Oldest
  • Most Votes
Reply
  • Reply as topic
Log in to reply
This topic has been deleted. Only users with topic management privileges can see it.
  • maxclaudiM Offline
    maxclaudiM Offline
    maxclaudi
    wrote on last edited by maxclaudi
    #1

    Für alle mit den neuen Geräten:

    • SolarFlow 800
    • SolarFlow 800 Pro
    • SolarFlow 2400 AC

    Immer wieder taucht die Frage auf z.B. (z. B. Michi 0 ), wie man den SmartMode:1 setzen kann.
    Bisher wurde das noch nirgends wirklich anwenderfreundlich beantwortet.

    Hier nun die Lösung:

    Mit diesem Script können nicht nur smartMode:1 und die MQTT-Verbindung (de-)aktiviert werden, sondern auch einiges mehr.


    Update 16.10.2025 1935h– Neues Script
    ioBroker JavaScript: Zendure SolarFlow 800 Pro (SF2400AC) via zenSDK HTTP
    Kein Hack, dafür wurde die offizielle zenSDK verwendet.
    plattformunabhängig - Linux, Windows

    Jetzt können auch Commands gesetzt werden, wie in einem Adapter. 🙂

    Muss man nicht nutzen, kann man aber zusätzlich einsetzen – z. B. falls MQTT mal Probleme macht oder wenn weitere set-Befehle dazukommen sollen.

    Hinweis:
    Damit neue Datenpunkte automatisch aus dem JSON erstellt werden:
    → Instanzen → JavaScript-Adapter → Allgemeine Einstellungen → „Enable command setObject“ aktivieren!

    So viel wie möglich wurde ohne Gerät getestet und simuliert.
    Extra ohne Schleifen und strukturiert geschrieben, damit jeder das Script nachvollziehen kann.

    Intervalle

    • intervalGet sollte nicht < 30 s gesetzt werden – das bringt keinen Mehrwert.
    • intervalMqtt = 300 s ist völlig ausreichend, um zu prüfen, ob MQTT verbunden ist.

    Eigene Daten anpassen
    Zendure Gerät:

    const IP = "192.168.177.103";   // IP des Zendure Geräts
    const SN = "EXXXXXXXXXXXXX0";   // Seriennummer
    

    Intervalle für Abfragen (in Sekunden):

    const intervalGet = 60;   // SmartMode (default: 60 s, nicht < 30)
    const intervalMqtt = 300; // MQTT-Status (default: 300 s, > SmartMode)
    

    MQTT-Broker Konfiguration:

    const mqttBrokerIp = "192.168.177.200"; // IP MQTT Broker (auch in App eingestellt)
    const mqttPort = 1883;                  // Port MQTT Broker (auch in App eingestellt)           
    const mqttUsername = "Daisy";           // MQTT Username
    const mqttPassword = "coco";            // MQTT Passwort
    
    

    Maximale Input-/Output-Limits:

    // Maximum Input-Limit
    const maxInputLimit = 800;   // SF800Pro
    //const maxInputLimit = 2400; // SF2400AC
    
    // Maximum Output-Limit
    const maxOutputLimit = 800;   // SF800Pro
    //const maxOutputLimit = 2400; // SF2400AC
    
    

    Hinweise

    • wichtig: wenn MQTT über dieses Script eingeschaltet wird, hat es vermutlich Vorrang!
      Es werden ggf. andere MQTT-Einstellungen in der App durch das Script überschrieben.

    • Wer meine Arbeit nützlich findet und sich bedanken möchte:
      Ein Klick auf den Pfeil nach oben (unten am Post, neben Zitieren) reicht völlig. Das ist für mich mehr als genug. 🙂

    • Dieser erste Post wird bei Änderungen editiert, damit das aktuelle Script immer direkt hier auffindbar ist.

    • Beschreibung / Anleitung
      Hinweise zur Benutzung, der aktuellen Version des Scripts und zusätzliche Tipps, siehe:
      Post im Thread

    Viel Spaß! ☀


    //
    // ioBroker JavaScript: Zendure SolarFlow 800 Pro (SF2400AC) via zenSDK HTTP
    // by maxclaudi 2025.10.16 19:35h for ioBroker Forum
    //------------------------------------------------------------------------------------
    // konfiguration
    //
    // Hinweis bei mehreren Zendure-Geräten:
    // - Für jedes Gerät ein eigenes Script mit individueller Konfiguration verwenden!
    //   → IP-Adresse
    //   → Seriennummer (SN)
    //   → MQTT-Daten (Broker, Port, Benutzer, Passwort)
    //   → maxInputLimit / maxOutputLimit (abhängig vom Gerätetyp)
    // - Intervalle (Standard): intervalGet = 60s, intervalMqtt = 300s – können gleich bleiben
    //
    // Empfehlung:
    //   • 3 Geräte: völlig unkritisch
    //   • 4 Geräte: problemlos möglich
    //   • mehr als 4: nicht empfohlen
    //
    //
    // Damit neue Datenpunkte automatisch aus dem JSON erstellt werden:
    // -> Instanzen -> javascript-Adapter -> Allgemeine Einstellungen -> Enable command"setObject“ aktivieren!
    //
    //------------------------------------------------------------------------------------
    // Intervalle für Abfragen (Sekunden)
    const intervalGet = 60;                 // sek SmartMode   (default:  60 sek, not <30)
    const intervalMqtt = 300;               // sek MQTT-Status (default: 300 sek, > SmartMode)
     
    // IP und Seriennummer Zendure Gerät
    const IP = "192.168.40.111";           // IP des Zendure Geräts
    const SN = "EXXXXXXXXXXXXX0";           // Seriennummer
     
    // MQTT Broker Konfiguration
    const mqttBrokerIp = "192.168.40.200";  // IP MQTT Broker und in App eingestellt 
    const mqttPort = 1883;                // PORT MQTT Broker und in App eingestellt           
    const mqttUsername = "Daisy";           // MQTT Username
    const mqttPassword = "coco";            // MQTT Passwort
     
    //maximum inputLimit SF800PRO: 800W / SF2400AC: 2400W
    const maxInputLimit = 1000; //SF800Pro
    //const maxInputLimit = 2400; //SF2400AC
     
    //maximum outputLimit SF800PRO: 800W / SF2400AC: 2400W
    const maxOutputLimit = 800; //SF800Pro
    //const maxOutputLimit = 2400; //SF2400AC
    //------------------------------------------------------------------------------------ 
    //------------------------------------------------------------------------------------
    // Datenpunkte
    const folderZendureApi = '0_userdata.0.zendure.' + SN;
    //------------------------------------------------------------------------------------
    const dpSmartModeInfo              = folderZendureApi + ".zendureSmartMode.smartModeInfo";
    const dpSetSmartMode               = folderZendureApi + ".zendureSmartMode.setSmartMode";
    const dpSetSmartModeResult         = folderZendureApi + ".zendureSmartMode.setResult";
    const dpTimestamp                  = folderZendureApi + ".zendureSmartMode.timestamp";
     
    const dpMqttConnectInfo            = folderZendureApi + ".zendureMqttState.mqttConnectInfo";
    const dpSetMqttConnect             = folderZendureApi + ".zendureMqttState.setMqttConnect";
    const dpSetMqttConnectResult       = folderZendureApi + ".zendureMqttState.setMqttConnectResult";
    const dpMqttTimestamp              = folderZendureApi + ".zendureMqttState.mqttTimestamp";
     
    //set dp
    const dpSetAcMode                  = folderZendureApi + ".control.acMode.setAcMode";
    const dpSetAcModeResult            = folderZendureApi + ".control.acMode.setAcModeResult";
    const dpSetAcModeResultTS          = folderZendureApi + ".control.acMode.setAcModeResultTs";
     
    const dpSetInputLimit              = folderZendureApi + ".control.inputLimit.setInputLimit";
    const dpSetInputLimitResult        = folderZendureApi + ".control.inputLimit.setInputLimitResult";
    const dpSetInputLimitResultTS      = folderZendureApi + ".control.inputLimit.setInputLimitResultTs";
     
    const dpSetOutputLimit             = folderZendureApi + ".control.outputLimit.setOutputLimit";
    const dpSetOutputLimitResult       = folderZendureApi + ".control.outputLimit.setOutputLimitResult";
    const dpSetOutputLimitResultTS     = folderZendureApi + ".control.outputLimit.setOutputLimitResultTs";
     
    const dpSetSocSet                  = folderZendureApi + ".control.socSet.setSocSet";
    const dpSetSocSetResult            = folderZendureApi + ".control.socSet.setSocSetResult";
    const dpSetSocSetResultTS          = folderZendureApi + ".control.socSet.setSocSetResultTs";
     
    const dpSetMinSoc                  = folderZendureApi + ".control.minSoc.setMinSoc";
    const dpSetMinSocResult            = folderZendureApi + ".control.minSoc.setMinSocResult";
    const dpSetMinSocResultTS          = folderZendureApi + ".control.minSoc.setMinSocResultTs";
     
    const dpSetGridReverse             = folderZendureApi + ".control.gridReverse.setGridReverse";
    const dpSetGridReverseResult       = folderZendureApi + ".control.gridReverse.setGridReverseResult";
    const dpSetGridReverseResultTS     = folderZendureApi + ".control.gridReverse.setGridReverseResultTs";
     
    const dpSetGridStandard            = folderZendureApi + ".control.gridStandard.setGridStandard";
    const dpSetGridStandardResult      = folderZendureApi + ".control.gridStandard.setGridStandardResult";
    const dpSetGridStandardResultTS    = folderZendureApi + ".control.gridStandard.setGridStandardResultTs";
    
    const dpSetInverseMaxPower         = folderZendureApi + ".control.inverseMaxPower.setInverseMaxPower";
    const dpSetInverseMaxPowerResult   = folderZendureApi + ".control.inverseMaxPower.setInverseMaxPowerResult";
    const dpSetInverseMaxPowerResultTS = folderZendureApi + ".control.inverseMaxPower.setInverseMaxPowerResultTs"; 
    //------------------------------------------------------------------------------------
    const http = require("http");           // Node.js http Standardmodul
    //------------------------------------------------------------------------------------
    
    // Mapping: Payload key, optional transformation, result and timestamp dp
    const dpMap = {
        [dpSetAcMode]:          { key: "acMode", result: dpSetAcModeResult, resultTS: dpSetAcModeResultTS, minNormal: 1, maxNormal: 2 },
        [dpSetInputLimit]:      { key: "inputLimit", result: dpSetInputLimitResult, resultTS: dpSetInputLimitResultTS, minNormal: 0, maxNormal: maxInputLimit },
        [dpSetOutputLimit]:     { key: "outputLimit", result: dpSetOutputLimitResult, resultTS: dpSetOutputLimitResultTS, minNormal: 0, maxNormal: maxOutputLimit },
        [dpSetSocSet]:          { key: "socSet", transform: v => v*10, result: dpSetSocSetResult, resultTS: dpSetSocSetResultTS, minNormal: 70, maxNormal: 100 },
        [dpSetMinSoc]:          { key: "minSoc", transform: v => v*10, result: dpSetMinSocResult, resultTS: dpSetMinSocResultTS, minNormal: 5, maxNormal: 50 },
        [dpSetGridReverse]:     { key: "gridReverse", result: dpSetGridReverseResult, resultTS: dpSetGridReverseResultTS, minNormal: 0, maxNormal: 2 },
        [dpSetGridStandard]:    { key: "gridStandard", result: dpSetGridStandardResult, resultTS: dpSetGridStandardResultTS, minNormal: 0, maxNormal: 2 },
        [dpSetInverseMaxPower]: { key: "inverseMaxPower", result: dpSetInverseMaxPowerResult, resultTS: dpSetInverseMaxPowerResultTS, minNormal: 600, maxNormal: maxOutputLimit }
    };
     
    // Queue HTTP
    const curlQueue = [];
    let curlRunning = false;
     
    function runQueue() {
        if (curlRunning || curlQueue.length === 0) return;
        const task = curlQueue.shift();
        curlRunning = true;
        task.fn(() => {
            curlRunning = false;
            runQueue();
        });
    }
     
    //dp have to exist - get
    function delay(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }
     
    // dp create
    createState(dpSmartModeInfo, 0, {
            name: "SmartMode Info",
            type: "number",
            role: "state",
            read: true,
            write: false,
            min: 0,
            max: 1
            }, async () => {
               await delay(1);
               getReport();
    });
     
    createState(dpSetSmartMode, -1, {
           name: "SmartMode Set",
    	   type: "number",
    	   role: "state",
    	   read: true,
    	   write: true,
    	   min: -1,
    	   max: 1
    }, () => {});
     
    createState(dpSetSmartModeResult, "", {
           name: "SmartMode Set Result",
    	   type: "string",
    	   role: "info",
    	   read: true,
    	   write: false
    }, () => {});
     
    createState(dpTimestamp, "", {
           name: "Timestamp",
    	   type: "string",
    	   role: "info",
    	   read: true,
    	   write: false
           }, async () => {
               await delay(1);
    });
     
    createState(dpMqttConnectInfo, 0, {
        name: "MQTT Connect Info",
        type: "number", 
        role: "state",
        read: true,
        write: false,
        min: 0,
        max: 1
        }, async () => {
           await delay(1);
        getMqttStatus();
    });
     
    createState(dpSetMqttConnect, -1, {
           name: "MQTT Connect Set",
    	   type: "number",
    	   role: "state",
    	   read: true,
    	   write: true,
    	   min: -1,
    	   max: 1
    }, () => {});
     
    createState(dpSetMqttConnectResult, "", {
           name: "MQTT Connect Result",
    	   type: "string",
    	   role: "info",
    	   read: true,
    	   write: false
    }, () => {});
     
    createState(dpMqttTimestamp, "", {
           name: "MQTT Timestamp",
    	   type: "string",
    	   role: "info",
    	   read: true,
    	   write: false
    }, async () => { await delay(1); });
     
    // set > result ts dp
    // acMode
    createState(dpSetAcMode, -1, {
           name: "set acMode, 1: charging 2: discharging",
    	   desc: "1: Input, 2: Output",
    	   type: "number",
    	   role: "state",
    	   read: true,
    	   write: true,
    	   min: -1,
    	   max: 2
    }, () => {});
     
    createState(dpSetAcModeResult, "", {
        name: "AcMode Set Result",
        type: "string",
        role: "info",
        read: true,
        write: false
    }, () => {});
     
    createState(dpSetAcModeResultTS, "", {
        name: "AcMode Set Result Timestamp",
        type: "string",
        role: "info",
        read: true,
        write: false
    }, () => {});
     
    // inputLimit
    createState(dpSetInputLimit, -1, {
           name: "set inputLimit",
    	   desc: "AC charging power limit",
    	   type: "number",
    	   role: "state",
    	   read: true,
    	   write: true,
    	   unit: 'W',
    	   min: -1,
    	   max: maxInputLimit //SF800Pro: 1000W, SF2400AC: 2400W
    }, () => {});
     
    createState(dpSetInputLimitResult, "", {
        name: "InputLimit Set Result",
        type: "string",
        role: "info",
        read: true,
        write: false
    }, () => {});
     
    createState(dpSetInputLimitResultTS, "", {
        name: "InputLimit Set Result Timestamp",
        type: "string",
        role: "info",
        read: true,
        write: false
    }, () => {});
     
    // outputLimit
    createState(dpSetOutputLimit, -1, {
           name: "set outputLimit",
    	   desc: "Output power limit",
    	   type: "number",
    	   role: "state",
    	   read: true,
    	   write: true,
    	   unit: 'W',
    	   min: -1,
    	   max: maxOutputLimit //SF800Pro: 800W, SF2400AC: 2400W
    }, () => {});
     
    createState(dpSetOutputLimitResult, "", {
        name: "OutputLimit Set Result",
        type: "string",
        role: "info",
        read: true,
        write: false
    }, () => {});
     
    createState(dpSetOutputLimitResultTS, "", {
        name: "OutputLimit Set Result Timestamp",
        type: "string",
        role: "info",
        read: true,
        write: false
    }, () => {});
     
    // socSet
    createState(dpSetSocSet, -1, {
           name: "set socSet 70-100%",
    	   desc: "Stop charging at battery percentage",
    	   type: "number",
    	   role: "state",
    	   read: true,
    	   write: true,
    	   unit: '%',
    	   min: -1,
    	   max: 100
    }, () => {});
     
    createState(dpSetSocSetResult, "", {
        name: "SocSet Set Result",
        type: "string",
        role: "info",
        read: true,
        write: false
    }, () => {});
     
    createState(dpSetSocSetResultTS, "", {
        name: "SocSet Set Result Timestamp",
        type: "string",
        role: "info",
        read: true,
        write: false
    }, () => {});
     
    // minSoc
    createState(dpSetMinSoc, -1, {
           name: "set minSoc 0-50%",
    	   desc: "Stop discharging at battery percentage",
    	   type: "number",
    	   role: "state",
    	   read: true,
    	   write: true,
    	   unit: '%',
    	   min: -1,
    	   max: 50
    }, () => {});
     
    createState(dpSetMinSocResult, "", {
        name: "MinSoc Set Result",
        type: "string",
        role: "info",
        read: true,
        write: false
    }, () => {});
     
    createState(dpSetMinSocResultTS, "", {
        name: "MinSoc Set Result Timestamp",
        type: "string",
        role: "info",
        read: true,
        write: false
    }, () => {});
     
    // gridReverse
    createState(dpSetGridReverse, -1, {
           name: "setGridReverse, 0: off, 1: rev. 2: no rev",
    	   desc: "0: Disabled, 1: Allowed reverse flow, 2: Forbidden reverse flow",
    	   type: "number",
    	   role: "state",
    	   read: true,
    	   write: true,
    	   min: -1,
    	   max: 2
    }, () => {});
     
    createState(dpSetGridReverseResult, "", {
        name: "GridReverse Set Result",
        type: "string",
        role: "info",
        read: true,
        write: false
    }, () => {});
     
    createState(dpSetGridReverseResultTS, "", {
        name: "GridReverse Set Result Timestamp",
        type: "string",
        role: "info",
        read: true,
        write: false
    }, () => {});
     
    // gridStandard
    createState(dpSetGridStandard, -1, {
           name: "setGridStandard, 0: Germany / 2: France",
    	   desc: "Grid connection standard 0: Germany 1: France 2: Austria",
    	   type: "number",
    	   role: "state",
    	   read: true,
    	   write: true,
    	   min: -1,
    	   max: 2
    }, () => {});
     
    createState(dpSetGridStandardResult, "", {
        name: "GridStandard Set Result",
        type: "string",
        role: "info",
        read: true,
        write: false
    }, () => {});
     
    createState(dpSetGridStandardResultTS, "", {
        name: "GridStandard Set Result Timestamp",
        type: "string",
        role: "info",
        read: true,
        write: false
    }, () => {});
    
    // inverseMaxPower
    createState(dpSetInverseMaxPower, -1, {
           name: "set inverseMaxPower",
    	   desc: "Maximum output power limit",
    	   type: "number",
    	   role: "state",
    	   read: true,
    	   write: true,
    	   unit: 'W',
    	   min: -1,
    	   max: maxOutputLimit
    }, () => {});
     
    createState(dpSetInverseMaxPowerResult, "", {
        name: "inverseMaxPower Set Result",
        type: "string",
        role: "info",
        read: true,
        write: false
    }, () => {});
     
    createState(dpSetInverseMaxPowerResultTS, "", {
        name: "inverseMaxPower Set Result Timestamp",
        type: "string",
        role: "info",
        read: true,
        write: false
    }, () => {});
    
    // intervals start																											  
    setInterval(getReport, intervalGet*1000);
    setInterval(getMqttStatus, intervalMqtt*1000);
     
    // trigger smartMode
    on({id: dpSetSmartMode, ack:false}, obj => {
        const val = parseInt(obj.state.val,10);
        if(val===0||val===1) setSmartMode(val);
    });
     
    // trigger MQTT connect
    on({id: dpSetMqttConnect, ack:false}, obj => {
        const val = parseInt(obj.state.val,10);
        if(val===0||val===1) setMqttConnect(val);
    });
     
    // trigger dp set
    Object.keys(dpMap).forEach(id => {
        on({ id: id, ack: false }, obj => {
            const val = obj.state.val;
            const { minNormal, maxNormal } = dpMap[id];
    
            // check values
            if (val >= minNormal && val <= maxNormal) {
    																 
                setControlDP(id, val);  // Transformation
            } else {
                log(`Value ${val} for ${id} is not allowed`, 'warn');
            }
        });
    });
    
    // time format
    function formatTime(ts) {
    	// ts unix sek							
        const d = new Date(ts * 1000);
        const pad = n => n.toString().padStart(2, "0");
        return `${pad(d.getDate())}.${pad(d.getMonth()+1)}.${d.getFullYear().toString().slice(-2)} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
    }
    
    // helper HTTP-error
    function handleHttpError(context, err, options) {
        const transient = [
            "EHOSTUNREACH", "ECONNRESET", "ECONNREFUSED", "ETIMEDOUT",
            "socket hang up", "ENETUNREACH", "EAI_AGAIN", "ENOTFOUND"
        ];
    
        const msg = err && err.message ? err.message : String(err);
        const isTransient = transient.some(code => msg.includes(code));
    
        //info_error
    	//log(`${context}: ${isTransient ? "war vorübergehend im Intervall nicht erfolgreich:" : "Warnung"} (${msg})`, isTransient ? "info" : "warn");
        log(`${context}: ${isTransient ? "war vorübergehend im Intervall nicht erfolgreich:" : "Warnung"} (${msg})`, "info");
    
        // set Timestamp
        if (options && options.timestamp) {
            setState(options.timestamp, formatTime(Math.floor(Date.now() / 1000)), true);
        }
    }
    
    // smartMode GET report
    function getReport() {
        curlQueue.push({
            fn: async done => {      //async
                const options = {
                    hostname: IP,
                    port: 80,
                    path: "/properties/report",
                    method: "GET",
                    timeout: 5000
                };
                const req = http.request(options, res => {
                    let data = "";
                    res.on("data", chunk => data += chunk);
                    res.on("end", async () => {     // async
                        try {
                            const json = JSON.parse(data);
                            if (json.properties && typeof json.properties.smartMode !== "undefined") {
                                setState(dpSmartModeInfo, json.properties.smartMode, true);
                                setState(dpTimestamp, formatTime(Math.floor(Date.now() / 1000)), true);
                            }
                            //JSON
                            await processJson(json);
                        } catch (e) {
                            log("GET JSON Parse Fehler: " + e, "info"); //no valid JSON
                            setState(dpTimestamp, formatTime(Math.floor(Date.now() / 1000)), true);
                        }
                        done();
                    });
                });
                req.on("error", err => { 
                    handleHttpError("HTTP GET", err, { timestamp: dpTimestamp }); 
                    done(); 
                });
                req.end();
            }
        });
        runQueue();
    }
    
    // smartMode POST
    function setSmartMode(val) {
        curlQueue.push({
            fn: done => {
                const payload = JSON.stringify({ sn: SN, properties: { smartMode: val } });
                const options = {
                    hostname: IP,
                    port: 80,
                    path: "/properties/write",
                    method: "POST",
                    headers: {
                        "Content-Type": "application/json",
                        "Content-Length": Buffer.byteLength(payload)
                    },
                    timeout: 5000
                };
    
                const req = http.request(options, res => {
                    let data = "";
                    res.on("data", chunk => data += chunk);
    
                    res.on("end", () => {
                        let ok = false;
    
                        if (data) {
                            try {
                                const json = JSON.parse(data);
                                ok = json.success === true;
                            } catch (e) {
                                ok = false; // no valid JSON
                            }
                        }
    					setState(dpSetSmartModeResult, ok ? `ok set ${val}` : `error set ${val}`, true);
                        setState(dpTimestamp, formatTime(Math.floor(Date.now() / 1000)), true);
    					setState(dpSetSmartMode, -1, true);
                        done();
                    });
                });
    
                req.on("error", err => {
                    handleHttpError("HTTP POST", err, { timestamp: dpTimestamp });
                    setState(dpSetSmartModeResult, `error set ${val}`, true);
                    setState(dpTimestamp, formatTime(Math.floor(Date.now() / 1000)), true);
    				setState(dpSetSmartMode, -1, true);
                    done();
                });
    
                req.write(payload);
                req.end();
            }
        });
    
        runQueue();
    }
     
    // MQTT state GET
    function getMqttStatus() {
        curlQueue.push({
            fn: done => {
                const options = {
                    hostname: IP,
                    port: 80,
                    path: "/rpc?method=HA.Mqtt.GetStatus",
                    method: "GET",
                    timeout: 5000
                };
                const req = http.request(options, res => {
                    let data = "";
                    res.on("data", chunk => data += chunk);
                    res.on("end", () => {
                        try {
                            const json = JSON.parse(data);
                            const state = json.connected ? 1 : 0;
                            setState(dpMqttConnectInfo, state, true);
                            setState(dpMqttTimestamp, formatTime(Math.floor(Date.now() / 1000)), true);
                        } catch (e) {
                            log(`MQTT JSON Parse Fehler: ${e}`, "info"); //no valid JSON
                            setState(dpMqttTimestamp, formatTime(Math.floor(Date.now() / 1000)), true);
                        }
                        done();
                    });
                });
                req.on("error", err => { 
                    handleHttpError("HTTP MQTT GET", err, { timestamp: dpMqttTimestamp }); 
                    done(); 
                });
                req.end();
            }
        });
        runQueue();
    }
     
    // MQTT POST
    function setMqttConnect(val) {
        curlQueue.push({
            fn: done => {
                const enable = !!val;
                const payload = JSON.stringify({
                    sn: SN,
                    method: "HA.Mqtt.SetConfig",
                    params: {
                        config: {
                            enable: enable,
                            server: mqttBrokerIp,
                            port: mqttPort,
                            protocol: "mqtt",
                            username: mqttUsername,
                            password: mqttPassword
                        }
                    }
                });
    
                const options = {
                    hostname: IP,
                    port: 80,
                    path: "/rpc",
                    method: "POST",
                    headers: {
                        "Content-Type": "application/json",
                        "Content-Length": Buffer.byteLength(payload)
                    },
                    timeout: 5000
                };
    
                const req = http.request(options, res => {
                    let data = "";
                    res.on("data", chunk => data += chunk);
    
                    res.on("end", () => {
                        let ok = false;
    
                        // HTTP 200 =  ok, Request succes
                        if (res.statusCode === 200) {
                            if (data) {
                                try {
                                    const json = JSON.parse(data);
                                    ok = json.success === true;
                                } catch (e) {
                                    ok = false; // no valid JSON
                                }
                            }
                        }
    					setState(dpSetMqttConnectResult, ok ? `ok set ${val}` : `error set ${val}`, true);
                        setState(dpMqttTimestamp, formatTime(Math.floor(Date.now() / 1000)), true);
    					setState(dpSetMqttConnect, -1, true);
                        done();
                    });
                });
    
                req.on("error", err => {
                    handleHttpError("HTTP MQTT POST", err, { timestamp: dpMqttTimestamp });
                    setState(dpSetMqttConnectResult, `error set ${val}`, true);
                    setState(dpMqttTimestamp, formatTime(Math.floor(Date.now() / 1000)), true);
    				setState(dpSetMqttConnect, -1, true);
                    done();
                });
    
                req.write(payload);
                req.end();
            }
        });
    
        runQueue();
    }
    
    // Generic POST function with result and timestamp handling
    function setControlDP(id, val) {
        if (!dpMap[id]) return;
        const { key, transform, result, resultTS } = dpMap[id];
        const value = transform ? transform(val) : val;
    
        curlQueue.push({
            fn: done => {
                const payload = JSON.stringify({ sn: SN, properties: { [key]: value } });
                const options = {
                    hostname: IP,
                    port: 80,
                    path: "/properties/write",
                    method: "POST",
                    headers: {
                        "Content-Type": "application/json",
                        "Content-Length": Buffer.byteLength(payload)
                    },
                    timeout: 5000
                };
    
                const req = http.request(options, res => {
                    let data = "";
                    res.on("data", chunk => data += chunk);
    
                    res.on("end", () => {
                        let ok = false;
    
                        // HTTP 200 = Connection established
                        if (res.statusCode === 200) {
                            if (data) {
                                try {
                                    const json = JSON.parse(data);
                                    ok = json.success === true;
                                } catch (e) {
                                    ok = false; // no valid JSON
                                }
                            }
                        }
    
                        // Write success or failure to data points
                        if (result) {
                            const valueToSend = val;  // Wert, der gesendet wurde
    						setState(result, ok ? `ok set ${valueToSend}` : `error set ${valueToSend}`, true);
                        }
                        if (resultTS) setState(resultTS, formatTime(Math.floor(Date.now() / 1000)), true);
    					setState(id, -1, true);
                        done();
                    });
                });
                
    			req.on("error", err => {
                    handleHttpError("HTTP POST " + key, err, { timestamp: resultTS });
                    if (result) {
                        const valueToSend = val;  // Wert, der gesendet wurde
    					setState(result, `error set ${valueToSend}`, true);
                    }
                    if (resultTS) setState(resultTS, formatTime(Math.floor(Date.now() / 1000)), true);
    				setState(id, -1, true);
                    done();
                });
                req.write(payload);
                req.end();
            }
        });
        runQueue();
    }
    
    //------------------------------------------------------------------------------------
    // JSON
    //------------------------------------------------------------------------------------
    async function processJson(obj) {
        try {
            if (!obj || !obj.product) return;
     
            const product = obj.product;
            const basePath = `${folderZendureApi}.${product}`;
     
            // create product folder if not exist
            if (!existsObject(basePath)) {
                setObject(basePath, {
                    type: 'folder',
                    common: { name: product },
                    native: {},
                });
            }
     
            // create main keys
            const mainKeys = ['timestamp', 'messageId', 'sn', 'version', 'product'];
            for (const key of mainKeys) {
                if (obj[key] !== undefined) {
                    const statePath = `${basePath}.${key}`;
                    if (existsState(statePath)) {
                        setState(statePath, obj[key], true);
                    } else {
                        createState(statePath, obj[key], {
                            name: key,
                            type: typeof obj[key],
                            role: 'info',
                            read: true,
                            write: false,
                        });
                    }
                }
            }
     
            // properties
            if (obj.properties) {
                await iter(`${basePath}.properties`, obj.properties);
            }
     
            // PackData
            if (obj.packData && Array.isArray(obj.packData)) {
                await iter(`${basePath}`, { packData: obj.packData, timestamp: obj.timestamp });
            }
        } catch (e) {
            log(`Error processing JSON: ${e}`, 'info');
        }
    }
     
    //------------------------------------------------------------------------------------
    // Battery
    //------------------------------------------------------------------------------------
    function getBatteryType(sn, model) {
      let batType = '';
      if (sn?.startsWith('A')) batType = 'AB1000';
      else if (sn?.startsWith('B')) batType = 'AB1000S';
      else if (sn?.startsWith('C')) batType = sn[3] === 'F' ? 'AB2000S' : sn[3] === 'E' ? 'AB2000X' : 'AB2000';
      else if (sn?.startsWith('F')) batType = 'AB3000X';
      if (model?.trim()) batType = model.trim();
      return batType || 'unknown';
    } 
    
    //------------------------------------------------------------------------------------
    // helper Iteration
    //------------------------------------------------------------------------------------
    async function iter(id, obj) {
        try {
    		if (!obj || typeof obj !== "object") {
               //log("iter: Ungültiges oder leeres Objekt übersprungen", "info");
               return;
               }
    		for (let i in obj) {
                if (i === 'packData' && Array.isArray(obj[i])) {
                    const ts = obj.timestamp ? obj.timestamp * 1000 : Date.now();
                    for (const pack of obj[i]) {
                        if (!pack.sn) continue;
                        const sn = pack.sn;
                        const path = `${id}.packData.${sn}`;
     
                        if (!existsObject(path)) {
                            setObject(path, {
                                type: 'folder',
                                common: { name: sn },
                                native: {},
                            });
                        }
     
                        for (let [key, val] of Object.entries(pack)) {
                            const statePath = `${path}.${key}`;
                            switch (key) {
                                case 'batcur':
                                    val = (val << 16 >> 16) / 10;
                                    if (existsState(statePath)) {
                                        setState(statePath, val, true);;
                                    } else {
                                        createState(statePath, val, {
                                            name: 'Battery Current',
                                            type: 'number',
                                            desc: 'battery current',
                                            role: 'value',
                                            read: true,
                                            write: false,
                                            unit: 'A',
                                        });
                                    }
                                    break;
    							case 'heatState':
                                    if (existsState(statePath)) {
                                        setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                            name: 'Heat State, 0: Not heating, 1: heating',
                                            type: 'number',
                                            role: 'value',
                                            read: true,
                                            write: false,
                                        });
                                    }
                                    break;		
    							case 'maxTemp':
                                    val = (val - 2731) / 10;
                                    if (existsState(statePath)) {
                                        setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                            name: 'Highest Akku Temperature',
                                            type: 'number',
                                            desc: 'maximum temperature',
                                            role: 'value',
                                            read: true,
                                            write: false,
                                            unit: '°C',
                                        });
                                    }
                                    break;
                                case 'maxVol':
                                    val = val / 100;
                                    if (existsState(statePath)) {
                                        setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                            name: 'Highest Cell Voltage',
                                            type: 'number',
                                            desc: 'highest cell voltage',
                                            role: 'value',
                                            read: true,
                                            write: false,
                                            unit: 'V',
                                        });
                                    }
                                    break;
                                case 'minVol':
                                    val = val / 100;
                                    if (existsState(statePath)) {
                                        setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                            name: 'Lowest Cell Voltage',
                                            type: 'number',
                                            desc: 'lowest cell voltage',
                                            role: 'value',
                                            read: true,
                                            write: false,
                                            unit: 'V',
                                        });
                                    }
                                    break;
    							case 'packType':
                                    if (existsState(statePath)) {
                                        setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                            name: 'packType',
                                            type: 'number',
                                            role: 'value',
                                            read: true,
                                            write: false,
                                        });
                                    }
                                    break;
    							case 'power':
                                    if (existsState(statePath)) {
                                        setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                            name: 'Battery Power',
                                            type: 'number',
                                            role: 'value',
                                            read: true,
                                            write: false,
                                            unit: 'W',
                                        });
                                    }
    								break;
    							case 'sn':
                                const batType = getBatteryType(val, pack.model);
                                // Modelltyp als Datenpunkt setzen/erstellen
                                const modelPath = `${path}.model`;
                                if (existsState(modelPath)) {
    								setState(modelPath, batType, true);
                                    } else {
                                        createState(modelPath, batType, {
                                        name: 'Battery Model',
                                        type: 'string',
                                        role: 'text',
                                        read: true,
                                        write: false,
                                        });
                                       }
                                    break;
    							case 'socLevel':
                                    if (existsState(statePath)) {
                                        setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                            name: 'Battery SoC Level',
                                            type: 'number',
                                            role: 'value',
                                            read: true,
                                            write: false,
                                            unit: '%',
                                        });
                                    }
    								break;
    							case 'softVersion':
                                    if (existsState(statePath)) {
                                        setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                            name: 'Battery Software Version',
                                            type: 'number',
                                            role: 'value',
                                            read: true,
                                            write: false,
                                        });
                                    }
    								break;
    							case 'state':
                                    if (existsState(statePath)) {
                                        setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                            name: 'Battery, 0: Standby, 1: Charging, 2: Discharging',
                                            type: 'number',
                                            role: 'value',
                                            read: true,
                                            write: false,
                                        });
                                    }
    								break;	
                                case 'totalVol':
                                    val = val / 100;
                                    if (existsState(statePath)) {
                                        setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                            name: 'Total Voltage',
                                            type: 'number',
                                            desc: 'total voltage',
                                            role: 'value',
                                            read: true,
                                            write: false,
                                            unit: 'V',
                                        });
                                    }
                                    break;
                                default:
                                    if (existsState(statePath)) {
                                        setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                            name: key,
                                            type: typeof val,
                                            role: 'value',
                                            read: true,
                                            write: false,
                                        });
                                    }
                                    break;
                            }
                        }
                    }
                } else {
                    const ts = Date.now();
                    const statePath = `${id}.${i}`;
                    let val = obj[i];
     
                    switch (i) {
                        case 'BatVolt':
                            val = val / 100;
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                            } else {
                                createState(statePath, val, {
                                    name: 'Battery Voltage',
                                    type: 'number',
                                    desc: 'battery voltage',
                                    role: 'value',
                                    read: true,
                                    write: false,
                                    unit: 'V',
                                });
                            }
                            break;
    					case 'chargeMaxLimit':
                            val = val / 10;
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                            } else {
                                createState(statePath, val, {
                                    name: 'maximum Charge Limit',
                                    type: 'number',
                                    desc: 'Battery Charge Limit Maximum',
                                    role: 'value',
                                    read: true,
                                    write: false,
                                    unit: '%',
                                });
                            }
                            break;
                        case 'acMode':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                            } else {
                                createState(statePath, val, {
                                    name: 'acMode, 1: input mode / 2: output mode',
                                    type: 'number',
                                    desc: '1: charging / 2: discharging',
                                    role: 'value',
                                    read: true,
                                    write: false,
                                });
                            }
                            break;
    					case 'dataReady':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                            } else {
                                createState(statePath, val, {
                                    name: 'Data Ready, 0: Not ready, 1: Ready',
                                    type: 'number',
                                    role: 'value',
                                    read: true,
                                    write: false,
                                });
                            }
                            break;	
    					case 'dcStatus':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                            } else {
                                createState(statePath, val, {
                                    name: 'dcStatus, 0: Stopped, 1: Battery input, 2: Battery output',
                                    type: 'number',
                                    role: 'value',
                                    read: true,
                                    write: false,
                                });
                            }
                            break;						
    					case 'electricLevel':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                            } else {
                                createState(statePath, val, {
                                    name: 'Total Battery Charge Level',
                                    type: 'number',
                                    desc: 'SoC',
                                    role: 'value',
                                    read: true,
                                    write: false,
                                    unit: '%',
                                });
                            }
                            break;
                        case 'gridInputPower':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                            } else {
                                createState(statePath, val, {
                                    name: 'Grid Input Power to Battery',
                                    type: 'number',
                                    role: 'value',
                                    read: true,
                                    write: false,
                                    unit: 'W',
                                });
                            }
                            break;
                        case 'gridReverse':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                            } else {
                                createState(statePath, val, {
                                    name: '0: Disabled, 1: Allowed reverse flow, 2: Forbidden reverse flow',
                                    type: 'number',
                                    role: 'value',
                                    read: true,
                                    write: false,
                                });
                            }
                            break;
                        case 'gridStandard':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                            } else {
                                createState(statePath, val, {
                                    name: 'Grid connection standard 0: Germany 1: France 2: Austria',
                                    type: 'number',
                                    role: 'value',
                                    read: true,
                                    write: false,
                                });
                            }
                            break;
                        case 'gridState':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                            } else {
                                createState(statePath, val, {
                                    name: 'GridState, 0: Not connected, 1: Connected',
                                    type: 'number',
                                    role: 'value',
                                    read: true,
                                    write: false,
                                });
                            }
                            break;									
                        case 'heatState':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                            } else {
                                createState(statePath, val, {
                                    name: 'Heat State, 0: Not heating, 1: heating',
                                    type: 'number',
                                    role: 'value',
                                    read: true,
                                    write: false,
                                });
                            }
                            break;		
    					case 'hyperTmp':
                            val = (val - 2731) / 10.0;
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                        name: 'Enclosure Temperature',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
                                        unit: '°C',
                                        });
                                    }
                            break;
    					case 'inputLimit':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                        name: 'AC charging power limit to Battery',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
                                        unit: 'W',
                                        });
                                    }
                            break;
    					case 'inverseMaxPower': 
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                        name: 'Device Maximum Output Power Limit',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
                                        unit: 'W',
                                        });
                                    }
                            break;
    					case 'minSoc':
                            val = val / 10;
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                        name: 'min SoC',
                                        type: 'number',
                                        desc: 'minimum Battery SoCset',
                                        role: 'value',
                                        read: true,
                                        write: false,
                                        unit: '%',
                                        });
                                    }
                            break;
    					case 'outputHomePower':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
    									createState(statePath, val, {
                                        name: 'outputHomePower',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
    							        unit: 'W',
                                        });
    								}
                            break;
    					case 'outputLimit':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
    									createState(statePath, val, {
                                        name: 'Output power limit',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
    							        unit: 'W',
                                        });
    								}
                            break;
    					case 'outputPackPower':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
    									createState(statePath, val, {
                                        name: 'Output power to battery pack (charging)',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
    							        unit: 'W',
                                        });
    								}
                            break;
    					case 'packInputPower':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
    									createState(statePath, val, {
                                        name: 'Battery pack input power (discharging)',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
    							        unit: 'W',
                                        });
    								}
                            break;
    					case 'packNum':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
    									createState(statePath, val, {
                                        name: 'Number of battery packs',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
                                        });
    								}
                            break;
    					case 'packState':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
    									createState(statePath, val, {
                                        name: 'Battery State, 0: Standby, 1: Charging, 2: Discharging',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
                                        });
    								}
                            break;
    					case 'pass':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
    									createState(statePath, val, {
                                        name: 'Bypass, 0: No, 1: Yes',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
                                        });
    								}
                            break;
    					case 'pvStatus':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
    									createState(statePath, val, {
                                        name: 'PV State producing, 0: Stopped, 1: Running',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
                                        });
    								}
                            break;	
    					case 'remainOutTime':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
    									createState(statePath, val, {
                                        name: 'Estimated discharge time in minutes, if not predictable: 59940',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
    									unit: 'min',
                                        });
    								}
                            break;		
    					case 'reverseState':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
    									createState(statePath, val, {
                                        name: 'Reverse flow, 0: No, 1: Reverse flow',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
                                        });
    								}
                            break;			
    					case 'rssi':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
    									createState(statePath, val, {
                                        name: 'Received Signal Strength Indicator',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
    									unit: 'dBm',
                                        });
    								}
                            break;
    					case 'smartMode':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
    									createState(statePath, val, {
                                        name: '1: parameter written to RAM / 0: parameter is written to flash.',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
                                        });
    								}
                            break;		
    					case 'socLimit':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                        name: 'socLimit-Info 0: normal, 1: Charge limit reached, 2: Discharge limit reached',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
                                        });
                                    }
                            break;
    					case 'socSet':
                            val = val / 10;
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                        name: 'max SoC',
                                        type: 'number',
                                        desc: 'maximum Battery SoCset',
                                        role: 'value',
                                        read: true,
                                        write: false,
                                        unit: '%',
                                        });
                                    }
                            break;
    					case 'socStatus':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                        name: 'Info of Calibrating, 0: No / 1: Calibrating',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
                                        });
                                    }
                            break;
    					case 'solarInputPower':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                        name: 'Total Solar Input Power',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
    									unit: 'W',
                                        });
                                    }
                            break;
                        case 'solarPower1':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                        name: 'Solar line 1 input power',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
    									unit: 'W',
                                        });
                                    }
                            break;
                        case 'solarPower2':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                        name: 'Solar line 2 input power',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
    									unit: 'W',
                                        });
                                    }
                            break;
                        case 'solarPower3':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                        name: 'Solar line 3 input power',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
    									unit: 'W',
                                        });
                                    }
                            break;
                        case 'solarPower4':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                        name: 'Solar line 4 input power',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
    									unit: 'W',
                                        });
                                    }
                            break;
                        case 'solarPower5':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                        name: 'Solar line 5 input power',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
    									unit: 'W',
                                        });
                                    }
                            break;
                        case 'solarPower6':
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                                    } else {
                                        createState(statePath, val, {
                                        name: 'Solar line 6 input power',
                                        type: 'number',
                                        role: 'value',
                                        read: true,
                                        write: false,
    									unit: 'W',
                                        });
                                    }
                            break;
                        case 'timestamp':
                            const timestampVal = obj[i];
                            const timestampFormatted = formatTime(timestampVal);
                            if (existsState(statePath)) setState(statePath, timestampVal, true);
                            else createState(statePath, timestampVal, {
                                name: 'unix timestamp (timestamp)',
                                type: 'number',
                                desc: 'unix timestamp in Seconds since Jan 01 1970 (UTC)',
                                role: 'value',
                                read: true,
                                write: false,
                            });
                            if (existsState(id + '.timeUpdateTimestamp')) setState(id + '.timeUpdateTimestamp', timestampFormatted, true);
                            else createState(id + '.timeUpdateTimestamp', timestampFormatted, {
                                name: 'TimeUpdate (timestamp)',
                                type: 'string',
                                desc: 'unix timestamp in readable Format (timestamp)',
                                read: true,
                                write: false,
                            });
                            break;
                        case 'ts':
                            const tsVal = obj[i];
                            const tsFormatted = formatTime(tsVal);
                            if (existsState(statePath)) setState(statePath, tsVal, true);
                            else createState(statePath, tsVal, {
                                name: 'unix timestamp (ts)',
                                type: 'number',
                                desc: 'unix timestamp in Seconds since Jan 01 1970 (UTC)',
                                role: 'value',
                                read: true,
                                write: false,
                            });
                            if (existsState(id + '.timeUpdateTs')) setState(id + '.timeUpdateTs', tsFormatted, true);
                            else createState(id + '.timeUpdateTs', tsFormatted, {
                                name: 'TimeUpdate (ts)',
                                type: 'string',
                                desc: 'unix timestamp in readable Format (ts)',
                                read: true,
                                write: false,
                            });
                            break;			
                        default:
                            if (existsState(statePath)) {
                                setState(statePath, val, true);
                            } else {
                                createState(statePath, val, {
                                    name: i,
                                    type: typeof val,
                                    role: 'value',
                                    read: true,
                                    write: false,
                                });
                            }
                            break;
                    }
                }
            }
        } catch (e) {
            log(`Error in iter: ${e}`, 'info');
        }
    }
    

    Historisch:
    Frühere Versionen der Scripte sind hier (im Spoiler) zu finden.
    Die kompletten Scripte sind zu groß für diesen Post, daher habe ich sie dort ausgelagert.

    Ich schreibe meistens sehr direkt – bitte nicht falsch verstehen, es ist nie böse gemeint. Das ist einfach mein Stil und niemals abwertend gemeint.

    M 1 Reply Last reply
    4
    • maxclaudiM maxclaudi

      Für alle mit den neuen Geräten:

      • SolarFlow 800
      • SolarFlow 800 Pro
      • SolarFlow 2400 AC

      Immer wieder taucht die Frage auf z.B. (z. B. Michi 0 ), wie man den SmartMode:1 setzen kann.
      Bisher wurde das noch nirgends wirklich anwenderfreundlich beantwortet.

      Hier nun die Lösung:

      Mit diesem Script können nicht nur smartMode:1 und die MQTT-Verbindung (de-)aktiviert werden, sondern auch einiges mehr.


      Update 16.10.2025 1935h– Neues Script
      ioBroker JavaScript: Zendure SolarFlow 800 Pro (SF2400AC) via zenSDK HTTP
      Kein Hack, dafür wurde die offizielle zenSDK verwendet.
      plattformunabhängig - Linux, Windows

      Jetzt können auch Commands gesetzt werden, wie in einem Adapter. 🙂

      Muss man nicht nutzen, kann man aber zusätzlich einsetzen – z. B. falls MQTT mal Probleme macht oder wenn weitere set-Befehle dazukommen sollen.

      Hinweis:
      Damit neue Datenpunkte automatisch aus dem JSON erstellt werden:
      → Instanzen → JavaScript-Adapter → Allgemeine Einstellungen → „Enable command setObject“ aktivieren!

      So viel wie möglich wurde ohne Gerät getestet und simuliert.
      Extra ohne Schleifen und strukturiert geschrieben, damit jeder das Script nachvollziehen kann.

      Intervalle

      • intervalGet sollte nicht < 30 s gesetzt werden – das bringt keinen Mehrwert.
      • intervalMqtt = 300 s ist völlig ausreichend, um zu prüfen, ob MQTT verbunden ist.

      Eigene Daten anpassen
      Zendure Gerät:

      const IP = "192.168.177.103";   // IP des Zendure Geräts
      const SN = "EXXXXXXXXXXXXX0";   // Seriennummer
      

      Intervalle für Abfragen (in Sekunden):

      const intervalGet = 60;   // SmartMode (default: 60 s, nicht < 30)
      const intervalMqtt = 300; // MQTT-Status (default: 300 s, > SmartMode)
      

      MQTT-Broker Konfiguration:

      const mqttBrokerIp = "192.168.177.200"; // IP MQTT Broker (auch in App eingestellt)
      const mqttPort = 1883;                  // Port MQTT Broker (auch in App eingestellt)           
      const mqttUsername = "Daisy";           // MQTT Username
      const mqttPassword = "coco";            // MQTT Passwort
      
      

      Maximale Input-/Output-Limits:

      // Maximum Input-Limit
      const maxInputLimit = 800;   // SF800Pro
      //const maxInputLimit = 2400; // SF2400AC
      
      // Maximum Output-Limit
      const maxOutputLimit = 800;   // SF800Pro
      //const maxOutputLimit = 2400; // SF2400AC
      
      

      Hinweise

      • wichtig: wenn MQTT über dieses Script eingeschaltet wird, hat es vermutlich Vorrang!
        Es werden ggf. andere MQTT-Einstellungen in der App durch das Script überschrieben.

      • Wer meine Arbeit nützlich findet und sich bedanken möchte:
        Ein Klick auf den Pfeil nach oben (unten am Post, neben Zitieren) reicht völlig. Das ist für mich mehr als genug. 🙂

      • Dieser erste Post wird bei Änderungen editiert, damit das aktuelle Script immer direkt hier auffindbar ist.

      • Beschreibung / Anleitung
        Hinweise zur Benutzung, der aktuellen Version des Scripts und zusätzliche Tipps, siehe:
        Post im Thread

      Viel Spaß! ☀


      //
      // ioBroker JavaScript: Zendure SolarFlow 800 Pro (SF2400AC) via zenSDK HTTP
      // by maxclaudi 2025.10.16 19:35h for ioBroker Forum
      //------------------------------------------------------------------------------------
      // konfiguration
      //
      // Hinweis bei mehreren Zendure-Geräten:
      // - Für jedes Gerät ein eigenes Script mit individueller Konfiguration verwenden!
      //   → IP-Adresse
      //   → Seriennummer (SN)
      //   → MQTT-Daten (Broker, Port, Benutzer, Passwort)
      //   → maxInputLimit / maxOutputLimit (abhängig vom Gerätetyp)
      // - Intervalle (Standard): intervalGet = 60s, intervalMqtt = 300s – können gleich bleiben
      //
      // Empfehlung:
      //   • 3 Geräte: völlig unkritisch
      //   • 4 Geräte: problemlos möglich
      //   • mehr als 4: nicht empfohlen
      //
      //
      // Damit neue Datenpunkte automatisch aus dem JSON erstellt werden:
      // -> Instanzen -> javascript-Adapter -> Allgemeine Einstellungen -> Enable command"setObject“ aktivieren!
      //
      //------------------------------------------------------------------------------------
      // Intervalle für Abfragen (Sekunden)
      const intervalGet = 60;                 // sek SmartMode   (default:  60 sek, not <30)
      const intervalMqtt = 300;               // sek MQTT-Status (default: 300 sek, > SmartMode)
       
      // IP und Seriennummer Zendure Gerät
      const IP = "192.168.40.111";           // IP des Zendure Geräts
      const SN = "EXXXXXXXXXXXXX0";           // Seriennummer
       
      // MQTT Broker Konfiguration
      const mqttBrokerIp = "192.168.40.200";  // IP MQTT Broker und in App eingestellt 
      const mqttPort = 1883;                // PORT MQTT Broker und in App eingestellt           
      const mqttUsername = "Daisy";           // MQTT Username
      const mqttPassword = "coco";            // MQTT Passwort
       
      //maximum inputLimit SF800PRO: 800W / SF2400AC: 2400W
      const maxInputLimit = 1000; //SF800Pro
      //const maxInputLimit = 2400; //SF2400AC
       
      //maximum outputLimit SF800PRO: 800W / SF2400AC: 2400W
      const maxOutputLimit = 800; //SF800Pro
      //const maxOutputLimit = 2400; //SF2400AC
      //------------------------------------------------------------------------------------ 
      //------------------------------------------------------------------------------------
      // Datenpunkte
      const folderZendureApi = '0_userdata.0.zendure.' + SN;
      //------------------------------------------------------------------------------------
      const dpSmartModeInfo              = folderZendureApi + ".zendureSmartMode.smartModeInfo";
      const dpSetSmartMode               = folderZendureApi + ".zendureSmartMode.setSmartMode";
      const dpSetSmartModeResult         = folderZendureApi + ".zendureSmartMode.setResult";
      const dpTimestamp                  = folderZendureApi + ".zendureSmartMode.timestamp";
       
      const dpMqttConnectInfo            = folderZendureApi + ".zendureMqttState.mqttConnectInfo";
      const dpSetMqttConnect             = folderZendureApi + ".zendureMqttState.setMqttConnect";
      const dpSetMqttConnectResult       = folderZendureApi + ".zendureMqttState.setMqttConnectResult";
      const dpMqttTimestamp              = folderZendureApi + ".zendureMqttState.mqttTimestamp";
       
      //set dp
      const dpSetAcMode                  = folderZendureApi + ".control.acMode.setAcMode";
      const dpSetAcModeResult            = folderZendureApi + ".control.acMode.setAcModeResult";
      const dpSetAcModeResultTS          = folderZendureApi + ".control.acMode.setAcModeResultTs";
       
      const dpSetInputLimit              = folderZendureApi + ".control.inputLimit.setInputLimit";
      const dpSetInputLimitResult        = folderZendureApi + ".control.inputLimit.setInputLimitResult";
      const dpSetInputLimitResultTS      = folderZendureApi + ".control.inputLimit.setInputLimitResultTs";
       
      const dpSetOutputLimit             = folderZendureApi + ".control.outputLimit.setOutputLimit";
      const dpSetOutputLimitResult       = folderZendureApi + ".control.outputLimit.setOutputLimitResult";
      const dpSetOutputLimitResultTS     = folderZendureApi + ".control.outputLimit.setOutputLimitResultTs";
       
      const dpSetSocSet                  = folderZendureApi + ".control.socSet.setSocSet";
      const dpSetSocSetResult            = folderZendureApi + ".control.socSet.setSocSetResult";
      const dpSetSocSetResultTS          = folderZendureApi + ".control.socSet.setSocSetResultTs";
       
      const dpSetMinSoc                  = folderZendureApi + ".control.minSoc.setMinSoc";
      const dpSetMinSocResult            = folderZendureApi + ".control.minSoc.setMinSocResult";
      const dpSetMinSocResultTS          = folderZendureApi + ".control.minSoc.setMinSocResultTs";
       
      const dpSetGridReverse             = folderZendureApi + ".control.gridReverse.setGridReverse";
      const dpSetGridReverseResult       = folderZendureApi + ".control.gridReverse.setGridReverseResult";
      const dpSetGridReverseResultTS     = folderZendureApi + ".control.gridReverse.setGridReverseResultTs";
       
      const dpSetGridStandard            = folderZendureApi + ".control.gridStandard.setGridStandard";
      const dpSetGridStandardResult      = folderZendureApi + ".control.gridStandard.setGridStandardResult";
      const dpSetGridStandardResultTS    = folderZendureApi + ".control.gridStandard.setGridStandardResultTs";
      
      const dpSetInverseMaxPower         = folderZendureApi + ".control.inverseMaxPower.setInverseMaxPower";
      const dpSetInverseMaxPowerResult   = folderZendureApi + ".control.inverseMaxPower.setInverseMaxPowerResult";
      const dpSetInverseMaxPowerResultTS = folderZendureApi + ".control.inverseMaxPower.setInverseMaxPowerResultTs"; 
      //------------------------------------------------------------------------------------
      const http = require("http");           // Node.js http Standardmodul
      //------------------------------------------------------------------------------------
      
      // Mapping: Payload key, optional transformation, result and timestamp dp
      const dpMap = {
          [dpSetAcMode]:          { key: "acMode", result: dpSetAcModeResult, resultTS: dpSetAcModeResultTS, minNormal: 1, maxNormal: 2 },
          [dpSetInputLimit]:      { key: "inputLimit", result: dpSetInputLimitResult, resultTS: dpSetInputLimitResultTS, minNormal: 0, maxNormal: maxInputLimit },
          [dpSetOutputLimit]:     { key: "outputLimit", result: dpSetOutputLimitResult, resultTS: dpSetOutputLimitResultTS, minNormal: 0, maxNormal: maxOutputLimit },
          [dpSetSocSet]:          { key: "socSet", transform: v => v*10, result: dpSetSocSetResult, resultTS: dpSetSocSetResultTS, minNormal: 70, maxNormal: 100 },
          [dpSetMinSoc]:          { key: "minSoc", transform: v => v*10, result: dpSetMinSocResult, resultTS: dpSetMinSocResultTS, minNormal: 5, maxNormal: 50 },
          [dpSetGridReverse]:     { key: "gridReverse", result: dpSetGridReverseResult, resultTS: dpSetGridReverseResultTS, minNormal: 0, maxNormal: 2 },
          [dpSetGridStandard]:    { key: "gridStandard", result: dpSetGridStandardResult, resultTS: dpSetGridStandardResultTS, minNormal: 0, maxNormal: 2 },
          [dpSetInverseMaxPower]: { key: "inverseMaxPower", result: dpSetInverseMaxPowerResult, resultTS: dpSetInverseMaxPowerResultTS, minNormal: 600, maxNormal: maxOutputLimit }
      };
       
      // Queue HTTP
      const curlQueue = [];
      let curlRunning = false;
       
      function runQueue() {
          if (curlRunning || curlQueue.length === 0) return;
          const task = curlQueue.shift();
          curlRunning = true;
          task.fn(() => {
              curlRunning = false;
              runQueue();
          });
      }
       
      //dp have to exist - get
      function delay(ms) {
          return new Promise(resolve => setTimeout(resolve, ms));
      }
       
      // dp create
      createState(dpSmartModeInfo, 0, {
              name: "SmartMode Info",
              type: "number",
              role: "state",
              read: true,
              write: false,
              min: 0,
              max: 1
              }, async () => {
                 await delay(1);
                 getReport();
      });
       
      createState(dpSetSmartMode, -1, {
             name: "SmartMode Set",
      	   type: "number",
      	   role: "state",
      	   read: true,
      	   write: true,
      	   min: -1,
      	   max: 1
      }, () => {});
       
      createState(dpSetSmartModeResult, "", {
             name: "SmartMode Set Result",
      	   type: "string",
      	   role: "info",
      	   read: true,
      	   write: false
      }, () => {});
       
      createState(dpTimestamp, "", {
             name: "Timestamp",
      	   type: "string",
      	   role: "info",
      	   read: true,
      	   write: false
             }, async () => {
                 await delay(1);
      });
       
      createState(dpMqttConnectInfo, 0, {
          name: "MQTT Connect Info",
          type: "number", 
          role: "state",
          read: true,
          write: false,
          min: 0,
          max: 1
          }, async () => {
             await delay(1);
          getMqttStatus();
      });
       
      createState(dpSetMqttConnect, -1, {
             name: "MQTT Connect Set",
      	   type: "number",
      	   role: "state",
      	   read: true,
      	   write: true,
      	   min: -1,
      	   max: 1
      }, () => {});
       
      createState(dpSetMqttConnectResult, "", {
             name: "MQTT Connect Result",
      	   type: "string",
      	   role: "info",
      	   read: true,
      	   write: false
      }, () => {});
       
      createState(dpMqttTimestamp, "", {
             name: "MQTT Timestamp",
      	   type: "string",
      	   role: "info",
      	   read: true,
      	   write: false
      }, async () => { await delay(1); });
       
      // set > result ts dp
      // acMode
      createState(dpSetAcMode, -1, {
             name: "set acMode, 1: charging 2: discharging",
      	   desc: "1: Input, 2: Output",
      	   type: "number",
      	   role: "state",
      	   read: true,
      	   write: true,
      	   min: -1,
      	   max: 2
      }, () => {});
       
      createState(dpSetAcModeResult, "", {
          name: "AcMode Set Result",
          type: "string",
          role: "info",
          read: true,
          write: false
      }, () => {});
       
      createState(dpSetAcModeResultTS, "", {
          name: "AcMode Set Result Timestamp",
          type: "string",
          role: "info",
          read: true,
          write: false
      }, () => {});
       
      // inputLimit
      createState(dpSetInputLimit, -1, {
             name: "set inputLimit",
      	   desc: "AC charging power limit",
      	   type: "number",
      	   role: "state",
      	   read: true,
      	   write: true,
      	   unit: 'W',
      	   min: -1,
      	   max: maxInputLimit //SF800Pro: 1000W, SF2400AC: 2400W
      }, () => {});
       
      createState(dpSetInputLimitResult, "", {
          name: "InputLimit Set Result",
          type: "string",
          role: "info",
          read: true,
          write: false
      }, () => {});
       
      createState(dpSetInputLimitResultTS, "", {
          name: "InputLimit Set Result Timestamp",
          type: "string",
          role: "info",
          read: true,
          write: false
      }, () => {});
       
      // outputLimit
      createState(dpSetOutputLimit, -1, {
             name: "set outputLimit",
      	   desc: "Output power limit",
      	   type: "number",
      	   role: "state",
      	   read: true,
      	   write: true,
      	   unit: 'W',
      	   min: -1,
      	   max: maxOutputLimit //SF800Pro: 800W, SF2400AC: 2400W
      }, () => {});
       
      createState(dpSetOutputLimitResult, "", {
          name: "OutputLimit Set Result",
          type: "string",
          role: "info",
          read: true,
          write: false
      }, () => {});
       
      createState(dpSetOutputLimitResultTS, "", {
          name: "OutputLimit Set Result Timestamp",
          type: "string",
          role: "info",
          read: true,
          write: false
      }, () => {});
       
      // socSet
      createState(dpSetSocSet, -1, {
             name: "set socSet 70-100%",
      	   desc: "Stop charging at battery percentage",
      	   type: "number",
      	   role: "state",
      	   read: true,
      	   write: true,
      	   unit: '%',
      	   min: -1,
      	   max: 100
      }, () => {});
       
      createState(dpSetSocSetResult, "", {
          name: "SocSet Set Result",
          type: "string",
          role: "info",
          read: true,
          write: false
      }, () => {});
       
      createState(dpSetSocSetResultTS, "", {
          name: "SocSet Set Result Timestamp",
          type: "string",
          role: "info",
          read: true,
          write: false
      }, () => {});
       
      // minSoc
      createState(dpSetMinSoc, -1, {
             name: "set minSoc 0-50%",
      	   desc: "Stop discharging at battery percentage",
      	   type: "number",
      	   role: "state",
      	   read: true,
      	   write: true,
      	   unit: '%',
      	   min: -1,
      	   max: 50
      }, () => {});
       
      createState(dpSetMinSocResult, "", {
          name: "MinSoc Set Result",
          type: "string",
          role: "info",
          read: true,
          write: false
      }, () => {});
       
      createState(dpSetMinSocResultTS, "", {
          name: "MinSoc Set Result Timestamp",
          type: "string",
          role: "info",
          read: true,
          write: false
      }, () => {});
       
      // gridReverse
      createState(dpSetGridReverse, -1, {
             name: "setGridReverse, 0: off, 1: rev. 2: no rev",
      	   desc: "0: Disabled, 1: Allowed reverse flow, 2: Forbidden reverse flow",
      	   type: "number",
      	   role: "state",
      	   read: true,
      	   write: true,
      	   min: -1,
      	   max: 2
      }, () => {});
       
      createState(dpSetGridReverseResult, "", {
          name: "GridReverse Set Result",
          type: "string",
          role: "info",
          read: true,
          write: false
      }, () => {});
       
      createState(dpSetGridReverseResultTS, "", {
          name: "GridReverse Set Result Timestamp",
          type: "string",
          role: "info",
          read: true,
          write: false
      }, () => {});
       
      // gridStandard
      createState(dpSetGridStandard, -1, {
             name: "setGridStandard, 0: Germany / 2: France",
      	   desc: "Grid connection standard 0: Germany 1: France 2: Austria",
      	   type: "number",
      	   role: "state",
      	   read: true,
      	   write: true,
      	   min: -1,
      	   max: 2
      }, () => {});
       
      createState(dpSetGridStandardResult, "", {
          name: "GridStandard Set Result",
          type: "string",
          role: "info",
          read: true,
          write: false
      }, () => {});
       
      createState(dpSetGridStandardResultTS, "", {
          name: "GridStandard Set Result Timestamp",
          type: "string",
          role: "info",
          read: true,
          write: false
      }, () => {});
      
      // inverseMaxPower
      createState(dpSetInverseMaxPower, -1, {
             name: "set inverseMaxPower",
      	   desc: "Maximum output power limit",
      	   type: "number",
      	   role: "state",
      	   read: true,
      	   write: true,
      	   unit: 'W',
      	   min: -1,
      	   max: maxOutputLimit
      }, () => {});
       
      createState(dpSetInverseMaxPowerResult, "", {
          name: "inverseMaxPower Set Result",
          type: "string",
          role: "info",
          read: true,
          write: false
      }, () => {});
       
      createState(dpSetInverseMaxPowerResultTS, "", {
          name: "inverseMaxPower Set Result Timestamp",
          type: "string",
          role: "info",
          read: true,
          write: false
      }, () => {});
      
      // intervals start																											  
      setInterval(getReport, intervalGet*1000);
      setInterval(getMqttStatus, intervalMqtt*1000);
       
      // trigger smartMode
      on({id: dpSetSmartMode, ack:false}, obj => {
          const val = parseInt(obj.state.val,10);
          if(val===0||val===1) setSmartMode(val);
      });
       
      // trigger MQTT connect
      on({id: dpSetMqttConnect, ack:false}, obj => {
          const val = parseInt(obj.state.val,10);
          if(val===0||val===1) setMqttConnect(val);
      });
       
      // trigger dp set
      Object.keys(dpMap).forEach(id => {
          on({ id: id, ack: false }, obj => {
              const val = obj.state.val;
              const { minNormal, maxNormal } = dpMap[id];
      
              // check values
              if (val >= minNormal && val <= maxNormal) {
      																 
                  setControlDP(id, val);  // Transformation
              } else {
                  log(`Value ${val} for ${id} is not allowed`, 'warn');
              }
          });
      });
      
      // time format
      function formatTime(ts) {
      	// ts unix sek							
          const d = new Date(ts * 1000);
          const pad = n => n.toString().padStart(2, "0");
          return `${pad(d.getDate())}.${pad(d.getMonth()+1)}.${d.getFullYear().toString().slice(-2)} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
      }
      
      // helper HTTP-error
      function handleHttpError(context, err, options) {
          const transient = [
              "EHOSTUNREACH", "ECONNRESET", "ECONNREFUSED", "ETIMEDOUT",
              "socket hang up", "ENETUNREACH", "EAI_AGAIN", "ENOTFOUND"
          ];
      
          const msg = err && err.message ? err.message : String(err);
          const isTransient = transient.some(code => msg.includes(code));
      
          //info_error
      	//log(`${context}: ${isTransient ? "war vorübergehend im Intervall nicht erfolgreich:" : "Warnung"} (${msg})`, isTransient ? "info" : "warn");
          log(`${context}: ${isTransient ? "war vorübergehend im Intervall nicht erfolgreich:" : "Warnung"} (${msg})`, "info");
      
          // set Timestamp
          if (options && options.timestamp) {
              setState(options.timestamp, formatTime(Math.floor(Date.now() / 1000)), true);
          }
      }
      
      // smartMode GET report
      function getReport() {
          curlQueue.push({
              fn: async done => {      //async
                  const options = {
                      hostname: IP,
                      port: 80,
                      path: "/properties/report",
                      method: "GET",
                      timeout: 5000
                  };
                  const req = http.request(options, res => {
                      let data = "";
                      res.on("data", chunk => data += chunk);
                      res.on("end", async () => {     // async
                          try {
                              const json = JSON.parse(data);
                              if (json.properties && typeof json.properties.smartMode !== "undefined") {
                                  setState(dpSmartModeInfo, json.properties.smartMode, true);
                                  setState(dpTimestamp, formatTime(Math.floor(Date.now() / 1000)), true);
                              }
                              //JSON
                              await processJson(json);
                          } catch (e) {
                              log("GET JSON Parse Fehler: " + e, "info"); //no valid JSON
                              setState(dpTimestamp, formatTime(Math.floor(Date.now() / 1000)), true);
                          }
                          done();
                      });
                  });
                  req.on("error", err => { 
                      handleHttpError("HTTP GET", err, { timestamp: dpTimestamp }); 
                      done(); 
                  });
                  req.end();
              }
          });
          runQueue();
      }
      
      // smartMode POST
      function setSmartMode(val) {
          curlQueue.push({
              fn: done => {
                  const payload = JSON.stringify({ sn: SN, properties: { smartMode: val } });
                  const options = {
                      hostname: IP,
                      port: 80,
                      path: "/properties/write",
                      method: "POST",
                      headers: {
                          "Content-Type": "application/json",
                          "Content-Length": Buffer.byteLength(payload)
                      },
                      timeout: 5000
                  };
      
                  const req = http.request(options, res => {
                      let data = "";
                      res.on("data", chunk => data += chunk);
      
                      res.on("end", () => {
                          let ok = false;
      
                          if (data) {
                              try {
                                  const json = JSON.parse(data);
                                  ok = json.success === true;
                              } catch (e) {
                                  ok = false; // no valid JSON
                              }
                          }
      					setState(dpSetSmartModeResult, ok ? `ok set ${val}` : `error set ${val}`, true);
                          setState(dpTimestamp, formatTime(Math.floor(Date.now() / 1000)), true);
      					setState(dpSetSmartMode, -1, true);
                          done();
                      });
                  });
      
                  req.on("error", err => {
                      handleHttpError("HTTP POST", err, { timestamp: dpTimestamp });
                      setState(dpSetSmartModeResult, `error set ${val}`, true);
                      setState(dpTimestamp, formatTime(Math.floor(Date.now() / 1000)), true);
      				setState(dpSetSmartMode, -1, true);
                      done();
                  });
      
                  req.write(payload);
                  req.end();
              }
          });
      
          runQueue();
      }
       
      // MQTT state GET
      function getMqttStatus() {
          curlQueue.push({
              fn: done => {
                  const options = {
                      hostname: IP,
                      port: 80,
                      path: "/rpc?method=HA.Mqtt.GetStatus",
                      method: "GET",
                      timeout: 5000
                  };
                  const req = http.request(options, res => {
                      let data = "";
                      res.on("data", chunk => data += chunk);
                      res.on("end", () => {
                          try {
                              const json = JSON.parse(data);
                              const state = json.connected ? 1 : 0;
                              setState(dpMqttConnectInfo, state, true);
                              setState(dpMqttTimestamp, formatTime(Math.floor(Date.now() / 1000)), true);
                          } catch (e) {
                              log(`MQTT JSON Parse Fehler: ${e}`, "info"); //no valid JSON
                              setState(dpMqttTimestamp, formatTime(Math.floor(Date.now() / 1000)), true);
                          }
                          done();
                      });
                  });
                  req.on("error", err => { 
                      handleHttpError("HTTP MQTT GET", err, { timestamp: dpMqttTimestamp }); 
                      done(); 
                  });
                  req.end();
              }
          });
          runQueue();
      }
       
      // MQTT POST
      function setMqttConnect(val) {
          curlQueue.push({
              fn: done => {
                  const enable = !!val;
                  const payload = JSON.stringify({
                      sn: SN,
                      method: "HA.Mqtt.SetConfig",
                      params: {
                          config: {
                              enable: enable,
                              server: mqttBrokerIp,
                              port: mqttPort,
                              protocol: "mqtt",
                              username: mqttUsername,
                              password: mqttPassword
                          }
                      }
                  });
      
                  const options = {
                      hostname: IP,
                      port: 80,
                      path: "/rpc",
                      method: "POST",
                      headers: {
                          "Content-Type": "application/json",
                          "Content-Length": Buffer.byteLength(payload)
                      },
                      timeout: 5000
                  };
      
                  const req = http.request(options, res => {
                      let data = "";
                      res.on("data", chunk => data += chunk);
      
                      res.on("end", () => {
                          let ok = false;
      
                          // HTTP 200 =  ok, Request succes
                          if (res.statusCode === 200) {
                              if (data) {
                                  try {
                                      const json = JSON.parse(data);
                                      ok = json.success === true;
                                  } catch (e) {
                                      ok = false; // no valid JSON
                                  }
                              }
                          }
      					setState(dpSetMqttConnectResult, ok ? `ok set ${val}` : `error set ${val}`, true);
                          setState(dpMqttTimestamp, formatTime(Math.floor(Date.now() / 1000)), true);
      					setState(dpSetMqttConnect, -1, true);
                          done();
                      });
                  });
      
                  req.on("error", err => {
                      handleHttpError("HTTP MQTT POST", err, { timestamp: dpMqttTimestamp });
                      setState(dpSetMqttConnectResult, `error set ${val}`, true);
                      setState(dpMqttTimestamp, formatTime(Math.floor(Date.now() / 1000)), true);
      				setState(dpSetMqttConnect, -1, true);
                      done();
                  });
      
                  req.write(payload);
                  req.end();
              }
          });
      
          runQueue();
      }
      
      // Generic POST function with result and timestamp handling
      function setControlDP(id, val) {
          if (!dpMap[id]) return;
          const { key, transform, result, resultTS } = dpMap[id];
          const value = transform ? transform(val) : val;
      
          curlQueue.push({
              fn: done => {
                  const payload = JSON.stringify({ sn: SN, properties: { [key]: value } });
                  const options = {
                      hostname: IP,
                      port: 80,
                      path: "/properties/write",
                      method: "POST",
                      headers: {
                          "Content-Type": "application/json",
                          "Content-Length": Buffer.byteLength(payload)
                      },
                      timeout: 5000
                  };
      
                  const req = http.request(options, res => {
                      let data = "";
                      res.on("data", chunk => data += chunk);
      
                      res.on("end", () => {
                          let ok = false;
      
                          // HTTP 200 = Connection established
                          if (res.statusCode === 200) {
                              if (data) {
                                  try {
                                      const json = JSON.parse(data);
                                      ok = json.success === true;
                                  } catch (e) {
                                      ok = false; // no valid JSON
                                  }
                              }
                          }
      
                          // Write success or failure to data points
                          if (result) {
                              const valueToSend = val;  // Wert, der gesendet wurde
      						setState(result, ok ? `ok set ${valueToSend}` : `error set ${valueToSend}`, true);
                          }
                          if (resultTS) setState(resultTS, formatTime(Math.floor(Date.now() / 1000)), true);
      					setState(id, -1, true);
                          done();
                      });
                  });
                  
      			req.on("error", err => {
                      handleHttpError("HTTP POST " + key, err, { timestamp: resultTS });
                      if (result) {
                          const valueToSend = val;  // Wert, der gesendet wurde
      					setState(result, `error set ${valueToSend}`, true);
                      }
                      if (resultTS) setState(resultTS, formatTime(Math.floor(Date.now() / 1000)), true);
      				setState(id, -1, true);
                      done();
                  });
                  req.write(payload);
                  req.end();
              }
          });
          runQueue();
      }
      
      //------------------------------------------------------------------------------------
      // JSON
      //------------------------------------------------------------------------------------
      async function processJson(obj) {
          try {
              if (!obj || !obj.product) return;
       
              const product = obj.product;
              const basePath = `${folderZendureApi}.${product}`;
       
              // create product folder if not exist
              if (!existsObject(basePath)) {
                  setObject(basePath, {
                      type: 'folder',
                      common: { name: product },
                      native: {},
                  });
              }
       
              // create main keys
              const mainKeys = ['timestamp', 'messageId', 'sn', 'version', 'product'];
              for (const key of mainKeys) {
                  if (obj[key] !== undefined) {
                      const statePath = `${basePath}.${key}`;
                      if (existsState(statePath)) {
                          setState(statePath, obj[key], true);
                      } else {
                          createState(statePath, obj[key], {
                              name: key,
                              type: typeof obj[key],
                              role: 'info',
                              read: true,
                              write: false,
                          });
                      }
                  }
              }
       
              // properties
              if (obj.properties) {
                  await iter(`${basePath}.properties`, obj.properties);
              }
       
              // PackData
              if (obj.packData && Array.isArray(obj.packData)) {
                  await iter(`${basePath}`, { packData: obj.packData, timestamp: obj.timestamp });
              }
          } catch (e) {
              log(`Error processing JSON: ${e}`, 'info');
          }
      }
       
      //------------------------------------------------------------------------------------
      // Battery
      //------------------------------------------------------------------------------------
      function getBatteryType(sn, model) {
        let batType = '';
        if (sn?.startsWith('A')) batType = 'AB1000';
        else if (sn?.startsWith('B')) batType = 'AB1000S';
        else if (sn?.startsWith('C')) batType = sn[3] === 'F' ? 'AB2000S' : sn[3] === 'E' ? 'AB2000X' : 'AB2000';
        else if (sn?.startsWith('F')) batType = 'AB3000X';
        if (model?.trim()) batType = model.trim();
        return batType || 'unknown';
      } 
      
      //------------------------------------------------------------------------------------
      // helper Iteration
      //------------------------------------------------------------------------------------
      async function iter(id, obj) {
          try {
      		if (!obj || typeof obj !== "object") {
                 //log("iter: Ungültiges oder leeres Objekt übersprungen", "info");
                 return;
                 }
      		for (let i in obj) {
                  if (i === 'packData' && Array.isArray(obj[i])) {
                      const ts = obj.timestamp ? obj.timestamp * 1000 : Date.now();
                      for (const pack of obj[i]) {
                          if (!pack.sn) continue;
                          const sn = pack.sn;
                          const path = `${id}.packData.${sn}`;
       
                          if (!existsObject(path)) {
                              setObject(path, {
                                  type: 'folder',
                                  common: { name: sn },
                                  native: {},
                              });
                          }
       
                          for (let [key, val] of Object.entries(pack)) {
                              const statePath = `${path}.${key}`;
                              switch (key) {
                                  case 'batcur':
                                      val = (val << 16 >> 16) / 10;
                                      if (existsState(statePath)) {
                                          setState(statePath, val, true);;
                                      } else {
                                          createState(statePath, val, {
                                              name: 'Battery Current',
                                              type: 'number',
                                              desc: 'battery current',
                                              role: 'value',
                                              read: true,
                                              write: false,
                                              unit: 'A',
                                          });
                                      }
                                      break;
      							case 'heatState':
                                      if (existsState(statePath)) {
                                          setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                              name: 'Heat State, 0: Not heating, 1: heating',
                                              type: 'number',
                                              role: 'value',
                                              read: true,
                                              write: false,
                                          });
                                      }
                                      break;		
      							case 'maxTemp':
                                      val = (val - 2731) / 10;
                                      if (existsState(statePath)) {
                                          setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                              name: 'Highest Akku Temperature',
                                              type: 'number',
                                              desc: 'maximum temperature',
                                              role: 'value',
                                              read: true,
                                              write: false,
                                              unit: '°C',
                                          });
                                      }
                                      break;
                                  case 'maxVol':
                                      val = val / 100;
                                      if (existsState(statePath)) {
                                          setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                              name: 'Highest Cell Voltage',
                                              type: 'number',
                                              desc: 'highest cell voltage',
                                              role: 'value',
                                              read: true,
                                              write: false,
                                              unit: 'V',
                                          });
                                      }
                                      break;
                                  case 'minVol':
                                      val = val / 100;
                                      if (existsState(statePath)) {
                                          setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                              name: 'Lowest Cell Voltage',
                                              type: 'number',
                                              desc: 'lowest cell voltage',
                                              role: 'value',
                                              read: true,
                                              write: false,
                                              unit: 'V',
                                          });
                                      }
                                      break;
      							case 'packType':
                                      if (existsState(statePath)) {
                                          setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                              name: 'packType',
                                              type: 'number',
                                              role: 'value',
                                              read: true,
                                              write: false,
                                          });
                                      }
                                      break;
      							case 'power':
                                      if (existsState(statePath)) {
                                          setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                              name: 'Battery Power',
                                              type: 'number',
                                              role: 'value',
                                              read: true,
                                              write: false,
                                              unit: 'W',
                                          });
                                      }
      								break;
      							case 'sn':
                                  const batType = getBatteryType(val, pack.model);
                                  // Modelltyp als Datenpunkt setzen/erstellen
                                  const modelPath = `${path}.model`;
                                  if (existsState(modelPath)) {
      								setState(modelPath, batType, true);
                                      } else {
                                          createState(modelPath, batType, {
                                          name: 'Battery Model',
                                          type: 'string',
                                          role: 'text',
                                          read: true,
                                          write: false,
                                          });
                                         }
                                      break;
      							case 'socLevel':
                                      if (existsState(statePath)) {
                                          setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                              name: 'Battery SoC Level',
                                              type: 'number',
                                              role: 'value',
                                              read: true,
                                              write: false,
                                              unit: '%',
                                          });
                                      }
      								break;
      							case 'softVersion':
                                      if (existsState(statePath)) {
                                          setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                              name: 'Battery Software Version',
                                              type: 'number',
                                              role: 'value',
                                              read: true,
                                              write: false,
                                          });
                                      }
      								break;
      							case 'state':
                                      if (existsState(statePath)) {
                                          setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                              name: 'Battery, 0: Standby, 1: Charging, 2: Discharging',
                                              type: 'number',
                                              role: 'value',
                                              read: true,
                                              write: false,
                                          });
                                      }
      								break;	
                                  case 'totalVol':
                                      val = val / 100;
                                      if (existsState(statePath)) {
                                          setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                              name: 'Total Voltage',
                                              type: 'number',
                                              desc: 'total voltage',
                                              role: 'value',
                                              read: true,
                                              write: false,
                                              unit: 'V',
                                          });
                                      }
                                      break;
                                  default:
                                      if (existsState(statePath)) {
                                          setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                              name: key,
                                              type: typeof val,
                                              role: 'value',
                                              read: true,
                                              write: false,
                                          });
                                      }
                                      break;
                              }
                          }
                      }
                  } else {
                      const ts = Date.now();
                      const statePath = `${id}.${i}`;
                      let val = obj[i];
       
                      switch (i) {
                          case 'BatVolt':
                              val = val / 100;
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                              } else {
                                  createState(statePath, val, {
                                      name: 'Battery Voltage',
                                      type: 'number',
                                      desc: 'battery voltage',
                                      role: 'value',
                                      read: true,
                                      write: false,
                                      unit: 'V',
                                  });
                              }
                              break;
      					case 'chargeMaxLimit':
                              val = val / 10;
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                              } else {
                                  createState(statePath, val, {
                                      name: 'maximum Charge Limit',
                                      type: 'number',
                                      desc: 'Battery Charge Limit Maximum',
                                      role: 'value',
                                      read: true,
                                      write: false,
                                      unit: '%',
                                  });
                              }
                              break;
                          case 'acMode':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                              } else {
                                  createState(statePath, val, {
                                      name: 'acMode, 1: input mode / 2: output mode',
                                      type: 'number',
                                      desc: '1: charging / 2: discharging',
                                      role: 'value',
                                      read: true,
                                      write: false,
                                  });
                              }
                              break;
      					case 'dataReady':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                              } else {
                                  createState(statePath, val, {
                                      name: 'Data Ready, 0: Not ready, 1: Ready',
                                      type: 'number',
                                      role: 'value',
                                      read: true,
                                      write: false,
                                  });
                              }
                              break;	
      					case 'dcStatus':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                              } else {
                                  createState(statePath, val, {
                                      name: 'dcStatus, 0: Stopped, 1: Battery input, 2: Battery output',
                                      type: 'number',
                                      role: 'value',
                                      read: true,
                                      write: false,
                                  });
                              }
                              break;						
      					case 'electricLevel':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                              } else {
                                  createState(statePath, val, {
                                      name: 'Total Battery Charge Level',
                                      type: 'number',
                                      desc: 'SoC',
                                      role: 'value',
                                      read: true,
                                      write: false,
                                      unit: '%',
                                  });
                              }
                              break;
                          case 'gridInputPower':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                              } else {
                                  createState(statePath, val, {
                                      name: 'Grid Input Power to Battery',
                                      type: 'number',
                                      role: 'value',
                                      read: true,
                                      write: false,
                                      unit: 'W',
                                  });
                              }
                              break;
                          case 'gridReverse':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                              } else {
                                  createState(statePath, val, {
                                      name: '0: Disabled, 1: Allowed reverse flow, 2: Forbidden reverse flow',
                                      type: 'number',
                                      role: 'value',
                                      read: true,
                                      write: false,
                                  });
                              }
                              break;
                          case 'gridStandard':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                              } else {
                                  createState(statePath, val, {
                                      name: 'Grid connection standard 0: Germany 1: France 2: Austria',
                                      type: 'number',
                                      role: 'value',
                                      read: true,
                                      write: false,
                                  });
                              }
                              break;
                          case 'gridState':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                              } else {
                                  createState(statePath, val, {
                                      name: 'GridState, 0: Not connected, 1: Connected',
                                      type: 'number',
                                      role: 'value',
                                      read: true,
                                      write: false,
                                  });
                              }
                              break;									
                          case 'heatState':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                              } else {
                                  createState(statePath, val, {
                                      name: 'Heat State, 0: Not heating, 1: heating',
                                      type: 'number',
                                      role: 'value',
                                      read: true,
                                      write: false,
                                  });
                              }
                              break;		
      					case 'hyperTmp':
                              val = (val - 2731) / 10.0;
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                          name: 'Enclosure Temperature',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
                                          unit: '°C',
                                          });
                                      }
                              break;
      					case 'inputLimit':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                          name: 'AC charging power limit to Battery',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
                                          unit: 'W',
                                          });
                                      }
                              break;
      					case 'inverseMaxPower': 
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                          name: 'Device Maximum Output Power Limit',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
                                          unit: 'W',
                                          });
                                      }
                              break;
      					case 'minSoc':
                              val = val / 10;
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                          name: 'min SoC',
                                          type: 'number',
                                          desc: 'minimum Battery SoCset',
                                          role: 'value',
                                          read: true,
                                          write: false,
                                          unit: '%',
                                          });
                                      }
                              break;
      					case 'outputHomePower':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
      									createState(statePath, val, {
                                          name: 'outputHomePower',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
      							        unit: 'W',
                                          });
      								}
                              break;
      					case 'outputLimit':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
      									createState(statePath, val, {
                                          name: 'Output power limit',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
      							        unit: 'W',
                                          });
      								}
                              break;
      					case 'outputPackPower':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
      									createState(statePath, val, {
                                          name: 'Output power to battery pack (charging)',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
      							        unit: 'W',
                                          });
      								}
                              break;
      					case 'packInputPower':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
      									createState(statePath, val, {
                                          name: 'Battery pack input power (discharging)',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
      							        unit: 'W',
                                          });
      								}
                              break;
      					case 'packNum':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
      									createState(statePath, val, {
                                          name: 'Number of battery packs',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
                                          });
      								}
                              break;
      					case 'packState':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
      									createState(statePath, val, {
                                          name: 'Battery State, 0: Standby, 1: Charging, 2: Discharging',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
                                          });
      								}
                              break;
      					case 'pass':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
      									createState(statePath, val, {
                                          name: 'Bypass, 0: No, 1: Yes',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
                                          });
      								}
                              break;
      					case 'pvStatus':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
      									createState(statePath, val, {
                                          name: 'PV State producing, 0: Stopped, 1: Running',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
                                          });
      								}
                              break;	
      					case 'remainOutTime':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
      									createState(statePath, val, {
                                          name: 'Estimated discharge time in minutes, if not predictable: 59940',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
      									unit: 'min',
                                          });
      								}
                              break;		
      					case 'reverseState':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
      									createState(statePath, val, {
                                          name: 'Reverse flow, 0: No, 1: Reverse flow',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
                                          });
      								}
                              break;			
      					case 'rssi':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
      									createState(statePath, val, {
                                          name: 'Received Signal Strength Indicator',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
      									unit: 'dBm',
                                          });
      								}
                              break;
      					case 'smartMode':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
      									createState(statePath, val, {
                                          name: '1: parameter written to RAM / 0: parameter is written to flash.',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
                                          });
      								}
                              break;		
      					case 'socLimit':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                          name: 'socLimit-Info 0: normal, 1: Charge limit reached, 2: Discharge limit reached',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
                                          });
                                      }
                              break;
      					case 'socSet':
                              val = val / 10;
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                          name: 'max SoC',
                                          type: 'number',
                                          desc: 'maximum Battery SoCset',
                                          role: 'value',
                                          read: true,
                                          write: false,
                                          unit: '%',
                                          });
                                      }
                              break;
      					case 'socStatus':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                          name: 'Info of Calibrating, 0: No / 1: Calibrating',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
                                          });
                                      }
                              break;
      					case 'solarInputPower':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                          name: 'Total Solar Input Power',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
      									unit: 'W',
                                          });
                                      }
                              break;
                          case 'solarPower1':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                          name: 'Solar line 1 input power',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
      									unit: 'W',
                                          });
                                      }
                              break;
                          case 'solarPower2':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                          name: 'Solar line 2 input power',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
      									unit: 'W',
                                          });
                                      }
                              break;
                          case 'solarPower3':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                          name: 'Solar line 3 input power',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
      									unit: 'W',
                                          });
                                      }
                              break;
                          case 'solarPower4':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                          name: 'Solar line 4 input power',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
      									unit: 'W',
                                          });
                                      }
                              break;
                          case 'solarPower5':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                          name: 'Solar line 5 input power',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
      									unit: 'W',
                                          });
                                      }
                              break;
                          case 'solarPower6':
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                                      } else {
                                          createState(statePath, val, {
                                          name: 'Solar line 6 input power',
                                          type: 'number',
                                          role: 'value',
                                          read: true,
                                          write: false,
      									unit: 'W',
                                          });
                                      }
                              break;
                          case 'timestamp':
                              const timestampVal = obj[i];
                              const timestampFormatted = formatTime(timestampVal);
                              if (existsState(statePath)) setState(statePath, timestampVal, true);
                              else createState(statePath, timestampVal, {
                                  name: 'unix timestamp (timestamp)',
                                  type: 'number',
                                  desc: 'unix timestamp in Seconds since Jan 01 1970 (UTC)',
                                  role: 'value',
                                  read: true,
                                  write: false,
                              });
                              if (existsState(id + '.timeUpdateTimestamp')) setState(id + '.timeUpdateTimestamp', timestampFormatted, true);
                              else createState(id + '.timeUpdateTimestamp', timestampFormatted, {
                                  name: 'TimeUpdate (timestamp)',
                                  type: 'string',
                                  desc: 'unix timestamp in readable Format (timestamp)',
                                  read: true,
                                  write: false,
                              });
                              break;
                          case 'ts':
                              const tsVal = obj[i];
                              const tsFormatted = formatTime(tsVal);
                              if (existsState(statePath)) setState(statePath, tsVal, true);
                              else createState(statePath, tsVal, {
                                  name: 'unix timestamp (ts)',
                                  type: 'number',
                                  desc: 'unix timestamp in Seconds since Jan 01 1970 (UTC)',
                                  role: 'value',
                                  read: true,
                                  write: false,
                              });
                              if (existsState(id + '.timeUpdateTs')) setState(id + '.timeUpdateTs', tsFormatted, true);
                              else createState(id + '.timeUpdateTs', tsFormatted, {
                                  name: 'TimeUpdate (ts)',
                                  type: 'string',
                                  desc: 'unix timestamp in readable Format (ts)',
                                  read: true,
                                  write: false,
                              });
                              break;			
                          default:
                              if (existsState(statePath)) {
                                  setState(statePath, val, true);
                              } else {
                                  createState(statePath, val, {
                                      name: i,
                                      type: typeof val,
                                      role: 'value',
                                      read: true,
                                      write: false,
                                  });
                              }
                              break;
                      }
                  }
              }
          } catch (e) {
              log(`Error in iter: ${e}`, 'info');
          }
      }
      

      Historisch:
      Frühere Versionen der Scripte sind hier (im Spoiler) zu finden.
      Die kompletten Scripte sind zu groß für diesen Post, daher habe ich sie dort ausgelagert.

      M Offline
      M Offline
      Michi 0
      wrote on last edited by Michi 0
      #2

      @maxclaudi
      Vielen Dank dass Du das gesondert einstellst!

      Ich werde das in den nächsten Tagen mal ausprobieren und komme dann vermutlich mit mehreren Fragen ums Eck 😉

      D 1 Reply Last reply
      0
      • M Michi 0

        @maxclaudi
        Vielen Dank dass Du das gesondert einstellst!

        Ich werde das in den nächsten Tagen mal ausprobieren und komme dann vermutlich mit mehreren Fragen ums Eck 😉

        D Online
        D Online
        Daniel 8
        wrote on last edited by
        #3

        Vielen Dank für das Script.

        Ich habe heute den ganzen Nachmittag gebastelt. Habe von der zendure sdk das Script genommen und umgebaut. Habe per blockly dann mal den Status vom solarflow angefragt und konnte sehen das ich den smartMode von 0 auf 1 setzen konnte. Dein Script werde ich aber mal noch testen weil mir das vom Aufbau besser gefällt.

        Mal sehen wie ich die Tage dazu komme um das ganze noch umzusetzen und auch zu kontrollieren ob der smartMode auf 1 bleibt.

        Solarflow 800 Pro mit 1,3 Kwp / Iobroker / Homematic / Shellys / Mediola / Intertechno

        maxclaudiM 1 Reply Last reply
        0
        • D Daniel 8

          Vielen Dank für das Script.

          Ich habe heute den ganzen Nachmittag gebastelt. Habe von der zendure sdk das Script genommen und umgebaut. Habe per blockly dann mal den Status vom solarflow angefragt und konnte sehen das ich den smartMode von 0 auf 1 setzen konnte. Dein Script werde ich aber mal noch testen weil mir das vom Aufbau besser gefällt.

          Mal sehen wie ich die Tage dazu komme um das ganze noch umzusetzen und auch zu kontrollieren ob der smartMode auf 1 bleibt.

          maxclaudiM Offline
          maxclaudiM Offline
          maxclaudi
          wrote on last edited by maxclaudi
          #4

          @daniel-8
          Super 👍
          Hast Du einfach die IP verwendet ohne Port anzugeben?
          Dann wäre es Standardport: 80.

          Hast Du es schon über http gemacht oder per mqtt?

          Wenn du das Blockly hier einstellen würdest
          (im Blockly: exportieren in Zwischenablage, hier beim Nachrichten verfassen oben auswählen: </> Code und dann rein kopieren, dann Deine Seriennummer durch z. B. "WOB1NHMAMXXXXX3" ersetzen), dann könnte ich schneller ein Script mit mehr Funktionen / Datenpunkten etc. erstellen.

          Mir fehlt dazu die Möglichkeit, weil ich keines der Geräte habe.

          So könnte ich besser helfen, falls gewünscht.

          Mit iob auf Linux-Basis bekommt man mit IP vom Zendure-Gerät + richtigem Port gleich alle relevanten Daten.
          Einfach ein curl absetzen und ein json mit allen keys+values sollte zurück kommen.

          Beispiel:

          curl -s http://192.168.50.123:80/properties/report
          

          edit oder einfach als Blockly ausprobieren.
          Dazu einfach IP und falls Port vom Standard-Port 80 abweicht: zusätzlich richtigen Port eingeben.
          Dann steht im Log JSON mit Keys und values:

          b0e15317-9ff9-4c8b-8560-cc8c73692cec-image.png

          <xml xmlns="https://developers.google.com/blockly/xml">
            <variables>
              <variable id="(w#*/K[*0t){NM82Wb4}">ZendureIp</variable>
              <variable id="?xd{Ro`yZj{Jd^N)xX*t">zendurePort</variable>
              <variable id="=-0mrzwIoW}btg.,BPp^">curlStep01</variable>
              <variable id="]NKaHB0BAP(UwAML_PG~">curlStep02</variable>
              <variable id="yyN_WeK8BY|3[i(6a2yU">curlStep03</variable>
              <variable id="+s4fiT)W5CkRx%z|G@na">curlKey</variable>
              <variable id="E0g8VQmv]n[5)?{;p{n_">curlReport</variable>
            </variables>
            <block type="comment" id="/u=p]*wyw+;ApoTiJ.?4" x="-312" y="437">
              <field name="COMMENT">Zendure-IP+Port:</field>
              <next>
                <block type="variables_set" id="(!SY,}niKV(fUQdft7{d">
                  <field name="VAR" id="(w#*/K[*0t){NM82Wb4}">ZendureIp</field>
                  <value name="VALUE">
                    <block type="text" id="M.`qvdIKmRQW)UOx|6Mp">
                      <field name="TEXT">192.168.50.123</field>
                    </block>
                  </value>
                  <next>
                    <block type="variables_set" id="$!M`QIA#E[yj*fE}7qy4">
                      <field name="VAR" id="?xd{Ro`yZj{Jd^N)xX*t">zendurePort</field>
                      <value name="VALUE">
                        <block type="text" id="{s$!G:v2f3xOZE4[|ka;">
                          <field name="TEXT">80</field>
                        </block>
                      </value>
                      <next>
                        <block type="comment" id="0reTf-FNE|XW*{z%J8MD">
                          <field name="COMMENT">----</field>
                          <next>
                            <block type="variables_set" id="8nPs0`Urt!2nc[x`p$sf">
                              <field name="VAR" id="=-0mrzwIoW}btg.,BPp^">curlStep01</field>
                              <value name="VALUE">
                                <block type="text" id="cT|,o|l:IM=S[dURs^|5">
                                  <field name="TEXT">curl -s http://</field>
                                </block>
                              </value>
                              <next>
                                <block type="variables_set" id="5}GxtvZKHj-h`hBM[U;2">
                                  <field name="VAR" id="]NKaHB0BAP(UwAML_PG~">curlStep02</field>
                                  <value name="VALUE">
                                    <block type="text" id="-(J+YIJhL^G7MCdL.!G:">
                                      <field name="TEXT">:</field>
                                    </block>
                                  </value>
                                  <next>
                                    <block type="variables_set" id="wQ9oYw}7{%1QuBUIJ.2i">
                                      <field name="VAR" id="yyN_WeK8BY|3[i(6a2yU">curlStep03</field>
                                      <value name="VALUE">
                                        <block type="text" id="S=3qcMrhAB.R$qdOi3c0">
                                          <field name="TEXT">/properties/</field>
                                        </block>
                                      </value>
                                      <next>
                                        <block type="variables_set" id="T?jKr9`]0|**]52m_RI:">
                                          <field name="VAR" id="+s4fiT)W5CkRx%z|G@na">curlKey</field>
                                          <value name="VALUE">
                                            <block type="text" id="90=V)G!Aqu4;Cx~wl7)h">
                                              <field name="TEXT">report</field>
                                            </block>
                                          </value>
                                          <next>
                                            <block type="comment" id="d9r~^-wF#JT!-y.3m5y+">
                                              <field name="COMMENT">curl -s http://192.168.50.123:80/properties/report</field>
                                              <next>
                                                <block type="variables_set" id="dmQ$}Y^.0A8vxUJ1(k/K">
                                                  <field name="VAR" id="E0g8VQmv]n[5)?{;p{n_">curlReport</field>
                                                  <value name="VALUE">
                                                    <block type="text_join" id="NSFAlC@auBvs9=Y4j_k%">
                                                      <mutation items="6"></mutation>
                                                      <value name="ADD0">
                                                        <block type="variables_get" id="u}CvP3Yz}1frT8;Ud_QP">
                                                          <field name="VAR" id="=-0mrzwIoW}btg.,BPp^">curlStep01</field>
                                                        </block>
                                                      </value>
                                                      <value name="ADD1">
                                                        <block type="variables_get" id="lTG|V9}G|B{,jQF-it%_">
                                                          <field name="VAR" id="(w#*/K[*0t){NM82Wb4}">ZendureIp</field>
                                                        </block>
                                                      </value>
                                                      <value name="ADD2">
                                                        <block type="variables_get" id="Z]4`v+o*x2nfw?cLqh.L">
                                                          <field name="VAR" id="]NKaHB0BAP(UwAML_PG~">curlStep02</field>
                                                        </block>
                                                      </value>
                                                      <value name="ADD3">
                                                        <block type="variables_get" id="0;VcCoAHYdQYL#.GY?}~">
                                                          <field name="VAR" id="?xd{Ro`yZj{Jd^N)xX*t">zendurePort</field>
                                                        </block>
                                                      </value>
                                                      <value name="ADD4">
                                                        <block type="variables_get" id="z/#?ld2^R.DP`U^H/;;l">
                                                          <field name="VAR" id="yyN_WeK8BY|3[i(6a2yU">curlStep03</field>
                                                        </block>
                                                      </value>
                                                      <value name="ADD5">
                                                        <block type="variables_get" id="@RWKa3z8Or_rQB6m%T9j">
                                                          <field name="VAR" id="+s4fiT)W5CkRx%z|G@na">curlKey</field>
                                                        </block>
                                                      </value>
                                                    </block>
                                                  </value>
                                                  <next>
                                                    <block type="exec" id="dsec2.aKuJph+F@rSjL)">
                                                      <mutation xmlns="http://www.w3.org/1999/xhtml" with_statement="true"></mutation>
                                                      <field name="WITH_STATEMENT">TRUE</field>
                                                      <field name="LOG"></field>
                                                      <value name="COMMAND">
                                                        <shadow type="text" id="M75b`L#|@]-G23[[OTQg">
                                                          <field name="TEXT"></field>
                                                        </shadow>
                                                        <block type="variables_get" id="[S-p^/6VR+ttSt3*j+fX">
                                                          <field name="VAR" id="E0g8VQmv]n[5)?{;p{n_">curlReport</field>
                                                        </block>
                                                      </value>
                                                      <statement name="STATEMENT">
                                                        <block type="debug" id="-iKLJ^@,s/18zWy+fQx^">
                                                          <field name="Severity">info</field>
                                                          <value name="TEXT">
                                                            <shadow type="text" id="Vj*~p~2.(t;n`[f,OQO2">
                                                              <field name="TEXT">test</field>
                                                            </shadow>
                                                            <block type="exec_result" id="l$00#44)SoCJ9y@y.gs:">
                                                              <field name="ATTR">result</field>
                                                            </block>
                                                          </value>
                                                        </block>
                                                      </statement>
                                                    </block>
                                                  </next>
                                                </block>
                                              </next>
                                            </block>
                                          </next>
                                        </block>
                                      </next>
                                    </block>
                                  </next>
                                </block>
                              </next>
                            </block>
                          </next>
                        </block>
                      </next>
                    </block>
                  </next>
                </block>
              </next>
            </block>
          </xml>
          

          Ich schreibe meistens sehr direkt – bitte nicht falsch verstehen, es ist nie böse gemeint. Das ist einfach mein Stil und niemals abwertend gemeint.

          D 1 Reply Last reply
          0
          • maxclaudiM maxclaudi

            @daniel-8
            Super 👍
            Hast Du einfach die IP verwendet ohne Port anzugeben?
            Dann wäre es Standardport: 80.

            Hast Du es schon über http gemacht oder per mqtt?

            Wenn du das Blockly hier einstellen würdest
            (im Blockly: exportieren in Zwischenablage, hier beim Nachrichten verfassen oben auswählen: </> Code und dann rein kopieren, dann Deine Seriennummer durch z. B. "WOB1NHMAMXXXXX3" ersetzen), dann könnte ich schneller ein Script mit mehr Funktionen / Datenpunkten etc. erstellen.

            Mir fehlt dazu die Möglichkeit, weil ich keines der Geräte habe.

            So könnte ich besser helfen, falls gewünscht.

            Mit iob auf Linux-Basis bekommt man mit IP vom Zendure-Gerät + richtigem Port gleich alle relevanten Daten.
            Einfach ein curl absetzen und ein json mit allen keys+values sollte zurück kommen.

            Beispiel:

            curl -s http://192.168.50.123:80/properties/report
            

            edit oder einfach als Blockly ausprobieren.
            Dazu einfach IP und falls Port vom Standard-Port 80 abweicht: zusätzlich richtigen Port eingeben.
            Dann steht im Log JSON mit Keys und values:

            b0e15317-9ff9-4c8b-8560-cc8c73692cec-image.png

            <xml xmlns="https://developers.google.com/blockly/xml">
              <variables>
                <variable id="(w#*/K[*0t){NM82Wb4}">ZendureIp</variable>
                <variable id="?xd{Ro`yZj{Jd^N)xX*t">zendurePort</variable>
                <variable id="=-0mrzwIoW}btg.,BPp^">curlStep01</variable>
                <variable id="]NKaHB0BAP(UwAML_PG~">curlStep02</variable>
                <variable id="yyN_WeK8BY|3[i(6a2yU">curlStep03</variable>
                <variable id="+s4fiT)W5CkRx%z|G@na">curlKey</variable>
                <variable id="E0g8VQmv]n[5)?{;p{n_">curlReport</variable>
              </variables>
              <block type="comment" id="/u=p]*wyw+;ApoTiJ.?4" x="-312" y="437">
                <field name="COMMENT">Zendure-IP+Port:</field>
                <next>
                  <block type="variables_set" id="(!SY,}niKV(fUQdft7{d">
                    <field name="VAR" id="(w#*/K[*0t){NM82Wb4}">ZendureIp</field>
                    <value name="VALUE">
                      <block type="text" id="M.`qvdIKmRQW)UOx|6Mp">
                        <field name="TEXT">192.168.50.123</field>
                      </block>
                    </value>
                    <next>
                      <block type="variables_set" id="$!M`QIA#E[yj*fE}7qy4">
                        <field name="VAR" id="?xd{Ro`yZj{Jd^N)xX*t">zendurePort</field>
                        <value name="VALUE">
                          <block type="text" id="{s$!G:v2f3xOZE4[|ka;">
                            <field name="TEXT">80</field>
                          </block>
                        </value>
                        <next>
                          <block type="comment" id="0reTf-FNE|XW*{z%J8MD">
                            <field name="COMMENT">----</field>
                            <next>
                              <block type="variables_set" id="8nPs0`Urt!2nc[x`p$sf">
                                <field name="VAR" id="=-0mrzwIoW}btg.,BPp^">curlStep01</field>
                                <value name="VALUE">
                                  <block type="text" id="cT|,o|l:IM=S[dURs^|5">
                                    <field name="TEXT">curl -s http://</field>
                                  </block>
                                </value>
                                <next>
                                  <block type="variables_set" id="5}GxtvZKHj-h`hBM[U;2">
                                    <field name="VAR" id="]NKaHB0BAP(UwAML_PG~">curlStep02</field>
                                    <value name="VALUE">
                                      <block type="text" id="-(J+YIJhL^G7MCdL.!G:">
                                        <field name="TEXT">:</field>
                                      </block>
                                    </value>
                                    <next>
                                      <block type="variables_set" id="wQ9oYw}7{%1QuBUIJ.2i">
                                        <field name="VAR" id="yyN_WeK8BY|3[i(6a2yU">curlStep03</field>
                                        <value name="VALUE">
                                          <block type="text" id="S=3qcMrhAB.R$qdOi3c0">
                                            <field name="TEXT">/properties/</field>
                                          </block>
                                        </value>
                                        <next>
                                          <block type="variables_set" id="T?jKr9`]0|**]52m_RI:">
                                            <field name="VAR" id="+s4fiT)W5CkRx%z|G@na">curlKey</field>
                                            <value name="VALUE">
                                              <block type="text" id="90=V)G!Aqu4;Cx~wl7)h">
                                                <field name="TEXT">report</field>
                                              </block>
                                            </value>
                                            <next>
                                              <block type="comment" id="d9r~^-wF#JT!-y.3m5y+">
                                                <field name="COMMENT">curl -s http://192.168.50.123:80/properties/report</field>
                                                <next>
                                                  <block type="variables_set" id="dmQ$}Y^.0A8vxUJ1(k/K">
                                                    <field name="VAR" id="E0g8VQmv]n[5)?{;p{n_">curlReport</field>
                                                    <value name="VALUE">
                                                      <block type="text_join" id="NSFAlC@auBvs9=Y4j_k%">
                                                        <mutation items="6"></mutation>
                                                        <value name="ADD0">
                                                          <block type="variables_get" id="u}CvP3Yz}1frT8;Ud_QP">
                                                            <field name="VAR" id="=-0mrzwIoW}btg.,BPp^">curlStep01</field>
                                                          </block>
                                                        </value>
                                                        <value name="ADD1">
                                                          <block type="variables_get" id="lTG|V9}G|B{,jQF-it%_">
                                                            <field name="VAR" id="(w#*/K[*0t){NM82Wb4}">ZendureIp</field>
                                                          </block>
                                                        </value>
                                                        <value name="ADD2">
                                                          <block type="variables_get" id="Z]4`v+o*x2nfw?cLqh.L">
                                                            <field name="VAR" id="]NKaHB0BAP(UwAML_PG~">curlStep02</field>
                                                          </block>
                                                        </value>
                                                        <value name="ADD3">
                                                          <block type="variables_get" id="0;VcCoAHYdQYL#.GY?}~">
                                                            <field name="VAR" id="?xd{Ro`yZj{Jd^N)xX*t">zendurePort</field>
                                                          </block>
                                                        </value>
                                                        <value name="ADD4">
                                                          <block type="variables_get" id="z/#?ld2^R.DP`U^H/;;l">
                                                            <field name="VAR" id="yyN_WeK8BY|3[i(6a2yU">curlStep03</field>
                                                          </block>
                                                        </value>
                                                        <value name="ADD5">
                                                          <block type="variables_get" id="@RWKa3z8Or_rQB6m%T9j">
                                                            <field name="VAR" id="+s4fiT)W5CkRx%z|G@na">curlKey</field>
                                                          </block>
                                                        </value>
                                                      </block>
                                                    </value>
                                                    <next>
                                                      <block type="exec" id="dsec2.aKuJph+F@rSjL)">
                                                        <mutation xmlns="http://www.w3.org/1999/xhtml" with_statement="true"></mutation>
                                                        <field name="WITH_STATEMENT">TRUE</field>
                                                        <field name="LOG"></field>
                                                        <value name="COMMAND">
                                                          <shadow type="text" id="M75b`L#|@]-G23[[OTQg">
                                                            <field name="TEXT"></field>
                                                          </shadow>
                                                          <block type="variables_get" id="[S-p^/6VR+ttSt3*j+fX">
                                                            <field name="VAR" id="E0g8VQmv]n[5)?{;p{n_">curlReport</field>
                                                          </block>
                                                        </value>
                                                        <statement name="STATEMENT">
                                                          <block type="debug" id="-iKLJ^@,s/18zWy+fQx^">
                                                            <field name="Severity">info</field>
                                                            <value name="TEXT">
                                                              <shadow type="text" id="Vj*~p~2.(t;n`[f,OQO2">
                                                                <field name="TEXT">test</field>
                                                              </shadow>
                                                              <block type="exec_result" id="l$00#44)SoCJ9y@y.gs:">
                                                                <field name="ATTR">result</field>
                                                              </block>
                                                            </value>
                                                          </block>
                                                        </statement>
                                                      </block>
                                                    </next>
                                                  </block>
                                                </next>
                                              </block>
                                            </next>
                                          </block>
                                        </next>
                                      </block>
                                    </next>
                                  </block>
                                </next>
                              </block>
                            </next>
                          </block>
                        </next>
                      </block>
                    </next>
                  </block>
                </next>
              </block>
            </xml>
            
            D Online
            D Online
            Daniel 8
            wrote on last edited by
            #5

            @maxclaudi
            So schön und komfortabel wie du habe ich dies noch nicht gestaltet, da ich die Setzung des Smartmode mit Javascript noch nicht ins Blockly gebracht habe.
            Hier mal mein Weg um mal herauszufinden wo er denn steht.

            <xml xmlns="https://developers.google.com/blockly/xml">
              <block type="http_get" id="j%A)IFPC:/X[3%4-uOoz" x="337" y="-587">
                <field name="TIMEOUT">2000</field>
                <field name="UNIT">ms</field>
                <field name="TYPE">text</field>
                <value name="URL">
                  <shadow type="text" id="Aw[L!5jdo%*Llnx^/#=D">
                    <field name="TEXT">http://192.168.177.103/properties/report</field>
                  </shadow>
                </value>
                <statement name="STATEMENT">
                  <block type="update" id="W=tV.%Gw+~UD]5Ern-QT">
                    <mutation xmlns="http://www.w3.org/1999/xhtml" delay_input="false"></mutation>
                    <field name="OID">0_userdata.0.Test.pro</field>
                    <field name="WITH_DELAY">FALSE</field>
                    <value name="VALUE">
                      <block type="text_getSubstring" id="RA=WWx@9N*RJY@h]U:YR">
                        <mutation at1="true" at2="true"></mutation>
                        <field name="WHERE1">FROM_START</field>
                        <field name="WHERE2">FROM_START</field>
                        <value name="STRING">
                          <block type="http_response" id="qjV%:]X#B)[R-G;5$+]C">
                            <field name="ATTR">response.data</field>
                          </block>
                        </value>
                        <value name="AT1">
                          <block type="text_indexOf" id="_qBlL/k,8w3NP@)5@]?r">
                            <field name="END">FIRST</field>
                            <value name="VALUE">
                              <block type="http_response" id="jEJw2-NqIR(}IAVi%.Ps">
                                <field name="ATTR">response.data</field>
                              </block>
                            </value>
                            <value name="FIND">
                              <shadow type="text" id="nTc~o-,LG:[Zc987~1HG">
                                <field name="TEXT">"smartMode"</field>
                              </shadow>
                            </value>
                          </block>
                        </value>
                        <value name="AT2">
                          <block type="text_indexOf" id="CsMD]%BkREj?y|o7jyr:">
                            <field name="END">FIRST</field>
                            <value name="VALUE">
                              <block type="http_response" id="?:3:r:XBI)gD=O]lI%EU">
                                <field name="ATTR">response.data</field>
                              </block>
                            </value>
                            <value name="FIND">
                              <shadow type="text" id="|a%9_IsBqdmg7@Q(Zv@F">
                                <field name="TEXT">,"chargeMaxLimit</field>
                              </shadow>
                            </value>
                          </block>
                        </value>
                      </block>
                    </value>
                    <next>
                      <block type="debug" id="sG}@g4pdHs}Ob_:yjpPz">
                        <field name="Severity">info</field>
                        <value name="TEXT">
                          <shadow type="text" id="zjoKpq+T%tlis;*6Om76">
                            <field name="TEXT">test</field>
                          </shadow>
                          <block type="get_value" id="G,Yytf7Ix`C9}tKYPQUf">
                            <field name="ATTR">val</field>
                            <field name="OID">0_userdata.0.Test.pro</field>
                          </block>
                        </value>
                      </block>
                    </next>
                  </block>
                </statement>
              </block>
            </xml>
            

            f4424091-6118-4ac4-a802-a77b3f25752d-image.png

            Das setzen habe ich quasi von der Zendure übernommen und habe nur mal ein Javascript gemacht und dies manuell gestartet. Ich hätte das schon gern in Blockly gehabt aber noch keine Lösung gefunden.

            /*
             * @Author: dav1d wei.liu@zendure.com
             * @Date: 2025-03-05 14:22:34
             * @LastEditors: dav1d wei.liu@zendure.com
             * @LastEditTime: 2025-03-05 14:22:36
             * @FilePath: /zenSDK/examples/JavaScript/demo.js
             * @Description: 
             * 
             * Copyright (c) 2025 by Zendure, All Rights Reserved. 
             */
            const axios = require('axios');
            
            // GET 请求
            axios.get('http://192.168.177.103/properties/report')
                 .then(res => console.log("GET:", res.data));
            
            // POST 请求
            axios.post('http://192.168.177.103/properties/write', { sn: "XXXXXXXXXX", properties: { smartMode: 1 } })
                 .then(res => console.log("POST:", res.data));
            

            Solarflow 800 Pro mit 1,3 Kwp / Iobroker / Homematic / Shellys / Mediola / Intertechno

            maxclaudiM 1 Reply Last reply
            0
            • D Daniel 8

              @maxclaudi
              So schön und komfortabel wie du habe ich dies noch nicht gestaltet, da ich die Setzung des Smartmode mit Javascript noch nicht ins Blockly gebracht habe.
              Hier mal mein Weg um mal herauszufinden wo er denn steht.

              <xml xmlns="https://developers.google.com/blockly/xml">
                <block type="http_get" id="j%A)IFPC:/X[3%4-uOoz" x="337" y="-587">
                  <field name="TIMEOUT">2000</field>
                  <field name="UNIT">ms</field>
                  <field name="TYPE">text</field>
                  <value name="URL">
                    <shadow type="text" id="Aw[L!5jdo%*Llnx^/#=D">
                      <field name="TEXT">http://192.168.177.103/properties/report</field>
                    </shadow>
                  </value>
                  <statement name="STATEMENT">
                    <block type="update" id="W=tV.%Gw+~UD]5Ern-QT">
                      <mutation xmlns="http://www.w3.org/1999/xhtml" delay_input="false"></mutation>
                      <field name="OID">0_userdata.0.Test.pro</field>
                      <field name="WITH_DELAY">FALSE</field>
                      <value name="VALUE">
                        <block type="text_getSubstring" id="RA=WWx@9N*RJY@h]U:YR">
                          <mutation at1="true" at2="true"></mutation>
                          <field name="WHERE1">FROM_START</field>
                          <field name="WHERE2">FROM_START</field>
                          <value name="STRING">
                            <block type="http_response" id="qjV%:]X#B)[R-G;5$+]C">
                              <field name="ATTR">response.data</field>
                            </block>
                          </value>
                          <value name="AT1">
                            <block type="text_indexOf" id="_qBlL/k,8w3NP@)5@]?r">
                              <field name="END">FIRST</field>
                              <value name="VALUE">
                                <block type="http_response" id="jEJw2-NqIR(}IAVi%.Ps">
                                  <field name="ATTR">response.data</field>
                                </block>
                              </value>
                              <value name="FIND">
                                <shadow type="text" id="nTc~o-,LG:[Zc987~1HG">
                                  <field name="TEXT">"smartMode"</field>
                                </shadow>
                              </value>
                            </block>
                          </value>
                          <value name="AT2">
                            <block type="text_indexOf" id="CsMD]%BkREj?y|o7jyr:">
                              <field name="END">FIRST</field>
                              <value name="VALUE">
                                <block type="http_response" id="?:3:r:XBI)gD=O]lI%EU">
                                  <field name="ATTR">response.data</field>
                                </block>
                              </value>
                              <value name="FIND">
                                <shadow type="text" id="|a%9_IsBqdmg7@Q(Zv@F">
                                  <field name="TEXT">,"chargeMaxLimit</field>
                                </shadow>
                              </value>
                            </block>
                          </value>
                        </block>
                      </value>
                      <next>
                        <block type="debug" id="sG}@g4pdHs}Ob_:yjpPz">
                          <field name="Severity">info</field>
                          <value name="TEXT">
                            <shadow type="text" id="zjoKpq+T%tlis;*6Om76">
                              <field name="TEXT">test</field>
                            </shadow>
                            <block type="get_value" id="G,Yytf7Ix`C9}tKYPQUf">
                              <field name="ATTR">val</field>
                              <field name="OID">0_userdata.0.Test.pro</field>
                            </block>
                          </value>
                        </block>
                      </next>
                    </block>
                  </statement>
                </block>
              </xml>
              

              f4424091-6118-4ac4-a802-a77b3f25752d-image.png

              Das setzen habe ich quasi von der Zendure übernommen und habe nur mal ein Javascript gemacht und dies manuell gestartet. Ich hätte das schon gern in Blockly gehabt aber noch keine Lösung gefunden.

              /*
               * @Author: dav1d wei.liu@zendure.com
               * @Date: 2025-03-05 14:22:34
               * @LastEditors: dav1d wei.liu@zendure.com
               * @LastEditTime: 2025-03-05 14:22:36
               * @FilePath: /zenSDK/examples/JavaScript/demo.js
               * @Description: 
               * 
               * Copyright (c) 2025 by Zendure, All Rights Reserved. 
               */
              const axios = require('axios');
              
              // GET 请求
              axios.get('http://192.168.177.103/properties/report')
                   .then(res => console.log("GET:", res.data));
              
              // POST 请求
              axios.post('http://192.168.177.103/properties/write', { sn: "XXXXXXXXXX", properties: { smartMode: 1 } })
                   .then(res => console.log("POST:", res.data));
              
              maxclaudiM Offline
              maxclaudiM Offline
              maxclaudi
              wrote on last edited by maxclaudi
              #6

              @daniel-8
              Für properties hat Dein Blockly so funktioniert?

              • Dann ist es Standardport:80 und muss nicht extra angegeben werden.
              • IP von zendure-device wird benötigt read only
              • sn von zendue-device wird zusätzlich benötigt für set

              🙂 👍

              So schwer ist das nicht.
              Was möchtest haben? Ziel(e)?

              Vielleicht erst Brainstorming

              • Evtl. x min report pollen.
              • JSON parsen.
              • bestimmte Datenpunkte (die es noch nicht gibt?) mit den Werten aktualisieren.
              • neue dp die beschreibbar sind unter ein folder cmd übernehmen.

              oder nur smartMode?

              Würde ein js als Vorlage schreiben. Datenpunkte können ja dann mit Blockly oder js verwendet werden.
              Ein Blockly kann man immer noch machen?

              @Daniel-8 und @Michi-0 macht Euch mal Gedanken.

              edit ps: @Daniel-8
              Kannst Du bitte den empfangenen report json hier in </> einstellen.
              Falls sn mit übermittelt wurde bitte mit WOB1NHMAMXXXXX3 ersetzen, danke.

              Ich schreibe meistens sehr direkt – bitte nicht falsch verstehen, es ist nie böse gemeint. Das ist einfach mein Stil und niemals abwertend gemeint.

              M 1 Reply Last reply
              0
              • D Online
                D Online
                Daniel 8
                wrote on last edited by
                #7

                @maxclaudi sagte in Zendure SmartMode:1 SolarFlow2400 AC SolarFlow800 ( u. Pro):

                @daniel-8
                Für properties hat Dein Blockly so funktioniert?

                • Dann ist es Standardport:80 und muss nicht extra angegeben werden.
                • IP von zendure-device wird benötigt read only
                • sn von zendue-device wird zusätzlich benötigt für set

                🙂 👍

                So schwer ist das nicht.
                Was möchtest haben? Ziel(e)?

                Vielleicht erst Brainstorming

                • Evtl. x min report pollen.
                • JSON parsen.
                • bestimmte Datenpunkte (die es noch nicht gibt?) mit den Werten aktualisieren.
                • neue dp die beschreibbar sind unter ein folder cmd übernehmen.

                oder nur smartMode?

                Würde ein js als Vorlage schreiben. Datenpunkte können ja dann mit Blockly oder js verwendet werden.
                Ein Blockly kann man immer noch machen?

                @Daniel-8 und @Michi-0 macht Euch mal Gedanken.

                edit ps: @Daniel-8
                Kannst Du bitte den empfangenen report json hier in </> einstellen.
                Falls sn mit übermittelt wurde bitte mit WOB1NHMAMXXXXX3 ersetzen, danke.

                Ja für properties hat mein Blockly so funktioniert. Der Port ist bei mir Standard auf 80.

                Mir war es jetzt mal wichtig das ich den Smartmode eben setzen kann und auch gewissermaßen überwachen. Ich habe jetzt mal ein Intervall von 5 Minuten gesetzt und es eben so mit den Texteilen abgefragt.

                Was meinst du mit ein js als Vorlage schreiben? ich kenne mich da eigentlich nicht aus mit js. Ich würde schon gerne JSON parsen aber bin noch nicht dahinter gestiegen wie das geht. Ich kann halt ein bisschen Blockly und da komme ich auch oft an meine Grenzen.

                Anbei noch den empfangenen Report json

                {"timestamp":1758649975,"messageId":25,"sn":"EXXXXXXXXXXXXX0","version":2,"product":"solarFlow800Pro","properties":{"heatState":0,"packInputPower":0,"outputPackPower":0,"outputHomePower":0,"remainOutTime":59940,"packState":0,"electricLevel":15,"gridInputPower":0,"solarInputPower":0,"solarPower1":0,"solarPower2":0,"solarPower3":0,"solarPower4":0,"pass":0,"reverseState":0,"socStatus":0,"hyperTmp":2881,"gridOffPower":0,"dcStatus":0,"pvStatus":1,"acStatus":0,"dataReady":1,"gridState":1,"BatVolt":4947,"socLimit":2,"writeRsp":0,"acMode":2,"inputLimit":0,"outputLimit":0,"socSet":1000,"minSoc":200,"gridStandard":0,"gridReverse":1,"inverseMaxPower":800,"lampSwitch":0,"gridOffMode":2,"IOTState":2,"Fanmode":1,"Fanspeed":0,"bindstate":0,"factoryModeState":0,"OTAState":0,"LCNState":0,"oldMode":0,"VoltWakeup":0,"ts":1758649841,"tsZone":14,"smartMode":1,"chargeMaxLimit":1000,"packNum":2,"rssi":-75,"is_error":0},"packData":[{"sn":"COXXXXXXXXXXXX9","packType":300,"socLevel":15,"state":0,"power":0,"maxTemp":2861,"totalVol":4930,"batcur":0,"maxVol":329,"minVol":328,"softVersion":4117},{"sn":"COXXXXXXXXXXXX7","packType":300,"socLevel":15,"state":0,"power":0,"maxTemp":2851,"totalVol":4910,"batcur":0,"maxVol":328,"minVol":327,"softVersion":4117}]}
                

                Solarflow 800 Pro mit 1,3 Kwp / Iobroker / Homematic / Shellys / Mediola / Intertechno

                maxclaudiM 2 Replies Last reply
                0
                • D Daniel 8

                  @maxclaudi sagte in Zendure SmartMode:1 SolarFlow2400 AC SolarFlow800 ( u. Pro):

                  @daniel-8
                  Für properties hat Dein Blockly so funktioniert?

                  • Dann ist es Standardport:80 und muss nicht extra angegeben werden.
                  • IP von zendure-device wird benötigt read only
                  • sn von zendue-device wird zusätzlich benötigt für set

                  🙂 👍

                  So schwer ist das nicht.
                  Was möchtest haben? Ziel(e)?

                  Vielleicht erst Brainstorming

                  • Evtl. x min report pollen.
                  • JSON parsen.
                  • bestimmte Datenpunkte (die es noch nicht gibt?) mit den Werten aktualisieren.
                  • neue dp die beschreibbar sind unter ein folder cmd übernehmen.

                  oder nur smartMode?

                  Würde ein js als Vorlage schreiben. Datenpunkte können ja dann mit Blockly oder js verwendet werden.
                  Ein Blockly kann man immer noch machen?

                  @Daniel-8 und @Michi-0 macht Euch mal Gedanken.

                  edit ps: @Daniel-8
                  Kannst Du bitte den empfangenen report json hier in </> einstellen.
                  Falls sn mit übermittelt wurde bitte mit WOB1NHMAMXXXXX3 ersetzen, danke.

                  Ja für properties hat mein Blockly so funktioniert. Der Port ist bei mir Standard auf 80.

                  Mir war es jetzt mal wichtig das ich den Smartmode eben setzen kann und auch gewissermaßen überwachen. Ich habe jetzt mal ein Intervall von 5 Minuten gesetzt und es eben so mit den Texteilen abgefragt.

                  Was meinst du mit ein js als Vorlage schreiben? ich kenne mich da eigentlich nicht aus mit js. Ich würde schon gerne JSON parsen aber bin noch nicht dahinter gestiegen wie das geht. Ich kann halt ein bisschen Blockly und da komme ich auch oft an meine Grenzen.

                  Anbei noch den empfangenen Report json

                  {"timestamp":1758649975,"messageId":25,"sn":"EXXXXXXXXXXXXX0","version":2,"product":"solarFlow800Pro","properties":{"heatState":0,"packInputPower":0,"outputPackPower":0,"outputHomePower":0,"remainOutTime":59940,"packState":0,"electricLevel":15,"gridInputPower":0,"solarInputPower":0,"solarPower1":0,"solarPower2":0,"solarPower3":0,"solarPower4":0,"pass":0,"reverseState":0,"socStatus":0,"hyperTmp":2881,"gridOffPower":0,"dcStatus":0,"pvStatus":1,"acStatus":0,"dataReady":1,"gridState":1,"BatVolt":4947,"socLimit":2,"writeRsp":0,"acMode":2,"inputLimit":0,"outputLimit":0,"socSet":1000,"minSoc":200,"gridStandard":0,"gridReverse":1,"inverseMaxPower":800,"lampSwitch":0,"gridOffMode":2,"IOTState":2,"Fanmode":1,"Fanspeed":0,"bindstate":0,"factoryModeState":0,"OTAState":0,"LCNState":0,"oldMode":0,"VoltWakeup":0,"ts":1758649841,"tsZone":14,"smartMode":1,"chargeMaxLimit":1000,"packNum":2,"rssi":-75,"is_error":0},"packData":[{"sn":"COXXXXXXXXXXXX9","packType":300,"socLevel":15,"state":0,"power":0,"maxTemp":2861,"totalVol":4930,"batcur":0,"maxVol":329,"minVol":328,"softVersion":4117},{"sn":"COXXXXXXXXXXXX7","packType":300,"socLevel":15,"state":0,"power":0,"maxTemp":2851,"totalVol":4910,"batcur":0,"maxVol":328,"minVol":327,"softVersion":4117}]}
                  
                  maxclaudiM Offline
                  maxclaudiM Offline
                  maxclaudi
                  wrote on last edited by maxclaudi
                  #8

                  @daniel-8

                  wenn iob bei Dir auf linux aufgesetzt ist, dann funktioniert curl und ist ganz schnell per Blockly einsetzbar, um smartMode:1 zu setzen:

                  ea505bea-5081-4f04-9ade-89470339fd47-image.png

                  <xml xmlns="https://developers.google.com/blockly/xml">
                    <variables>
                      <variable id="|Z4cG|;~p^V_u}/qKz+(">ip</variable>
                      <variable id="O:5c2*j=w)/flfe{j8a8">sn</variable>
                      <variable id="h@E[D.%?+^5d8toyKvSv">curlStep01</variable>
                      <variable id="y_{I%DT%0WG:U-I0P#8q">curlStep02</variable>
                      <variable id="$a83^wpdf;SuP~Ia2YO=">curlStep03</variable>
                      <variable id="`cI]q|W2l-MVi9#b;$})">setSmartMode1</variable>
                    </variables>
                    <block type="comment" id="51aEJOC6-o0}A@uW11@g" x="-238" y="-613">
                      <field name="COMMENT">IP und SN eingeben</field>
                      <next>
                        <block type="variables_set" id=".oeX3r2;4.g7S6(It5JR">
                          <field name="VAR" id="|Z4cG|;~p^V_u}/qKz+(">ip</field>
                          <value name="VALUE">
                            <block type="text" id="nWb3;8kX0MZ[ss4X^W:A">
                              <field name="TEXT">192.168.177.103</field>
                            </block>
                          </value>
                          <next>
                            <block type="variables_set" id="|/(|DlHe=w0^i9j^coB3">
                              <field name="VAR" id="O:5c2*j=w)/flfe{j8a8">sn</field>
                              <value name="VALUE">
                                <block type="text" id="2]Eabc@R0v$p[vK};L}c">
                                  <field name="TEXT">WOB1NHMAMXXXXX3</field>
                                </block>
                              </value>
                              <next>
                                <block type="comment" id="1e7De%bg@z@:_AfkfBh2">
                                  <field name="COMMENT">folgende nicht aendern</field>
                                  <next>
                                    <block type="variables_set" id="bx~@K[1]qaabwEi/31N-">
                                      <field name="VAR" id="h@E[D.%?+^5d8toyKvSv">curlStep01</field>
                                      <value name="VALUE">
                                        <block type="text" id="d6k;T_QsdAJ/B=%3gCfH">
                                          <field name="TEXT">curl -X POST "http://</field>
                                        </block>
                                      </value>
                                      <next>
                                        <block type="variables_set" id=";YsKp]sCUl[bw[xo,2~,">
                                          <field name="VAR" id="y_{I%DT%0WG:U-I0P#8q">curlStep02</field>
                                          <value name="VALUE">
                                            <block type="text" id="Pn1e0e4{A_a1)`YXdTP!">
                                              <field name="TEXT">/properties/write" -H "Content-Type: application/json" -d '{"sn":"</field>
                                            </block>
                                          </value>
                                          <next>
                                            <block type="variables_set" id="w--~T=$|r@CRxgfzY}5o">
                                              <field name="VAR" id="$a83^wpdf;SuP~Ia2YO=">curlStep03</field>
                                              <value name="VALUE">
                                                <block type="text" id="1.n;UnaAm(APP=[,jmQa">
                                                  <field name="TEXT">","properties":{"smartMode":1}}'</field>
                                                </block>
                                              </value>
                                              <next>
                                                <block type="variables_set" id="^%B|M{-7-{?u!z6wO:|.">
                                                  <field name="VAR" id="`cI]q|W2l-MVi9#b;$})">setSmartMode1</field>
                                                  <value name="VALUE">
                                                    <block type="text_join" id="ZK_cH*:XIVwvaCt~Z@M9">
                                                      <mutation items="5"></mutation>
                                                      <value name="ADD0">
                                                        <block type="variables_get" id="{`.{)rX:%J=?C5tt]4x?">
                                                          <field name="VAR" id="h@E[D.%?+^5d8toyKvSv">curlStep01</field>
                                                        </block>
                                                      </value>
                                                      <value name="ADD1">
                                                        <block type="variables_get" id="!Hf,PQ-wzXYpoYCE+w:J">
                                                          <field name="VAR" id="|Z4cG|;~p^V_u}/qKz+(">ip</field>
                                                        </block>
                                                      </value>
                                                      <value name="ADD2">
                                                        <block type="variables_get" id="T^n2l,6}q3OiYc*+2yuB">
                                                          <field name="VAR" id="y_{I%DT%0WG:U-I0P#8q">curlStep02</field>
                                                        </block>
                                                      </value>
                                                      <value name="ADD3">
                                                        <block type="variables_get" id="^860%_,0?(~Q}:n=1wl}">
                                                          <field name="VAR" id="O:5c2*j=w)/flfe{j8a8">sn</field>
                                                        </block>
                                                      </value>
                                                      <value name="ADD4">
                                                        <block type="variables_get" id="#RK:~jVJCO_Q,0|QhR7{">
                                                          <field name="VAR" id="$a83^wpdf;SuP~Ia2YO=">curlStep03</field>
                                                        </block>
                                                      </value>
                                                    </block>
                                                  </value>
                                                  <next>
                                                    <block type="exec" id="U%SOl=kmT:{[KkMi?(ij">
                                                      <mutation xmlns="http://www.w3.org/1999/xhtml" with_statement="true"></mutation>
                                                      <field name="WITH_STATEMENT">TRUE</field>
                                                      <field name="LOG"></field>
                                                      <value name="COMMAND">
                                                        <shadow type="text" id="VUO-L0/%TiX`zWm?M%,B">
                                                          <field name="TEXT">pwd</field>
                                                        </shadow>
                                                        <block type="variables_get" id="O42bN62/QhV^+$0ZO@Is">
                                                          <field name="VAR" id="`cI]q|W2l-MVi9#b;$})">setSmartMode1</field>
                                                        </block>
                                                      </value>
                                                      <statement name="STATEMENT">
                                                        <block type="debug" id="@}R)#^y*MNj~Dy(k~:VJ">
                                                          <field name="Severity">info</field>
                                                          <value name="TEXT">
                                                            <shadow type="text" id="N3VZo-KJ)D5+o2}AEh;-">
                                                              <field name="TEXT">test</field>
                                                            </shadow>
                                                            <block type="exec_result" id=")u=f{;W5bJ$o/M}!T,$_">
                                                              <field name="ATTR">result</field>
                                                            </block>
                                                          </value>
                                                        </block>
                                                      </statement>
                                                    </block>
                                                  </next>
                                                </block>
                                              </next>
                                            </block>
                                          </next>
                                        </block>
                                      </next>
                                    </block>
                                  </next>
                                </block>
                              </next>
                            </block>
                          </next>
                        </block>
                      </next>
                    </block>
                  </xml>
                  

                  Kann man auch in HTTP Post umsetzen wie Dein HTTP-get in Blockly.

                  Genug geklickt 🙂

                  Mit Vorlage meinte ich ein eigenständiges js.
                  Das dann nur als js statt blockly verwendest, einfügst und speicherst.
                  Bevor es gestartet wird musst Du dann nur

                  • zendure device IP
                  • zendure sn einfügen.
                  • dp eingeben, die Du zuvor manuell angelegt hast
                    (könnte man auch automatisch erstellen lassen)
                    Speichern und starten.

                  Damit verhält sich das script wie ein Adapter.
                  Du liest oder steuerst einfach die Datenpunkte, wie bei einem Adapter.
                  Mit extra js oder extra Blockly(s).

                  Ich schreibe meistens sehr direkt – bitte nicht falsch verstehen, es ist nie böse gemeint. Das ist einfach mein Stil und niemals abwertend gemeint.

                  1 Reply Last reply
                  0
                  • D Daniel 8

                    @maxclaudi sagte in Zendure SmartMode:1 SolarFlow2400 AC SolarFlow800 ( u. Pro):

                    @daniel-8
                    Für properties hat Dein Blockly so funktioniert?

                    • Dann ist es Standardport:80 und muss nicht extra angegeben werden.
                    • IP von zendure-device wird benötigt read only
                    • sn von zendue-device wird zusätzlich benötigt für set

                    🙂 👍

                    So schwer ist das nicht.
                    Was möchtest haben? Ziel(e)?

                    Vielleicht erst Brainstorming

                    • Evtl. x min report pollen.
                    • JSON parsen.
                    • bestimmte Datenpunkte (die es noch nicht gibt?) mit den Werten aktualisieren.
                    • neue dp die beschreibbar sind unter ein folder cmd übernehmen.

                    oder nur smartMode?

                    Würde ein js als Vorlage schreiben. Datenpunkte können ja dann mit Blockly oder js verwendet werden.
                    Ein Blockly kann man immer noch machen?

                    @Daniel-8 und @Michi-0 macht Euch mal Gedanken.

                    edit ps: @Daniel-8
                    Kannst Du bitte den empfangenen report json hier in </> einstellen.
                    Falls sn mit übermittelt wurde bitte mit WOB1NHMAMXXXXX3 ersetzen, danke.

                    Ja für properties hat mein Blockly so funktioniert. Der Port ist bei mir Standard auf 80.

                    Mir war es jetzt mal wichtig das ich den Smartmode eben setzen kann und auch gewissermaßen überwachen. Ich habe jetzt mal ein Intervall von 5 Minuten gesetzt und es eben so mit den Texteilen abgefragt.

                    Was meinst du mit ein js als Vorlage schreiben? ich kenne mich da eigentlich nicht aus mit js. Ich würde schon gerne JSON parsen aber bin noch nicht dahinter gestiegen wie das geht. Ich kann halt ein bisschen Blockly und da komme ich auch oft an meine Grenzen.

                    Anbei noch den empfangenen Report json

                    {"timestamp":1758649975,"messageId":25,"sn":"EXXXXXXXXXXXXX0","version":2,"product":"solarFlow800Pro","properties":{"heatState":0,"packInputPower":0,"outputPackPower":0,"outputHomePower":0,"remainOutTime":59940,"packState":0,"electricLevel":15,"gridInputPower":0,"solarInputPower":0,"solarPower1":0,"solarPower2":0,"solarPower3":0,"solarPower4":0,"pass":0,"reverseState":0,"socStatus":0,"hyperTmp":2881,"gridOffPower":0,"dcStatus":0,"pvStatus":1,"acStatus":0,"dataReady":1,"gridState":1,"BatVolt":4947,"socLimit":2,"writeRsp":0,"acMode":2,"inputLimit":0,"outputLimit":0,"socSet":1000,"minSoc":200,"gridStandard":0,"gridReverse":1,"inverseMaxPower":800,"lampSwitch":0,"gridOffMode":2,"IOTState":2,"Fanmode":1,"Fanspeed":0,"bindstate":0,"factoryModeState":0,"OTAState":0,"LCNState":0,"oldMode":0,"VoltWakeup":0,"ts":1758649841,"tsZone":14,"smartMode":1,"chargeMaxLimit":1000,"packNum":2,"rssi":-75,"is_error":0},"packData":[{"sn":"COXXXXXXXXXXXX9","packType":300,"socLevel":15,"state":0,"power":0,"maxTemp":2861,"totalVol":4930,"batcur":0,"maxVol":329,"minVol":328,"softVersion":4117},{"sn":"COXXXXXXXXXXXX7","packType":300,"socLevel":15,"state":0,"power":0,"maxTemp":2851,"totalVol":4910,"batcur":0,"maxVol":328,"minVol":327,"softVersion":4117}]}
                    
                    maxclaudiM Offline
                    maxclaudiM Offline
                    maxclaudi
                    wrote on last edited by maxclaudi
                    #9

                    @daniel-8

                    sieht gut aus

                    {
                      "timestamp": 1758649975,
                      "messageId": 25,
                      "sn": "EXXXXXXXXXXXXX0",
                      "version": 2,
                      "product": "solarFlow800Pro",
                      "properties": {
                        "heatState": 0,
                        "packInputPower": 0,
                        "outputPackPower": 0,
                        "outputHomePower": 0,
                        "remainOutTime": 59940,
                        "packState": 0,
                        "electricLevel": 15,
                        "gridInputPower": 0,
                        "solarInputPower": 0,
                        "solarPower1": 0,
                        "solarPower2": 0,
                        "solarPower3": 0,
                        "solarPower4": 0,
                        "pass": 0,
                        "reverseState": 0,
                        "socStatus": 0,
                        "hyperTmp": 2881,
                        "gridOffPower": 0,
                        "dcStatus": 0,
                        "pvStatus": 1,
                        "acStatus": 0,
                        "dataReady": 1,
                        "gridState": 1,
                        "BatVolt": 4947,
                        "socLimit": 2,
                        "writeRsp": 0,
                        "acMode": 2,
                        "inputLimit": 0,
                        "outputLimit": 0,
                        "socSet": 1000,
                        "minSoc": 200,
                        "gridStandard": 0,
                        "gridReverse": 1,
                        "inverseMaxPower": 800,
                        "lampSwitch": 0,
                        "gridOffMode": 2,
                        "IOTState": 2,
                        "Fanmode": 1,
                        "Fanspeed": 0,
                        "bindstate": 0,
                        "factoryModeState": 0,
                        "OTAState": 0,
                        "LCNState": 0,
                        "oldMode": 0,
                        "VoltWakeup": 0,
                        "ts": 1758649841,
                        "tsZone": 14,
                        "smartMode": 1,
                        "chargeMaxLimit": 1000,
                        "packNum": 2,
                        "rssi": -75,
                        "is_error": 0
                      },
                      "packData": [
                        {
                          "sn": "COXXXXXXXXXXXX9",
                          "packType": 300,
                          "socLevel": 15,
                          "state": 0,
                          "power": 0,
                          "maxTemp": 2861,
                          "totalVol": 4930,
                          "batcur": 0,
                          "maxVol": 329,
                          "minVol": 328,
                          "softVersion": 4117
                        },
                        {
                          "sn": "COXXXXXXXXXXXX7",
                          "packType": 300,
                          "socLevel": 15,
                          "state": 0,
                          "power": 0,
                          "maxTemp": 2851,
                          "totalVol": 4910,
                          "batcur": 0,
                          "maxVol": 328,
                          "minVol": 327,
                          "softVersion": 4117
                        }
                      ]
                    }
                    

                    maxTemp: 2851 -> 14,95°C. ist bestimmt outside.

                    Ich schreibe meistens sehr direkt – bitte nicht falsch verstehen, es ist nie böse gemeint. Das ist einfach mein Stil und niemals abwertend gemeint.

                    1 Reply Last reply
                    0
                    • D Online
                      D Online
                      Daniel 8
                      wrote on last edited by
                      #10

                      @maxclaudi

                      was meinst mit sieht gut aus?

                      Solarflow 800 Pro mit 1,3 Kwp / Iobroker / Homematic / Shellys / Mediola / Intertechno

                      maxclaudiM 1 Reply Last reply
                      0
                      • D Daniel 8

                        @maxclaudi

                        was meinst mit sieht gut aus?

                        maxclaudiM Offline
                        maxclaudiM Offline
                        maxclaudi
                        wrote on last edited by maxclaudi
                        #11

                        @daniel-8 sagte in Zendure SmartMode:1 SolarFlow2400 AC SolarFlow800 ( u. Pro):

                        @maxclaudi

                        was meinst mit sieht gut aus?

                        dass json quasi genau so aufgebaut ist, wie bisher auch (mqtt, alte Geräte).
                        Leicht auszuwerten 🙂

                        eigentlich nur properties und Akku(s) -> packData array.

                        Ich schreibe meistens sehr direkt – bitte nicht falsch verstehen, es ist nie böse gemeint. Das ist einfach mein Stil und niemals abwertend gemeint.

                        D 1 Reply Last reply
                        0
                        • maxclaudiM maxclaudi

                          @daniel-8 sagte in Zendure SmartMode:1 SolarFlow2400 AC SolarFlow800 ( u. Pro):

                          @maxclaudi

                          was meinst mit sieht gut aus?

                          dass json quasi genau so aufgebaut ist, wie bisher auch (mqtt, alte Geräte).
                          Leicht auszuwerten 🙂

                          eigentlich nur properties und Akku(s) -> packData array.

                          D Online
                          D Online
                          Daniel 8
                          wrote on last edited by
                          #12

                          @maxclaudi

                          Wenn du mir vielleicht noch verrätst wie?

                          Danke für das Blockly mit curl. Funktioniert 1A

                          Solarflow 800 Pro mit 1,3 Kwp / Iobroker / Homematic / Shellys / Mediola / Intertechno

                          1 Reply Last reply
                          0
                          • maxclaudiM maxclaudi

                            @daniel-8
                            Für properties hat Dein Blockly so funktioniert?

                            • Dann ist es Standardport:80 und muss nicht extra angegeben werden.
                            • IP von zendure-device wird benötigt read only
                            • sn von zendue-device wird zusätzlich benötigt für set

                            🙂 👍

                            So schwer ist das nicht.
                            Was möchtest haben? Ziel(e)?

                            Vielleicht erst Brainstorming

                            • Evtl. x min report pollen.
                            • JSON parsen.
                            • bestimmte Datenpunkte (die es noch nicht gibt?) mit den Werten aktualisieren.
                            • neue dp die beschreibbar sind unter ein folder cmd übernehmen.

                            oder nur smartMode?

                            Würde ein js als Vorlage schreiben. Datenpunkte können ja dann mit Blockly oder js verwendet werden.
                            Ein Blockly kann man immer noch machen?

                            @Daniel-8 und @Michi-0 macht Euch mal Gedanken.

                            edit ps: @Daniel-8
                            Kannst Du bitte den empfangenen report json hier in </> einstellen.
                            Falls sn mit übermittelt wurde bitte mit WOB1NHMAMXXXXX3 ersetzen, danke.

                            M Offline
                            M Offline
                            Michi 0
                            wrote on last edited by
                            #13

                            @maxclaudi
                            Ihr habt ein Tempo...

                            Mir würde vermutlich reichen, wenn mir der SmartMode Status in einem Datenpunkt angezeigt wird und ich den kontrollieren und steuern kann. Den Rest würde ich vermutlich auch weiterhin nur über MQTT machen.

                            Alternativ:
                            Alle über MQTT abrufbaren Datenpunkte und den SmartMode Datenpunkt in einem Adapter zusammenfassen. Keine Ahnung was das für einen Aufwand macht. Adpater zu erstellen hat für mich was von schwarzer Magie 😉

                            D maxclaudiM 3 Replies Last reply
                            0
                            • M Michi 0

                              @maxclaudi
                              Ihr habt ein Tempo...

                              Mir würde vermutlich reichen, wenn mir der SmartMode Status in einem Datenpunkt angezeigt wird und ich den kontrollieren und steuern kann. Den Rest würde ich vermutlich auch weiterhin nur über MQTT machen.

                              Alternativ:
                              Alle über MQTT abrufbaren Datenpunkte und den SmartMode Datenpunkt in einem Adapter zusammenfassen. Keine Ahnung was das für einen Aufwand macht. Adpater zu erstellen hat für mich was von schwarzer Magie 😉

                              D Online
                              D Online
                              Daniel 8
                              wrote on last edited by
                              #14

                              @michi-0

                              Ist nur weil ich grad nichts machen kann und mit Bänderiss im Fuß nur rumsitzen kann. Deswegen habe ich soviel Zeit gerade

                              Solarflow 800 Pro mit 1,3 Kwp / Iobroker / Homematic / Shellys / Mediola / Intertechno

                              1 Reply Last reply
                              0
                              • M Michi 0

                                @maxclaudi
                                Ihr habt ein Tempo...

                                Mir würde vermutlich reichen, wenn mir der SmartMode Status in einem Datenpunkt angezeigt wird und ich den kontrollieren und steuern kann. Den Rest würde ich vermutlich auch weiterhin nur über MQTT machen.

                                Alternativ:
                                Alle über MQTT abrufbaren Datenpunkte und den SmartMode Datenpunkt in einem Adapter zusammenfassen. Keine Ahnung was das für einen Aufwand macht. Adpater zu erstellen hat für mich was von schwarzer Magie 😉

                                maxclaudiM Offline
                                maxclaudiM Offline
                                maxclaudi
                                wrote on last edited by
                                #15

                                @michi-0 @Daniel-8
                                Sorry muss früh raus.

                                Ich schreibe meistens sehr direkt – bitte nicht falsch verstehen, es ist nie böse gemeint. Das ist einfach mein Stil und niemals abwertend gemeint.

                                1 Reply Last reply
                                0
                                • M Michi 0

                                  @maxclaudi
                                  Ihr habt ein Tempo...

                                  Mir würde vermutlich reichen, wenn mir der SmartMode Status in einem Datenpunkt angezeigt wird und ich den kontrollieren und steuern kann. Den Rest würde ich vermutlich auch weiterhin nur über MQTT machen.

                                  Alternativ:
                                  Alle über MQTT abrufbaren Datenpunkte und den SmartMode Datenpunkt in einem Adapter zusammenfassen. Keine Ahnung was das für einen Aufwand macht. Adpater zu erstellen hat für mich was von schwarzer Magie 😉

                                  maxclaudiM Offline
                                  maxclaudiM Offline
                                  maxclaudi
                                  wrote on last edited by maxclaudi
                                  #16

                                  @michi-0 sagte in Zendure SmartMode:1 SolarFlow2400 AC SolarFlow800 ( u. Pro):

                                  @maxclaudi
                                  Ihr habt ein Tempo...

                                  Mir würde vermutlich reichen, wenn mir der SmartMode Status in einem Datenpunkt angezeigt wird und ich den kontrollieren und steuern kann. Den Rest würde ich vermutlich auch weiterhin nur über MQTT machen.

                                  👍

                                  Zendure hat auch angekündigt, dass sie den Datenpunkt irgendwann auch aufnehmen werden, dann wäre alles andere überflüssig.
                                  Aber wenn nicht oder bis dahin hier die Lösungen.
                                  2 Scripte, die von den Funktionen identisch sind.
                                  Script 1: nur für iob unter Linux.
                                  Srcipt 2: plattformunabhängig, also auch für Windows.

                                  @Daniel-8 und @Michi-0 , bitte testen:


                                  Beschreibung für beide scripts:
                                  Script hat folgende Funktion:

                                  • Alle 60 Sekunden (anpassbar) wird properties/report geholt.
                                  • timestamp wird in ein lesbares Datum umgewandelt und in dpTimestamp geschrieben.
                                  • Aktueller smartMode wird in dpSmartModeInfo geschrieben (read only).
                                  • Wenn man setSmartMode mit 0 oder 1 steuert, sendet das Script automatisch einen POST an /properties/write und schreibt "ok" oder "error" in setResult.

                                  Beim Start werden vier Datenpunkte erstellt.
                                  Diese können oben im script konfiguriert werden.

                                  const dpSmartModeInfo = "0_userdata.0.zendureSmartMode.smartModeInfo";
                                  const dpSetSmartMode = "0_userdata.0.zendureSmartMode.setSmartMode";
                                  const dpSetSmartModeResult = "0_userdata.0.zendureSmartMode.setResult";
                                  const dpTimestamp = "0_userdata.0.zendureSmartMode.timestamp";

                                  60 Sekunden Interval ist unkritisch und aktuell.
                                  Bei Bedarf kann das auch oben im Script geändert werden:
                                  const intervalGet = 60; // Sekunden

                                  Oben trägt man auch die IP und Seriennummer des Zendure Geräts ein:

                                  const IP = "192.168.177.103"; // IP Zendure
                                  const SN = "EXXXXXXXXXXXXX0"; // Seriennummer Zendure

                                  Die Datenpunkte können mit anderen scripts / Blocklys gelesen werden oder dpSetSmartMode auf 1 oder 0 gesetzt werden.
                                  smartMode:1 ist wichtig.


                                  Script 1, mit curl umgesetzt, funktioniert nur wenn iob auf Linux läuft:

                                  // konfiguration
                                  
                                  const dpSmartModeInfo    = "0_userdata.0.zendureSmartMode.smartModeInfo";
                                  const dpSetSmartMode     = "0_userdata.0.zendureSmartMode.setSmartMode";
                                  const dpSetSmartModeResult = "0_userdata.0.zendureSmartMode.setResult";
                                  const dpTimestamp        = "0_userdata.0.zendureSmartMode.timestamp";
                                  
                                  const intervalGet = 60;                 // Sekunden
                                  const IP = "192.168.177.103";           // IP des Zendure Geräts
                                  const SN = "EXXXXXXXXXXXXX0";           // Seriennummer
                                  
                                  //-----------
                                  // dp anlegen
                                  
                                  createState(dpSmartModeInfo, 0, {
                                      name: "SmartMode Info",
                                      type: "number",
                                      role: "state",
                                      read: true,
                                      write: false,
                                      min: 0,
                                      max: 1
                                  }, () => {});
                                  
                                  createState(dpSetSmartMode, 0, {
                                      name: "SmartMode Set",
                                      type: "number",
                                      role: "state",
                                      read: true,
                                      write: true,
                                      min: 0,
                                      max: 1
                                  }, () => {});
                                  
                                  createState(dpSetSmartModeResult, "", {
                                      name: "SmartMode Set Result",
                                      type: "string",
                                      role: "info",
                                      read: true,
                                      write: false
                                  }, () => {});
                                  
                                  createState(dpTimestamp, "", {
                                      name: "Timestamp",
                                      type: "string",
                                      role: "info",
                                      read: true,
                                      write: false
                                  }, () => {});
                                  
                                  
                                  // time
                                  
                                  function formatTime(ts) {
                                      // ts ist Unix Sekunden
                                      const d = new Date(ts * 1000);
                                      const pad = n => n.toString().padStart(2, "0");
                                      return `${pad(d.getDate())}.${pad(d.getMonth()+1)}.${d.getFullYear().toString().slice(-2)} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
                                  }
                                  
                                  
                                  //curl HTTP GET
                                  
                                  function getReport() {
                                      const cmd = `curl -s "http://${IP}/properties/report"`;
                                      exec(cmd, (error, stdout, stderr) => {
                                          if (error) {
                                              console.error("GET Fehler:", stderr);
                                              return;
                                          }
                                          try {
                                              const data = JSON.parse(stdout);
                                              if (data && data.timestamp) {
                                                  setState(dpTimestamp, formatTime(data.timestamp), true);
                                              }
                                              if (data && data.properties && typeof data.properties.smartMode !== "undefined") {
                                                  setState(dpSmartModeInfo, data.properties.smartMode, true);
                                              }
                                          } catch (e) {
                                              console.error("JSON Parse Fehler:", e);
                                          }
                                      });
                                  }
                                  
                                  
                                  //curl HTTP POST zum Setzen
                                  
                                  function setSmartMode(val) {
                                      const payload = `{"sn":"${SN}","properties":{"smartMode":${val}}}`;
                                      const cmd = `curl -s -X POST "http://${IP}/properties/write" -H "Content-Type: application/json" -d '${payload}'`;
                                      exec(cmd, (error, stdout, stderr) => {
                                          if (error) {
                                              console.error("POST Fehler:", stderr);
                                              setState(dpSetSmartModeResult, "error", true);
                                              return;
                                          }
                                          setState(dpSetSmartModeResult, "ok", true);
                                      });
                                  }
                                  
                                  
                                  // interval
                                  
                                  getReport();  // sofort bei start
                                  schedule(`*/${intervalGet} * * * * *`, getReport); // alle x Sekunden
                                  
                                  // trigger wenn SmartMode gesetzt wird
                                  
                                  on({id: dpSetSmartMode, ack: false}, obj => {
                                      const val = parseInt(obj.state.val, 10);
                                      if (val === 0 || val === 1) {
                                          setSmartMode(val);
                                      }
                                  });
                                  

                                  Script 2:
                                  Funktionen identisch zum ersten.
                                  Skript ist plattformunabhängig und sollte damit für Windows-Installationen von ioBroker funktionieren (ungetestet).
                                  Statt curl werden ioBroker/Node.js vorhandene Standardbibliotheken (http und https) verwendet.

                                  // konfiguration
                                  const dpSmartModeInfo      = "0_userdata.0.zendureSmartMode.smartModeInfo";
                                  const dpSetSmartMode       = "0_userdata.0.zendureSmartMode.setSmartMode";
                                  const dpSetSmartModeResult = "0_userdata.0.zendureSmartMode.setResult";
                                  const dpTimestamp          = "0_userdata.0.zendureSmartMode.timestamp";
                                  
                                  const intervalGet = 60;                 // Sekunden
                                  const IP = "192.168.177.103";           // IP des Zendure Geräts
                                  const SN = "EXXXXXXXXXXXXX0";           // Seriennummer
                                  
                                  const http = require("http");           // Node.js Standardmodul
                                  
                                  
                                  //-----------
                                  // dp
                                  
                                  createState(dpSmartModeInfo, 0, {
                                      name: "SmartMode Info",
                                      type: "number",
                                      role: "state",
                                      read: true,
                                      write: false,
                                      min: 0,
                                      max: 1
                                  }, () => {});
                                  
                                  createState(dpSetSmartMode, 0, {
                                      name: "SmartMode Set",
                                      type: "number",
                                      role: "state",
                                      read: true,
                                      write: true,
                                      min: 0,
                                      max: 1
                                  }, () => {});
                                  
                                  createState(dpSetSmartModeResult, "", {
                                      name: "SmartMode Set Result",
                                      type: "string",
                                      role: "info",
                                      read: true,
                                      write: false
                                  }, () => {});
                                  
                                  createState(dpTimestamp, "", {
                                      name: "Timestamp",
                                      type: "string",
                                      role: "info",
                                      read: true,
                                      write: false
                                  }, () => {});
                                  
                                  
                                  // time
                                  
                                  function formatTime(ts) {
                                      const d = new Date(ts * 1000);
                                      const pad = n => n.toString().padStart(2, "0");
                                      return `${pad(d.getDate())}.${pad(d.getMonth()+1)}.${d.getFullYear().toString().slice(-2)} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
                                  }
                                  
                                  
                                  //HTTP GET
                                  
                                  function getReport() {
                                      const options = {
                                          hostname: IP,
                                          port: 80,
                                          path: "/properties/report",
                                          method: "GET",
                                          timeout: 3000
                                      };
                                  
                                      const req = http.request(options, res => {
                                          let data = "";
                                          res.on("data", chunk => data += chunk);
                                          res.on("end", () => {
                                              try {
                                                  const json = JSON.parse(data);
                                                  if (json.timestamp) {
                                                      setState(dpTimestamp, formatTime(json.timestamp), true);
                                                  }
                                                  if (json.properties && typeof json.properties.smartMode !== "undefined") {
                                                      setState(dpSmartModeInfo, json.properties.smartMode, true);
                                                  }
                                              } catch (e) {
                                                  console.error("GET JSON Parse Fehler:", e);
                                              }
                                          });
                                      });
                                  
                                      req.on("error", err => console.error("HTTP GET Fehler:", err.message));
                                      req.end();
                                  }
                                  
                                  
                                  //HTTP POST zum Setzen
                                  
                                  function setSmartMode(val) {
                                      const payload = JSON.stringify({
                                          sn: SN,
                                          properties: { smartMode: val }
                                      });
                                  
                                      const options = {
                                          hostname: IP,
                                          port: 80,
                                          path: "/properties/write",
                                          method: "POST",
                                          headers: {
                                              "Content-Type": "application/json",
                                              "Content-Length": Buffer.byteLength(payload)
                                          },
                                          timeout: 3000
                                      };
                                  
                                      const req = http.request(options, res => {
                                          let data = "";
                                          res.on("data", chunk => data += chunk);
                                          res.on("end", () => {
                                              if (res.statusCode >= 200 && res.statusCode < 300) {
                                                  setState(dpSetSmartModeResult, "ok", true);
                                              } else {
                                                  console.error("POST Antwort:", res.statusCode, data);
                                                  setState(dpSetSmartModeResult, "error", true);
                                              }
                                          });
                                      });
                                  
                                      req.on("error", err => {
                                          console.error("HTTP POST Fehler:", err.message);
                                          setState(dpSetSmartModeResult, "error", true);
                                      });
                                  
                                      req.write(payload);
                                      req.end();
                                  }
                                  
                                  
                                  // interval
                                  
                                  getReport();  // sofort einmal abrufen
                                  schedule(`*/${intervalGet} * * * * *`, getReport); // alle x Sekunden
                                  
                                  
                                  // trigger wenn SmartMode gesetzt wird
                                  
                                  on({id: dpSetSmartMode, ack: false}, obj => {
                                      const val = parseInt(obj.state.val, 10);
                                      if (val === 0 || val === 1) {
                                          setSmartMode(val);
                                      }
                                  });
                                  

                                  Hinweis: Bei den Scripts wird davon ausgegangen, dass Zendure für HTTP den Standarport 80 verwendet wie von @Daniel-8 getestet.
                                  Wenn es bei jemand nicht so sein sollte, dann im script die 2 Port (port: 80,) bei Get und POST anpassen.

                                  Ich schreibe meistens sehr direkt – bitte nicht falsch verstehen, es ist nie böse gemeint. Das ist einfach mein Stil und niemals abwertend gemeint.

                                  D M Rene55R 3 Replies Last reply
                                  1
                                  • maxclaudiM maxclaudi

                                    @michi-0 sagte in Zendure SmartMode:1 SolarFlow2400 AC SolarFlow800 ( u. Pro):

                                    @maxclaudi
                                    Ihr habt ein Tempo...

                                    Mir würde vermutlich reichen, wenn mir der SmartMode Status in einem Datenpunkt angezeigt wird und ich den kontrollieren und steuern kann. Den Rest würde ich vermutlich auch weiterhin nur über MQTT machen.

                                    👍

                                    Zendure hat auch angekündigt, dass sie den Datenpunkt irgendwann auch aufnehmen werden, dann wäre alles andere überflüssig.
                                    Aber wenn nicht oder bis dahin hier die Lösungen.
                                    2 Scripte, die von den Funktionen identisch sind.
                                    Script 1: nur für iob unter Linux.
                                    Srcipt 2: plattformunabhängig, also auch für Windows.

                                    @Daniel-8 und @Michi-0 , bitte testen:


                                    Beschreibung für beide scripts:
                                    Script hat folgende Funktion:

                                    • Alle 60 Sekunden (anpassbar) wird properties/report geholt.
                                    • timestamp wird in ein lesbares Datum umgewandelt und in dpTimestamp geschrieben.
                                    • Aktueller smartMode wird in dpSmartModeInfo geschrieben (read only).
                                    • Wenn man setSmartMode mit 0 oder 1 steuert, sendet das Script automatisch einen POST an /properties/write und schreibt "ok" oder "error" in setResult.

                                    Beim Start werden vier Datenpunkte erstellt.
                                    Diese können oben im script konfiguriert werden.

                                    const dpSmartModeInfo = "0_userdata.0.zendureSmartMode.smartModeInfo";
                                    const dpSetSmartMode = "0_userdata.0.zendureSmartMode.setSmartMode";
                                    const dpSetSmartModeResult = "0_userdata.0.zendureSmartMode.setResult";
                                    const dpTimestamp = "0_userdata.0.zendureSmartMode.timestamp";

                                    60 Sekunden Interval ist unkritisch und aktuell.
                                    Bei Bedarf kann das auch oben im Script geändert werden:
                                    const intervalGet = 60; // Sekunden

                                    Oben trägt man auch die IP und Seriennummer des Zendure Geräts ein:

                                    const IP = "192.168.177.103"; // IP Zendure
                                    const SN = "EXXXXXXXXXXXXX0"; // Seriennummer Zendure

                                    Die Datenpunkte können mit anderen scripts / Blocklys gelesen werden oder dpSetSmartMode auf 1 oder 0 gesetzt werden.
                                    smartMode:1 ist wichtig.


                                    Script 1, mit curl umgesetzt, funktioniert nur wenn iob auf Linux läuft:

                                    // konfiguration
                                    
                                    const dpSmartModeInfo    = "0_userdata.0.zendureSmartMode.smartModeInfo";
                                    const dpSetSmartMode     = "0_userdata.0.zendureSmartMode.setSmartMode";
                                    const dpSetSmartModeResult = "0_userdata.0.zendureSmartMode.setResult";
                                    const dpTimestamp        = "0_userdata.0.zendureSmartMode.timestamp";
                                    
                                    const intervalGet = 60;                 // Sekunden
                                    const IP = "192.168.177.103";           // IP des Zendure Geräts
                                    const SN = "EXXXXXXXXXXXXX0";           // Seriennummer
                                    
                                    //-----------
                                    // dp anlegen
                                    
                                    createState(dpSmartModeInfo, 0, {
                                        name: "SmartMode Info",
                                        type: "number",
                                        role: "state",
                                        read: true,
                                        write: false,
                                        min: 0,
                                        max: 1
                                    }, () => {});
                                    
                                    createState(dpSetSmartMode, 0, {
                                        name: "SmartMode Set",
                                        type: "number",
                                        role: "state",
                                        read: true,
                                        write: true,
                                        min: 0,
                                        max: 1
                                    }, () => {});
                                    
                                    createState(dpSetSmartModeResult, "", {
                                        name: "SmartMode Set Result",
                                        type: "string",
                                        role: "info",
                                        read: true,
                                        write: false
                                    }, () => {});
                                    
                                    createState(dpTimestamp, "", {
                                        name: "Timestamp",
                                        type: "string",
                                        role: "info",
                                        read: true,
                                        write: false
                                    }, () => {});
                                    
                                    
                                    // time
                                    
                                    function formatTime(ts) {
                                        // ts ist Unix Sekunden
                                        const d = new Date(ts * 1000);
                                        const pad = n => n.toString().padStart(2, "0");
                                        return `${pad(d.getDate())}.${pad(d.getMonth()+1)}.${d.getFullYear().toString().slice(-2)} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
                                    }
                                    
                                    
                                    //curl HTTP GET
                                    
                                    function getReport() {
                                        const cmd = `curl -s "http://${IP}/properties/report"`;
                                        exec(cmd, (error, stdout, stderr) => {
                                            if (error) {
                                                console.error("GET Fehler:", stderr);
                                                return;
                                            }
                                            try {
                                                const data = JSON.parse(stdout);
                                                if (data && data.timestamp) {
                                                    setState(dpTimestamp, formatTime(data.timestamp), true);
                                                }
                                                if (data && data.properties && typeof data.properties.smartMode !== "undefined") {
                                                    setState(dpSmartModeInfo, data.properties.smartMode, true);
                                                }
                                            } catch (e) {
                                                console.error("JSON Parse Fehler:", e);
                                            }
                                        });
                                    }
                                    
                                    
                                    //curl HTTP POST zum Setzen
                                    
                                    function setSmartMode(val) {
                                        const payload = `{"sn":"${SN}","properties":{"smartMode":${val}}}`;
                                        const cmd = `curl -s -X POST "http://${IP}/properties/write" -H "Content-Type: application/json" -d '${payload}'`;
                                        exec(cmd, (error, stdout, stderr) => {
                                            if (error) {
                                                console.error("POST Fehler:", stderr);
                                                setState(dpSetSmartModeResult, "error", true);
                                                return;
                                            }
                                            setState(dpSetSmartModeResult, "ok", true);
                                        });
                                    }
                                    
                                    
                                    // interval
                                    
                                    getReport();  // sofort bei start
                                    schedule(`*/${intervalGet} * * * * *`, getReport); // alle x Sekunden
                                    
                                    // trigger wenn SmartMode gesetzt wird
                                    
                                    on({id: dpSetSmartMode, ack: false}, obj => {
                                        const val = parseInt(obj.state.val, 10);
                                        if (val === 0 || val === 1) {
                                            setSmartMode(val);
                                        }
                                    });
                                    

                                    Script 2:
                                    Funktionen identisch zum ersten.
                                    Skript ist plattformunabhängig und sollte damit für Windows-Installationen von ioBroker funktionieren (ungetestet).
                                    Statt curl werden ioBroker/Node.js vorhandene Standardbibliotheken (http und https) verwendet.

                                    // konfiguration
                                    const dpSmartModeInfo      = "0_userdata.0.zendureSmartMode.smartModeInfo";
                                    const dpSetSmartMode       = "0_userdata.0.zendureSmartMode.setSmartMode";
                                    const dpSetSmartModeResult = "0_userdata.0.zendureSmartMode.setResult";
                                    const dpTimestamp          = "0_userdata.0.zendureSmartMode.timestamp";
                                    
                                    const intervalGet = 60;                 // Sekunden
                                    const IP = "192.168.177.103";           // IP des Zendure Geräts
                                    const SN = "EXXXXXXXXXXXXX0";           // Seriennummer
                                    
                                    const http = require("http");           // Node.js Standardmodul
                                    
                                    
                                    //-----------
                                    // dp
                                    
                                    createState(dpSmartModeInfo, 0, {
                                        name: "SmartMode Info",
                                        type: "number",
                                        role: "state",
                                        read: true,
                                        write: false,
                                        min: 0,
                                        max: 1
                                    }, () => {});
                                    
                                    createState(dpSetSmartMode, 0, {
                                        name: "SmartMode Set",
                                        type: "number",
                                        role: "state",
                                        read: true,
                                        write: true,
                                        min: 0,
                                        max: 1
                                    }, () => {});
                                    
                                    createState(dpSetSmartModeResult, "", {
                                        name: "SmartMode Set Result",
                                        type: "string",
                                        role: "info",
                                        read: true,
                                        write: false
                                    }, () => {});
                                    
                                    createState(dpTimestamp, "", {
                                        name: "Timestamp",
                                        type: "string",
                                        role: "info",
                                        read: true,
                                        write: false
                                    }, () => {});
                                    
                                    
                                    // time
                                    
                                    function formatTime(ts) {
                                        const d = new Date(ts * 1000);
                                        const pad = n => n.toString().padStart(2, "0");
                                        return `${pad(d.getDate())}.${pad(d.getMonth()+1)}.${d.getFullYear().toString().slice(-2)} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
                                    }
                                    
                                    
                                    //HTTP GET
                                    
                                    function getReport() {
                                        const options = {
                                            hostname: IP,
                                            port: 80,
                                            path: "/properties/report",
                                            method: "GET",
                                            timeout: 3000
                                        };
                                    
                                        const req = http.request(options, res => {
                                            let data = "";
                                            res.on("data", chunk => data += chunk);
                                            res.on("end", () => {
                                                try {
                                                    const json = JSON.parse(data);
                                                    if (json.timestamp) {
                                                        setState(dpTimestamp, formatTime(json.timestamp), true);
                                                    }
                                                    if (json.properties && typeof json.properties.smartMode !== "undefined") {
                                                        setState(dpSmartModeInfo, json.properties.smartMode, true);
                                                    }
                                                } catch (e) {
                                                    console.error("GET JSON Parse Fehler:", e);
                                                }
                                            });
                                        });
                                    
                                        req.on("error", err => console.error("HTTP GET Fehler:", err.message));
                                        req.end();
                                    }
                                    
                                    
                                    //HTTP POST zum Setzen
                                    
                                    function setSmartMode(val) {
                                        const payload = JSON.stringify({
                                            sn: SN,
                                            properties: { smartMode: val }
                                        });
                                    
                                        const options = {
                                            hostname: IP,
                                            port: 80,
                                            path: "/properties/write",
                                            method: "POST",
                                            headers: {
                                                "Content-Type": "application/json",
                                                "Content-Length": Buffer.byteLength(payload)
                                            },
                                            timeout: 3000
                                        };
                                    
                                        const req = http.request(options, res => {
                                            let data = "";
                                            res.on("data", chunk => data += chunk);
                                            res.on("end", () => {
                                                if (res.statusCode >= 200 && res.statusCode < 300) {
                                                    setState(dpSetSmartModeResult, "ok", true);
                                                } else {
                                                    console.error("POST Antwort:", res.statusCode, data);
                                                    setState(dpSetSmartModeResult, "error", true);
                                                }
                                            });
                                        });
                                    
                                        req.on("error", err => {
                                            console.error("HTTP POST Fehler:", err.message);
                                            setState(dpSetSmartModeResult, "error", true);
                                        });
                                    
                                        req.write(payload);
                                        req.end();
                                    }
                                    
                                    
                                    // interval
                                    
                                    getReport();  // sofort einmal abrufen
                                    schedule(`*/${intervalGet} * * * * *`, getReport); // alle x Sekunden
                                    
                                    
                                    // trigger wenn SmartMode gesetzt wird
                                    
                                    on({id: dpSetSmartMode, ack: false}, obj => {
                                        const val = parseInt(obj.state.val, 10);
                                        if (val === 0 || val === 1) {
                                            setSmartMode(val);
                                        }
                                    });
                                    

                                    Hinweis: Bei den Scripts wird davon ausgegangen, dass Zendure für HTTP den Standarport 80 verwendet wie von @Daniel-8 getestet.
                                    Wenn es bei jemand nicht so sein sollte, dann im script die 2 Port (port: 80,) bei Get und POST anpassen.

                                    D Online
                                    D Online
                                    Daniel 8
                                    wrote on last edited by
                                    #17

                                    @maxclaudi

                                    Vielen Dank für die Scripte. Werde ich die Tage mal testen.
                                    Sehr bewundernswert was du da auf die schnelle mal schreibst.

                                    Schreibst du das alles so händisch oder baust du das auch mit art blockly zusammen?

                                    Solarflow 800 Pro mit 1,3 Kwp / Iobroker / Homematic / Shellys / Mediola / Intertechno

                                    maxclaudiM 1 Reply Last reply
                                    0
                                    • D Daniel 8

                                      @maxclaudi

                                      Vielen Dank für die Scripte. Werde ich die Tage mal testen.
                                      Sehr bewundernswert was du da auf die schnelle mal schreibst.

                                      Schreibst du das alles so händisch oder baust du das auch mit art blockly zusammen?

                                      maxclaudiM Offline
                                      maxclaudiM Offline
                                      maxclaudi
                                      wrote on last edited by
                                      #18

                                      @daniel-8
                                      vscode nutze ich dafür und ja, händisch. Ab und zu, dann schon copy paste von meinen vorhandenen Funktionen.
                                      blockly dann auch wieder händisches geklicke und umschreiben.

                                      Ich schreibe meistens sehr direkt – bitte nicht falsch verstehen, es ist nie böse gemeint. Das ist einfach mein Stil und niemals abwertend gemeint.

                                      D 1 Reply Last reply
                                      0
                                      • maxclaudiM maxclaudi

                                        @daniel-8
                                        vscode nutze ich dafür und ja, händisch. Ab und zu, dann schon copy paste von meinen vorhandenen Funktionen.
                                        blockly dann auch wieder händisches geklicke und umschreiben.

                                        D Online
                                        D Online
                                        Daniel 8
                                        wrote on last edited by
                                        #19

                                        @maxclaudi

                                        Respekt. Das werde ich wohl nicht mehr lernen.
                                        Ich werde wohl bei blockly bleiben für meine Zwecke.

                                        Vielen Dank für deine Unterstützung.

                                        Ja das hat mir zendure auch geschrieben das sie den Datenpunkt irgendwann aufnehmen wollen.

                                        Solarflow 800 Pro mit 1,3 Kwp / Iobroker / Homematic / Shellys / Mediola / Intertechno

                                        1 Reply Last reply
                                        0
                                        • maxclaudiM maxclaudi

                                          @michi-0 sagte in Zendure SmartMode:1 SolarFlow2400 AC SolarFlow800 ( u. Pro):

                                          @maxclaudi
                                          Ihr habt ein Tempo...

                                          Mir würde vermutlich reichen, wenn mir der SmartMode Status in einem Datenpunkt angezeigt wird und ich den kontrollieren und steuern kann. Den Rest würde ich vermutlich auch weiterhin nur über MQTT machen.

                                          👍

                                          Zendure hat auch angekündigt, dass sie den Datenpunkt irgendwann auch aufnehmen werden, dann wäre alles andere überflüssig.
                                          Aber wenn nicht oder bis dahin hier die Lösungen.
                                          2 Scripte, die von den Funktionen identisch sind.
                                          Script 1: nur für iob unter Linux.
                                          Srcipt 2: plattformunabhängig, also auch für Windows.

                                          @Daniel-8 und @Michi-0 , bitte testen:


                                          Beschreibung für beide scripts:
                                          Script hat folgende Funktion:

                                          • Alle 60 Sekunden (anpassbar) wird properties/report geholt.
                                          • timestamp wird in ein lesbares Datum umgewandelt und in dpTimestamp geschrieben.
                                          • Aktueller smartMode wird in dpSmartModeInfo geschrieben (read only).
                                          • Wenn man setSmartMode mit 0 oder 1 steuert, sendet das Script automatisch einen POST an /properties/write und schreibt "ok" oder "error" in setResult.

                                          Beim Start werden vier Datenpunkte erstellt.
                                          Diese können oben im script konfiguriert werden.

                                          const dpSmartModeInfo = "0_userdata.0.zendureSmartMode.smartModeInfo";
                                          const dpSetSmartMode = "0_userdata.0.zendureSmartMode.setSmartMode";
                                          const dpSetSmartModeResult = "0_userdata.0.zendureSmartMode.setResult";
                                          const dpTimestamp = "0_userdata.0.zendureSmartMode.timestamp";

                                          60 Sekunden Interval ist unkritisch und aktuell.
                                          Bei Bedarf kann das auch oben im Script geändert werden:
                                          const intervalGet = 60; // Sekunden

                                          Oben trägt man auch die IP und Seriennummer des Zendure Geräts ein:

                                          const IP = "192.168.177.103"; // IP Zendure
                                          const SN = "EXXXXXXXXXXXXX0"; // Seriennummer Zendure

                                          Die Datenpunkte können mit anderen scripts / Blocklys gelesen werden oder dpSetSmartMode auf 1 oder 0 gesetzt werden.
                                          smartMode:1 ist wichtig.


                                          Script 1, mit curl umgesetzt, funktioniert nur wenn iob auf Linux läuft:

                                          // konfiguration
                                          
                                          const dpSmartModeInfo    = "0_userdata.0.zendureSmartMode.smartModeInfo";
                                          const dpSetSmartMode     = "0_userdata.0.zendureSmartMode.setSmartMode";
                                          const dpSetSmartModeResult = "0_userdata.0.zendureSmartMode.setResult";
                                          const dpTimestamp        = "0_userdata.0.zendureSmartMode.timestamp";
                                          
                                          const intervalGet = 60;                 // Sekunden
                                          const IP = "192.168.177.103";           // IP des Zendure Geräts
                                          const SN = "EXXXXXXXXXXXXX0";           // Seriennummer
                                          
                                          //-----------
                                          // dp anlegen
                                          
                                          createState(dpSmartModeInfo, 0, {
                                              name: "SmartMode Info",
                                              type: "number",
                                              role: "state",
                                              read: true,
                                              write: false,
                                              min: 0,
                                              max: 1
                                          }, () => {});
                                          
                                          createState(dpSetSmartMode, 0, {
                                              name: "SmartMode Set",
                                              type: "number",
                                              role: "state",
                                              read: true,
                                              write: true,
                                              min: 0,
                                              max: 1
                                          }, () => {});
                                          
                                          createState(dpSetSmartModeResult, "", {
                                              name: "SmartMode Set Result",
                                              type: "string",
                                              role: "info",
                                              read: true,
                                              write: false
                                          }, () => {});
                                          
                                          createState(dpTimestamp, "", {
                                              name: "Timestamp",
                                              type: "string",
                                              role: "info",
                                              read: true,
                                              write: false
                                          }, () => {});
                                          
                                          
                                          // time
                                          
                                          function formatTime(ts) {
                                              // ts ist Unix Sekunden
                                              const d = new Date(ts * 1000);
                                              const pad = n => n.toString().padStart(2, "0");
                                              return `${pad(d.getDate())}.${pad(d.getMonth()+1)}.${d.getFullYear().toString().slice(-2)} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
                                          }
                                          
                                          
                                          //curl HTTP GET
                                          
                                          function getReport() {
                                              const cmd = `curl -s "http://${IP}/properties/report"`;
                                              exec(cmd, (error, stdout, stderr) => {
                                                  if (error) {
                                                      console.error("GET Fehler:", stderr);
                                                      return;
                                                  }
                                                  try {
                                                      const data = JSON.parse(stdout);
                                                      if (data && data.timestamp) {
                                                          setState(dpTimestamp, formatTime(data.timestamp), true);
                                                      }
                                                      if (data && data.properties && typeof data.properties.smartMode !== "undefined") {
                                                          setState(dpSmartModeInfo, data.properties.smartMode, true);
                                                      }
                                                  } catch (e) {
                                                      console.error("JSON Parse Fehler:", e);
                                                  }
                                              });
                                          }
                                          
                                          
                                          //curl HTTP POST zum Setzen
                                          
                                          function setSmartMode(val) {
                                              const payload = `{"sn":"${SN}","properties":{"smartMode":${val}}}`;
                                              const cmd = `curl -s -X POST "http://${IP}/properties/write" -H "Content-Type: application/json" -d '${payload}'`;
                                              exec(cmd, (error, stdout, stderr) => {
                                                  if (error) {
                                                      console.error("POST Fehler:", stderr);
                                                      setState(dpSetSmartModeResult, "error", true);
                                                      return;
                                                  }
                                                  setState(dpSetSmartModeResult, "ok", true);
                                              });
                                          }
                                          
                                          
                                          // interval
                                          
                                          getReport();  // sofort bei start
                                          schedule(`*/${intervalGet} * * * * *`, getReport); // alle x Sekunden
                                          
                                          // trigger wenn SmartMode gesetzt wird
                                          
                                          on({id: dpSetSmartMode, ack: false}, obj => {
                                              const val = parseInt(obj.state.val, 10);
                                              if (val === 0 || val === 1) {
                                                  setSmartMode(val);
                                              }
                                          });
                                          

                                          Script 2:
                                          Funktionen identisch zum ersten.
                                          Skript ist plattformunabhängig und sollte damit für Windows-Installationen von ioBroker funktionieren (ungetestet).
                                          Statt curl werden ioBroker/Node.js vorhandene Standardbibliotheken (http und https) verwendet.

                                          // konfiguration
                                          const dpSmartModeInfo      = "0_userdata.0.zendureSmartMode.smartModeInfo";
                                          const dpSetSmartMode       = "0_userdata.0.zendureSmartMode.setSmartMode";
                                          const dpSetSmartModeResult = "0_userdata.0.zendureSmartMode.setResult";
                                          const dpTimestamp          = "0_userdata.0.zendureSmartMode.timestamp";
                                          
                                          const intervalGet = 60;                 // Sekunden
                                          const IP = "192.168.177.103";           // IP des Zendure Geräts
                                          const SN = "EXXXXXXXXXXXXX0";           // Seriennummer
                                          
                                          const http = require("http");           // Node.js Standardmodul
                                          
                                          
                                          //-----------
                                          // dp
                                          
                                          createState(dpSmartModeInfo, 0, {
                                              name: "SmartMode Info",
                                              type: "number",
                                              role: "state",
                                              read: true,
                                              write: false,
                                              min: 0,
                                              max: 1
                                          }, () => {});
                                          
                                          createState(dpSetSmartMode, 0, {
                                              name: "SmartMode Set",
                                              type: "number",
                                              role: "state",
                                              read: true,
                                              write: true,
                                              min: 0,
                                              max: 1
                                          }, () => {});
                                          
                                          createState(dpSetSmartModeResult, "", {
                                              name: "SmartMode Set Result",
                                              type: "string",
                                              role: "info",
                                              read: true,
                                              write: false
                                          }, () => {});
                                          
                                          createState(dpTimestamp, "", {
                                              name: "Timestamp",
                                              type: "string",
                                              role: "info",
                                              read: true,
                                              write: false
                                          }, () => {});
                                          
                                          
                                          // time
                                          
                                          function formatTime(ts) {
                                              const d = new Date(ts * 1000);
                                              const pad = n => n.toString().padStart(2, "0");
                                              return `${pad(d.getDate())}.${pad(d.getMonth()+1)}.${d.getFullYear().toString().slice(-2)} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
                                          }
                                          
                                          
                                          //HTTP GET
                                          
                                          function getReport() {
                                              const options = {
                                                  hostname: IP,
                                                  port: 80,
                                                  path: "/properties/report",
                                                  method: "GET",
                                                  timeout: 3000
                                              };
                                          
                                              const req = http.request(options, res => {
                                                  let data = "";
                                                  res.on("data", chunk => data += chunk);
                                                  res.on("end", () => {
                                                      try {
                                                          const json = JSON.parse(data);
                                                          if (json.timestamp) {
                                                              setState(dpTimestamp, formatTime(json.timestamp), true);
                                                          }
                                                          if (json.properties && typeof json.properties.smartMode !== "undefined") {
                                                              setState(dpSmartModeInfo, json.properties.smartMode, true);
                                                          }
                                                      } catch (e) {
                                                          console.error("GET JSON Parse Fehler:", e);
                                                      }
                                                  });
                                              });
                                          
                                              req.on("error", err => console.error("HTTP GET Fehler:", err.message));
                                              req.end();
                                          }
                                          
                                          
                                          //HTTP POST zum Setzen
                                          
                                          function setSmartMode(val) {
                                              const payload = JSON.stringify({
                                                  sn: SN,
                                                  properties: { smartMode: val }
                                              });
                                          
                                              const options = {
                                                  hostname: IP,
                                                  port: 80,
                                                  path: "/properties/write",
                                                  method: "POST",
                                                  headers: {
                                                      "Content-Type": "application/json",
                                                      "Content-Length": Buffer.byteLength(payload)
                                                  },
                                                  timeout: 3000
                                              };
                                          
                                              const req = http.request(options, res => {
                                                  let data = "";
                                                  res.on("data", chunk => data += chunk);
                                                  res.on("end", () => {
                                                      if (res.statusCode >= 200 && res.statusCode < 300) {
                                                          setState(dpSetSmartModeResult, "ok", true);
                                                      } else {
                                                          console.error("POST Antwort:", res.statusCode, data);
                                                          setState(dpSetSmartModeResult, "error", true);
                                                      }
                                                  });
                                              });
                                          
                                              req.on("error", err => {
                                                  console.error("HTTP POST Fehler:", err.message);
                                                  setState(dpSetSmartModeResult, "error", true);
                                              });
                                          
                                              req.write(payload);
                                              req.end();
                                          }
                                          
                                          
                                          // interval
                                          
                                          getReport();  // sofort einmal abrufen
                                          schedule(`*/${intervalGet} * * * * *`, getReport); // alle x Sekunden
                                          
                                          
                                          // trigger wenn SmartMode gesetzt wird
                                          
                                          on({id: dpSetSmartMode, ack: false}, obj => {
                                              const val = parseInt(obj.state.val, 10);
                                              if (val === 0 || val === 1) {
                                                  setSmartMode(val);
                                              }
                                          });
                                          

                                          Hinweis: Bei den Scripts wird davon ausgegangen, dass Zendure für HTTP den Standarport 80 verwendet wie von @Daniel-8 getestet.
                                          Wenn es bei jemand nicht so sein sollte, dann im script die 2 Port (port: 80,) bei Get und POST anpassen.

                                          M Offline
                                          M Offline
                                          Michi 0
                                          wrote on last edited by
                                          #20

                                          @maxclaudi

                                          Es läuft!! Hab ioBroker auf einem Proxmox Host unter Linux laufen.

                                          Hab´s grad eingebunden. Datenpunkte wie beschrieben angelegt und auch sofort befüllt. Ich konnte mit SetSmartMode den DP smartMode ändern.

                                          Vielen Dank! Echt klasse das Du dich hier so für die Probleme Anderer engagierst.

                                          Jetzt kann ich das Ding regeln lassen bis zum umfallen 😉

                                          D 1 Reply Last reply
                                          0
                                          Reply
                                          • Reply as topic
                                          Log in to reply
                                          • Oldest to Newest
                                          • Newest to Oldest
                                          • Most Votes


                                          Support us

                                          ioBroker
                                          Community Adapters
                                          Donate

                                          578

                                          Online

                                          32.4k

                                          Users

                                          81.4k

                                          Topics

                                          1.3m

                                          Posts
                                          Community
                                          Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen
                                          ioBroker Community 2014-2025
                                          logo
                                          • Login

                                          • Don't have an account? Register

                                          • Login or register to search.
                                          • First post
                                            Last post
                                          0
                                          • Recent
                                          • Tags
                                          • Unread 0
                                          • Categories
                                          • Unreplied
                                          • Popular
                                          • GitHub
                                          • Docu
                                          • Hilfe