@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/fronius-write/fronius-write.js

@@ -0,0 +1,2531 @@
+module.exports = function (RED) {
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+
+    const ModbusRTU = require("modbus-serial");
+    const {
+        atLeast,
+        clampNumber
+    } = require("../lib/numbers");
+
+    const MAX_OPERATION_RETRIES = 3;
+
+    const RETRY_DELAY_MS = [250, 750];
+
+    const MAX_CONFIG_POWER_W = 125000;
+
+    const nodeRuntimeState = new Map();
+
+
+    function setNodeRuntimeState(nodeId, state) {
+
+        nodeRuntimeState.set(nodeId, Object.assign({}, state, {
+
+            updated_at: new Date().toISOString()
+
+        }));
+
+    }
+
+
+    function clearNodeRuntimeState(nodeId) {
+
+        nodeRuntimeState.delete(nodeId);
+
+    }
+
+
+    RED.httpAdmin.get("/fronius-write/state/:id", function (req, res) {
+
+
+        const nodeId = req.params.id;
+
+
+        if (!nodeId) {
+
+            res.json({ ok: false, error: "Missing node id" });
+
+            return;
+
+        }
+
+
+        const state = nodeRuntimeState.get(nodeId);
+
+
+        if (!state) {
+
+            res.json({ ok: false, error: "No cached state" });
+
+            return;
+
+        }
+
+
+        res.json({
+
+            ok: true,
+
+            state: state
+
+        });
+
+
+    });
+
+
+
+    function normalizeRampType(type) {
+
+
+        if (!type) return "none";
+
+
+        if (type === "gradient_watts") return "gradient_w";
+
+
+        if (type === "gradient_vars") return "gradient_w";
+
+        if (type === "gradient_var") return "gradient_w";
+
+        if (type === "gradient_vars_per_sec") return "gradient_w";
+
+
+        return type;
+
+
+    }
+
+
+
+    function normalizePowerType(type) {
+
+
+        return type === "reactive" ? "reactive" : "active";
+
+
+    }
+
+
+
+    function normalizeModeByPowerType(powerType, mode) {
+
+
+        const normalizedPowerType = normalizePowerType(powerType);
+
+
+
+        if (normalizedPowerType === "reactive") {
+
+
+            if (mode === "vars") return "vars";
+
+
+            if (mode === "percent") return "percent";
+
+
+            return "vars";
+
+
+        }
+
+
+
+        if (mode === "watts") return "watts";
+
+
+        if (mode === "percent") return "percent";
+
+
+        return "watts";
+
+
+    }
+
+
+
+    function toUnsigned16FromSigned(value) {
+
+
+        let v = Math.round(Number(value) || 0);
+
+
+
+        if (v > 32767) v = 32767;
+
+
+        if (v < -32768) v = -32768;
+
+
+
+        return v < 0 ? (65536 + v) : v;
+
+
+    }
+
+
+
+    function clampSignedPercent(powerType, percent) {
+
+
+        if (powerType === "reactive") {
+
+
+            if (percent < -100) return -100;
+
+
+            if (percent > 100) return 100;
+
+
+            return percent;
+
+
+        }
+
+
+
+        if (percent < -100) return -100;
+
+
+        if (percent > 100) return 100;
+
+
+        return percent;
+
+
+    }
+
+
+
+    function assertRange(value, min, max, label) {
+
+
+        if (!Number.isFinite(value)) {
+
+
+            throw new Error(label + " trebuie sa fie numeric");
+
+
+        }
+
+
+        if (value < min || value > max) {
+
+
+            throw new Error(label + " trebuie sa fie intre " + min + " si " + max);
+
+
+        }
+
+
+    }
+
+
+
+    function isRetryableModbusError(err) {
+
+
+        if (!err) {
+
+            return false;
+
+        }
+
+
+        const msg = String(err.message || err || "").toLowerCase();
+
+
+        if (!msg) {
+
+            return false;
+
+        }
+
+
+        return [
+
+            "timed out",
+
+            "timeout",
+
+            "econnreset",
+
+            "econnrefused",
+
+            "ehostunreach",
+
+            "enetunreach",
+
+            "etimedout",
+
+            "econnaborted",
+
+            "socket hang up",
+
+            "port not open",
+
+            "not connected",
+
+            "broken pipe",
+
+            "eof",
+
+            "modbus exception 4",
+
+            "slave device failure"
+
+        ].some(function (token) {
+
+            return msg.includes(token);
+
+        });
+
+
+    }
+
+    function optionalPositiveTimestampMs(payload, key) {
+        if (!payload || typeof payload !== "object") return null;
+        if (payload[key] === undefined || payload[key] === null || payload[key] === "") return null;
+
+        const timestamp = Number(payload[key]);
+        return Number.isFinite(timestamp) && timestamp > 0 ? timestamp : null;
+    }
+
+
+
+    function FroniusWriteNode(config) {
+
+
+        RED.nodes.createNode(this, config);
+
+
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+
+
+
+        node.host = config.host;
+
+
+        node.port = atLeast(config.port, 1, 502);
+
+
+        node.unitId = atLeast(config.unitId, 1, 1);
+
+
+
+        node.powerType = normalizePowerType(config.powerType || "active");
+
+
+        node.mode = normalizeModeByPowerType(node.powerType, config.mode || "watts");
+
+
+
+        node.nominalPower = clampNumber(config.nominalPower, 1, MAX_CONFIG_POWER_W, 25000);
+
+        node.maxPower = clampNumber(
+
+            config.maxPower !== undefined
+
+                ? config.maxPower
+
+                : (config.nominalPower || 25000)
+
+            ,
+            1,
+            MAX_CONFIG_POWER_W,
+            25000
+        );
+
+
+        if (!Number.isFinite(node.maxPower) || node.maxPower <= 0) {
+
+            node.maxPower = clampNumber(config.nominalPower, 1, MAX_CONFIG_POWER_W, 25000);
+
+        }
+
+
+        if (!Number.isFinite(node.nominalPower) || node.nominalPower <= 0) {
+
+            node.nominalPower = 25000;
+
+        }
+
+
+        if (node.nominalPower < node.maxPower) {
+
+            node.nominalPower = node.maxPower;
+
+        }
+
+
+        node.nominalReactivePower = clampNumber(
+
+
+            config.nominalReactivePower !== undefined
+
+
+                ? config.nominalReactivePower
+
+
+                : (config.nominalPower || 25000)
+
+
+            ,
+            1,
+            MAX_CONFIG_POWER_W,
+            25000
+        );
+
+
+
+        node.rampType = normalizeRampType(config.rampType || "none");
+
+
+        node.rampTime = atLeast(config.rampTime, 0, 0);
+
+
+        node.rampGradientPct = atLeast(config.rampGradientPct, 0, 10);
+
+
+        node.rampGradientWatts = atLeast(config.rampGradientWatts, 0, 2500);
+
+
+        node.rampGradientVars = atLeast(
+
+
+            config.rampGradientVars !== undefined
+
+
+                ? config.rampGradientVars
+
+
+                : (config.rampGradientWatts || 2500)
+
+
+            ,
+            0,
+            2500
+        );
+
+        node.rampUpValue = atLeast(config.rampUpValue, 0, 0);
+
+        node.rampDownValue = atLeast(config.rampDownValue, 0, 0);
+
+
+        node.multiInverter = !!config.multiInverter;
+
+        node.inverterId = String(config.inverterId || "").trim();
+        node.latencyTargetMs = atLeast(config.latencyTargetMs, 1, 200);
+        node.maxCommandAgeMs = atLeast(config.maxCommandAgeMs, 50, 1000);
+        node.disableReadbackVerification = !!config.disableReadbackVerification;
+
+
+
+        let client = new ModbusRTU();
+
+
+        let sunspecBase = null;
+
+
+        let cachedControlModel = null;
+
+        const lastAppliedPercentByPowerType = {
+            active: null,
+            reactive: null
+        };
+        let confirmedControlState = null;
+        let pendingOperation = null;
+        let operationWorker = Promise.resolve();
+        let operationWorkerRunning = false;
+
+
+
+        function toSigned16(v) {
+
+
+            return v > 32767 ? v - 65536 : v;
+
+
+        }
+
+
+
+        function invScale(value, sf) {
+
+
+            return Math.round(value / Math.pow(10, sf));
+
+
+        }
+
+
+
+        function toNumber(v) {
+
+
+            const n = Number(v);
+
+
+            return Number.isFinite(n) ? n : null;
+
+
+        }
+
+
+
+        function wait(ms) {
+
+            return new Promise(function (resolve) {
+
+                setTimeout(resolve, ms);
+
+            });
+
+        }
+
+
+
+        async function recreateClient() {
+
+
+            try {
+
+                if (client && client.isOpen) {
+
+                    await client.close();
+
+                }
+
+            } catch (e) {
+
+                // ignore
+
+            }
+
+
+            client = new ModbusRTU();
+
+
+        }
+
+
+
+        async function resetRuntimeAfterCommFailure() {
+
+
+            await recreateClient();
+
+            sunspecBase = null;
+
+            cachedControlModel = null;
+            confirmedControlState = null;
+
+
+        }
+
+
+
+        async function executeWithRetry(label, operation) {
+
+
+            let lastError = null;
+
+
+            for (let attempt = 1; attempt <= MAX_OPERATION_RETRIES; attempt++) {
+
+
+                try {
+
+                    return await operation();
+
+                } catch (err) {
+
+                    lastError = err;
+
+
+                    const retryable = isRetryableModbusError(err);
+
+                    const shouldRetry = retryable && attempt < MAX_OPERATION_RETRIES;
+
+
+                    if (!shouldRetry) {
+
+                        throw err;
+
+                    }
+
+
+                    node.warn(
+
+                        label +
+
+                        " failed (" +
+
+                        attempt +
+
+                        "/" +
+
+                        MAX_OPERATION_RETRIES +
+
+                        "): " +
+
+                        err.message +
+
+                        ". Retrying..."
+
+                    );
+
+
+                    await resetRuntimeAfterCommFailure();
+
+                    await wait(RETRY_DELAY_MS[attempt - 1] || RETRY_DELAY_MS[RETRY_DELAY_MS.length - 1] || 500);
+
+                }
+
+            }
+
+
+            throw lastError || new Error(label + " failed");
+
+
+        }
+
+
+
+        async function connect() {
+
+
+            if (client.isOpen) {
+
+                client.setID(node.unitId);
+
+                client.setTimeout(2500);
+
+                return;
+
+            }
+
+
+            await client.connectTCP(node.host, { port: node.port });
+
+            client.setID(node.unitId);
+
+            client.setTimeout(2500);
+
+
+        }
+
+
+
+        async function read(addr, len) {
+
+
+            return client.readHoldingRegisters(addr, len);
+
+
+        }
+
+
+
+        async function writeSingle(addr, value) {
+
+
+            return client.writeRegister(addr, value);
+
+
+        }
+
+        async function writeSingleLabeled(addr, value, label) {
+            try {
+                return await writeSingle(addr, value);
+            } catch (err) {
+                const detail = (label || "Registru") + " write failed at register " + addr + " value " + value;
+                err.message = detail + ": " + (err.message || String(err));
+                throw err;
+            }
+        }
+
+        async function readSingle(addr, label) {
+            let response = null;
+            try {
+                response = await read(addr, 1);
+            } catch (err) {
+                const detail = (label || "Registru") + " read failed at register " + addr;
+                err.message = detail + ": " + (err.message || String(err));
+                throw err;
+            }
+            if (!response || !Array.isArray(response.data) || response.data.length !== 1) {
+                throw new Error("Raspuns Modbus incomplet la verificarea " + (label || "registrului") + " register " + addr);
+            }
+            return response.data[0];
+        }
+
+        async function verifyRegister(addr, expected, label) {
+            if (node.disableReadbackVerification) {
+                return null;
+            }
+            const actual = await readSingle(addr, label);
+            if (actual !== expected) {
+                throw new Error(
+                    (label || "Registru") + " register " + addr + " nu a fost confirmat: asteptat " + expected + ", citit " + actual
+                );
+            }
+            return actual;
+        }
+
+        function isSlaveDeviceFailure(err) {
+            const msg = String(err && err.message ? err.message : err || "").toLowerCase();
+            return msg.includes("modbus exception 4") || msg.includes("slave device failure");
+        }
+
+        async function verifyOppositeEnableRegister(addr, expected) {
+            try {
+                return await verifyRegister(addr, expected, "Enable control opus");
+            } catch (err) {
+                if (isSlaveDeviceFailure(err)) {
+                    node.warn(
+                        "Enable control opus read-back indisponibil la registrul " +
+                            addr +
+                            ": " +
+                            (err.message || String(err)) +
+                            ". Comanda continua deoarece scrierea de dezactivare a fost acceptata."
+                    );
+                    return null;
+                }
+                throw err;
+            }
+        }
+
+
+
+        async function findBase() {
+
+
+            const bases = [39999, 40000, 40001, 40002, 40199, 40200, 40201, 40202];
+
+
+
+            for (const b of bases) {
+
+
+                try {
+
+
+                    const r = await read(b, 2);
+
+
+
+                    const txt =
+
+
+                        String.fromCharCode((r.data[0] >> 8) & 0xff) +
+
+
+                        String.fromCharCode(r.data[0] & 0xff) +
+
+
+                        String.fromCharCode((r.data[1] >> 8) & 0xff) +
+
+
+                        String.fromCharCode(r.data[1] & 0xff);
+
+
+
+                    if (txt.includes("SunS")) {
+
+
+                        return b;
+
+
+                    }
+
+
+                } catch (e) {
+
+
+                    // ignore
+
+
+                }
+
+
+            }
+
+
+
+            throw new Error("SunSpec not found");
+
+
+        }
+
+
+
+        async function scanModels(base) {
+
+
+            const models = [];
+
+
+            let addr = base + 2;
+
+
+
+            while (true) {
+
+
+                const header = await read(addr, 2);
+
+
+                const modelId = header.data[0];
+
+
+                const len = header.data[1];
+
+
+
+                if (modelId === 0xffff) {
+
+
+                    break;
+
+
+                }
+
+
+
+                const payload = await read(addr + 2, len);
+
+
+
+                models.push({
+
+
+                    modelId,
+
+
+                    addr,
+
+
+                    len,
+
+
+                    baseAddr: addr + 2,
+
+
+                    raw: payload.data
+
+
+                });
+
+
+
+                addr += 2 + len;
+
+
+            }
+
+
+
+            return models;
+
+
+        }
+
+
+
+        async function findControlModel(base) {
+
+
+            const models = await scanModels(base);
+
+
+            const preferred = [123, 122, 121, 120];
+
+
+
+            for (const wantedId of preferred) {
+
+
+                const found = models.find((m) => m.modelId === wantedId);
+
+
+                if (found) {
+
+
+                    return found;
+
+
+                }
+
+
+            }
+
+
+
+            const foundAnyControl = models.find((m) => [120, 121, 122, 123].includes(m.modelId));
+
+
+            if (foundAnyControl) {
+
+
+                return foundAnyControl;
+
+
+            }
+
+
+
+            throw new Error("Nu a fost găsit niciun model SunSpec de control (120/121/122/123)");
+
+
+        }
+
+
+
+        function extractRampFromConfig(powerType) {
+
+
+            if (node.rampType === "none") {
+
+
+                return { type: "none", value: 0 };
+
+
+            }
+
+
+
+            if (node.rampType === "time") {
+
+
+                return { type: "time", value: 0 };
+
+
+            }
+
+
+
+            if (node.rampType === "gradient_pct") {
+
+
+                return { type: "gradient_pct", value: 0 };
+
+
+            }
+
+
+
+            if (node.rampType === "gradient_w") {
+
+
+                return {
+
+
+                    type: "gradient_w",
+
+
+                    value: 0
+
+
+                };
+
+
+            }
+
+
+
+            return { type: "none", value: 0 };
+
+
+        }
+
+
+
+        function extractInput(msg) {
+
+
+            let powerType = node.powerType;
+
+
+            let mode = node.mode;
+
+
+            let value;
+
+
+            let ramp = extractRampFromConfig(powerType);
+            let rampFromMessage = false;
+            let rampDirectionHint = null;
+            let nominalPowerOverride = null;
+            let nominalReactivePowerOverride = null;
+
+
+
+            if (typeof msg.payload === "number") {
+
+
+                value = Number(msg.payload);
+
+
+            } else if (typeof msg.payload === "string" && msg.payload.trim() !== "") {
+
+
+                const parsed = Number(msg.payload.trim());
+
+
+                if (Number.isFinite(parsed)) {
+
+
+                    value = parsed;
+
+
+                }
+
+
+            } else if (typeof msg.payload === "object" && msg.payload !== null) {
+
+
+                const p = msg.payload;
+
+
+
+                if (p.powerType) {
+
+
+                    powerType = normalizePowerType(p.powerType);
+
+
+                } else if (p.power_type) {
+
+
+                    powerType = normalizePowerType(p.power_type);
+
+
+                }
+
+
+
+                if (p.mode) {
+
+
+                    mode = p.mode;
+
+
+                }
+
+
+                if (Number.isFinite(Number(p.nominal_power_w))) {
+
+
+                    nominalPowerOverride = Number(p.nominal_power_w);
+
+
+                }
+
+
+                if (Number.isFinite(Number(p.nominal_reactive_power_var))) {
+
+
+                    nominalReactivePowerOverride = Number(p.nominal_reactive_power_var);
+
+
+                }
+
+
+
+                if (p.value !== undefined) {
+
+
+                    value = Number(p.value);
+
+
+                } else if (p.site_limit_w !== undefined) {
+
+
+                    value = Number(p.site_limit_w);
+
+
+                    powerType = "active";
+
+
+                    mode = "watts";
+
+
+                } else if (p.limit_w !== undefined) {
+
+
+                    value = Number(p.limit_w);
+
+
+                    powerType = "active";
+
+
+                    mode = "watts";
+
+
+                } else if (p.watts !== undefined) {
+
+
+                    value = Number(p.watts);
+
+
+                    powerType = "active";
+
+
+                    mode = "watts";
+
+
+                } else if (p.limit_pct !== undefined) {
+
+
+                    value = Number(p.limit_pct);
+
+
+                    powerType = "active";
+
+
+                    mode = "percent";
+
+
+                } else if (p.percent !== undefined) {
+
+
+                    value = Number(p.percent);
+
+
+                    mode = "percent";
+
+
+                } else if (p.limit_var !== undefined) {
+
+
+                    value = Number(p.limit_var);
+
+
+                    powerType = "reactive";
+
+
+                    mode = "vars";
+
+
+                } else if (p.vars !== undefined) {
+
+
+                    value = Number(p.vars);
+
+
+                    powerType = "reactive";
+
+
+                    mode = "vars";
+
+
+                } else if (p.var !== undefined) {
+
+
+                    value = Number(p.var);
+
+
+                    powerType = "reactive";
+
+
+                    mode = "vars";
+
+
+                } else if (p.limit_var_pct !== undefined) {
+
+
+                    value = Number(p.limit_var_pct);
+
+
+                    powerType = "reactive";
+
+
+                    mode = "percent";
+
+
+                }
+
+
+
+                if (p.ramp && typeof p.ramp === "object") {
+
+
+                    const msgRampType = normalizeRampType(p.ramp.type || "none");
+
+
+                    const msgRampValue = toNumber(p.ramp.value);
+
+
+
+                    ramp = {
+
+
+                        type: msgRampType,
+
+
+                        value: msgRampType === "none" ? 0 : (msgRampValue ?? 0)
+
+
+                    };
+
+                    rampFromMessage = true;
+
+
+                }
+
+                if (p.ramp_direction === "up" || p.ramp_direction === "down" || p.ramp_direction === "hold") {
+
+
+                    rampDirectionHint = p.ramp_direction;
+
+
+                }
+
+
+            }
+
+
+
+            powerType = normalizePowerType(powerType);
+
+
+            mode = normalizeModeByPowerType(powerType, mode);
+
+
+
+            if (!Number.isFinite(value)) {
+
+
+                throw new Error("msg.payload trebuie să conțină valoarea limitei");
+
+
+            }
+
+
+
+            if (powerType === "active" && mode !== "watts" && mode !== "percent") {
+
+
+                throw new Error("Pentru putere activă, mode trebuie să fie 'watts' sau 'percent'");
+
+
+            }
+
+
+
+            if (powerType === "reactive" && mode !== "vars" && mode !== "percent") {
+
+
+                throw new Error("Pentru putere reactivă, mode trebuie să fie 'vars' sau 'percent'");
+
+
+            }
+
+
+
+            if (mode === "percent") {
+
+
+                assertRange(value, -100, 100, "Valoarea procentuală");
+
+
+            } else if (powerType === "active" && mode === "watts") {
+
+
+                if (!Number.isFinite(node.maxPower) || node.maxPower <= 0) {
+
+
+                    throw new Error("Max Power (W) trebuie sa fie > 0");
+
+
+                }
+
+
+                assertRange(value, 0, node.maxPower, "Valoarea in W fata de Max Power");
+
+
+            } else if (powerType === "reactive" && mode === "vars") {
+
+
+                const nominalReactivePower = effectiveNominalReactivePower({
+                    nominalReactivePowerOverride: nominalReactivePowerOverride
+                });
+
+
+                if (!Number.isFinite(nominalReactivePower) || nominalReactivePower <= 0) {
+
+
+                    throw new Error("Nominal Reactive Power (VAr) trebuie să fie > 0");
+
+
+                }
+
+
+                assertRange(value, -nominalReactivePower, nominalReactivePower, "Valoarea în VAr");
+
+
+            }
+
+
+            if (mode === "watts" || mode === "vars") {
+
+                value = Math.round(value);
+
+            }
+
+
+
+            return {
+                powerType,
+                mode,
+                value,
+                ramp,
+                rampFromMessage,
+                rampDirectionHint,
+                nominalPowerOverride,
+                nominalReactivePowerOverride
+            };
+
+
+        }
+
+
+        function effectiveNominalPower(input) {
+
+
+            const n = Number(input && input.nominalPowerOverride);
+
+
+            return Number.isFinite(n) && n > 0 ? n : node.nominalPower;
+
+
+        }
+
+        function effectiveNominalReactivePower(input) {
+
+
+            const n = Number(input && input.nominalReactivePowerOverride);
+
+
+            return Number.isFinite(n) && n > 0 ? n : node.nominalReactivePower;
+
+
+        }
+
+
+
+        function computePercent(powerType, mode, value, input) {
+
+
+            if (powerType === "active") {
+
+
+                if (mode === "watts") {
+
+
+                    const nominalPower = effectiveNominalPower(input);
+
+
+                    if (!Number.isFinite(nominalPower) || nominalPower <= 0) {
+
+
+                        throw new Error("Nominal Power (W) trebuie sa fie > 0");
+
+
+                    }
+
+
+                    if (Number.isFinite(node.maxPower) && node.maxPower > 0 && nominalPower < node.maxPower) {
+
+
+                        throw new Error("Nominal Power (W) trebuie sa fie >= Max Power (W)");
+
+
+                    }
+
+
+                    return (value / nominalPower) * 100;
+
+
+                }
+
+
+
+                assertRange(value, -100, 100, "Valoarea procentuală");
+
+
+                return value;
+
+
+            }
+
+
+
+            if (mode === "vars") {
+
+
+                const nominalReactivePower = effectiveNominalReactivePower(input);
+
+
+                if (!Number.isFinite(nominalReactivePower) || nominalReactivePower <= 0) {
+
+
+                    throw new Error("Nominal Reactive Power (VAr) trebuie să fie > 0");
+
+
+                }
+
+
+
+                assertRange(value, -nominalReactivePower, nominalReactivePower, "Valoarea în VAr");
+
+
+                return (value / nominalReactivePower) * 100;
+
+
+            }
+
+
+
+            assertRange(value, -100, 100, "Valoarea procentuală");
+
+
+            return value;
+
+
+        }
+
+
+
+        function computeRampTimeSeconds(powerType, percent, ramp, input) {
+
+
+            const rampType = normalizeRampType(ramp?.type || "none");
+
+
+            const rampValue = toNumber(ramp?.value);
+
+
+
+            if (rampType === "none") {
+
+
+                return null;
+
+
+            }
+
+
+
+            const safePercent = Math.abs(clampSignedPercent(powerType, percent));
+
+
+
+            if (rampType === "time") {
+
+
+                if (!Number.isFinite(rampValue) || rampValue < 0) {
+
+
+                    throw new Error("Ramp Time (s) invalid");
+
+
+                }
+
+
+                return Math.round(rampValue);
+
+
+            }
+
+
+
+            if (rampType === "gradient_pct") {
+
+
+                if (!Number.isFinite(rampValue) || rampValue <= 0) {
+
+
+                    throw new Error("Gradient (%/s) trebuie să fie > 0");
+
+
+                }
+
+
+
+                const t = safePercent / rampValue;
+
+
+                return Math.round(t);
+
+
+            }
+
+
+
+            if (rampType === "gradient_w") {
+
+
+                if (!Number.isFinite(rampValue) || rampValue <= 0) {
+
+
+                    throw new Error(powerType === "reactive"
+
+
+                        ? "Gradient (VAr/s) trebuie să fie > 0"
+
+
+                        : "Gradient (W/s) trebuie să fie > 0");
+
+
+                }
+
+
+
+                if (powerType === "reactive") {
+
+
+                    const nominalReactivePower = effectiveNominalReactivePower(input);
+
+
+                    if (!Number.isFinite(nominalReactivePower) || nominalReactivePower <= 0) {
+
+
+                        throw new Error("Nominal Reactive Power (VAr) trebuie să fie > 0");
+
+
+                    }
+
+
+
+                    const targetVars = (safePercent / 100) * nominalReactivePower;
+
+
+                    const t = targetVars / rampValue;
+
+
+                    return Math.round(t);
+
+
+                }
+
+
+
+                const nominalPower = effectiveNominalPower(input);
+
+
+                if (!Number.isFinite(nominalPower) || nominalPower <= 0) {
+
+
+                    throw new Error("Nominal Power (W) trebuie sa fie > 0");
+
+
+                }
+
+
+                if (Number.isFinite(node.maxPower) && node.maxPower > 0 && nominalPower < node.maxPower) {
+
+
+                    throw new Error("Nominal Power (W) trebuie sa fie >= Max Power (W)");
+
+
+                }
+
+
+                const targetWatts = (safePercent / 100) * nominalPower;
+
+
+                const t = targetWatts / rampValue;
+
+
+                return Math.round(t);
+
+
+            }
+
+
+
+            throw new Error(`Ramp type invalid: ${rampType}`);
+
+
+        }
+
+
+        function selectDirectionalRamp(input, percent) {
+
+
+            const powerType = normalizePowerType(input.powerType);
+
+
+            const previousPercent = lastAppliedPercentByPowerType[powerType];
+
+
+            const measuredDirection = Number.isFinite(previousPercent)
+
+
+                ? (percent > previousPercent ? "up" : (percent < previousPercent ? "down" : "hold"))
+
+
+                : "hold";
+
+
+            const direction = input.rampDirectionHint || measuredDirection;
+
+
+            const baseRamp = input.ramp || { type: "none", value: 0 };
+
+
+            if (input.rampFromMessage || !baseRamp || baseRamp.type === "none") {
+
+
+                return { ramp: baseRamp, direction: direction };
+
+
+            }
+
+
+            if (direction === "up" && node.rampUpValue > 0) {
+
+
+                return { ramp: { type: baseRamp.type, value: node.rampUpValue }, direction: direction };
+
+
+            }
+
+
+            if (direction === "down" && node.rampDownValue > 0) {
+
+
+                return { ramp: { type: baseRamp.type, value: node.rampDownValue }, direction: direction };
+
+
+            }
+
+
+            return { ramp: baseRamp, direction: direction };
+
+
+        }
+
+
+
+        function buildStatusText(powerType, inputMode, inputValue, appliedPercent, rampTimeSeconds, ramp) {
+
+
+            const rampType = normalizeRampType(ramp?.type || "none");
+
+
+
+            let baseText = "";
+
+
+            if (powerType === "reactive") {
+
+
+                if (inputMode === "vars") {
+
+
+                    baseText = `Q ${inputValue} VAr -> ${appliedPercent.toFixed(1)}%`;
+
+
+                } else {
+
+
+                    baseText = `Q ${appliedPercent.toFixed(1)}%`;
+
+
+                }
+
+
+            } else {
+
+
+                if (inputMode === "watts") {
+
+
+                    baseText = `P ${inputValue} W -> ${appliedPercent.toFixed(1)}%`;
+
+
+                } else {
+
+
+                    baseText = `P ${appliedPercent.toFixed(1)}%`;
+
+
+                }
+
+
+            }
+
+
+
+            if (rampTimeSeconds === null || rampType === "none") {
+
+
+                return baseText;
+
+
+            }
+
+
+
+            if (rampType === "time") {
+
+
+                return `${baseText} | ramp ${ramp.value}s`;
+
+
+            }
+
+
+
+            if (rampType === "gradient_pct") {
+
+
+                return `${baseText} | ramp ${ramp.value}%/s`;
+
+
+            }
+
+
+
+            if (rampType === "gradient_w") {
+
+
+                return powerType === "reactive"
+
+
+                    ? `${baseText} | ramp ${ramp.value}VAr/s`
+
+
+                    : `${baseText} | ramp ${ramp.value}W/s`;
+
+
+            }
+
+
+
+            return baseText;
+
+
+        }
+
+
+        function normalizeMultiItem(item) {
+
+            if (!item || typeof item !== "object") {
+
+                return null;
+
+            }
+
+
+            const id = String(item.id || item.inverter_id || item.topic || "").trim();
+
+            if (!id) {
+
+                return null;
+
+            }
+
+
+            if (item.payload && typeof item.payload === "object") {
+
+                const payload = Object.assign({}, item.payload);
+
+                if (!Number.isFinite(Number(payload.limit_w)) && Number.isFinite(Number(item.limit_w))) {
+
+                    payload.limit_w = Number(item.limit_w);
+
+                }
+
+                if (!Number.isFinite(Number(payload.limit_var)) && Number.isFinite(Number(item.limit_var))) {
+
+                    payload.limit_var = Number(item.limit_var);
+
+                }
+
+                if (!Number.isFinite(Number(payload.limit_var_pct)) && Number.isFinite(Number(item.limit_var_pct))) {
+
+                    payload.limit_var_pct = Number(item.limit_var_pct);
+
+                }
+
+                if (!payload.ramp && item.ramp && typeof item.ramp === "object") {
+
+                    payload.ramp = item.ramp;
+
+                }
+
+                if (!Number.isFinite(Number(payload.nominal_power_w)) && Number.isFinite(Number(item.nominal_power_w))) {
+
+                    payload.nominal_power_w = Number(item.nominal_power_w);
+
+                }
+
+                if (!Number.isFinite(Number(payload.nominal_reactive_power_var)) && Number.isFinite(Number(item.nominal_reactive_power_var))) {
+
+                    payload.nominal_reactive_power_var = Number(item.nominal_reactive_power_var);
+
+                }
+
+                return { id: id, payload: payload };
+
+            }
+
+
+            const payload = {};
+
+            if (Number.isFinite(Number(item.limit_w))) {
+
+                payload.limit_w = Number(item.limit_w);
+
+            }
+
+            if (Number.isFinite(Number(item.limit_var))) {
+
+                payload.limit_var = Number(item.limit_var);
+
+            }
+
+            if (Number.isFinite(Number(item.limit_var_pct))) {
+
+                payload.limit_var_pct = Number(item.limit_var_pct);
+
+            }
+
+            if (item.ramp && typeof item.ramp === "object") {
+
+                payload.ramp = item.ramp;
+
+            }
+
+            if (Number.isFinite(Number(item.nominal_power_w))) {
+
+                payload.nominal_power_w = Number(item.nominal_power_w);
+
+            }
+
+            if (Number.isFinite(Number(item.nominal_reactive_power_var))) {
+
+                payload.nominal_reactive_power_var = Number(item.nominal_reactive_power_var);
+
+            }
+
+            [
+                "command_id",
+                "command_requested_at_ms",
+                "control_received_at_ms",
+                "control_calculated_at_ms",
+                "allocated_at_ms"
+            ].forEach(function (key) {
+                if (item[key] !== undefined) payload[key] = item[key];
+            });
+
+            return { id: id, payload: payload };
+
+        }
+
+
+        function rewriteMessageForMultiInverter(msg) {
+
+            if (!node.multiInverter) {
+
+                return msg;
+
+            }
+
+
+            if (!node.inverterId) {
+
+                throw new Error("Inverter ID este obligatoriu cand Multi-inverter este activ");
+
+            }
+
+
+            const payload = msg && msg.payload;
+
+            let items = null;
+
+
+            if (Array.isArray(payload)) {
+
+                items = payload;
+
+            } else if (payload && typeof payload === "object") {
+
+                if (Array.isArray(payload.limits)) {
+
+                    items = payload.limits;
+
+                } else if (Array.isArray(payload.inverters)) {
+
+                    items = payload.inverters;
+
+                }
+
+            }
+
+
+            if (!Array.isArray(items)) {
+
+                throw new Error("Payload multi-inverter invalid: lipseste lista de limite");
+
+            }
+
+
+            const normalizedItems = items
+
+                .map(normalizeMultiItem)
+
+                .filter(Boolean);
+
+
+            const target = normalizedItems.find(function (entry) {
+
+                return entry.id === node.inverterId;
+
+            });
+
+
+            if (!target) {
+
+                throw new Error("Inverter ID '" + node.inverterId + "' nu exista in payload-ul multi-inverter");
+
+            }
+
+
+            return Object.assign({}, msg, {
+
+                topic: node.inverterId,
+
+                payload: target.payload
+
+            });
+
+        }
+
+
+
+        function getControlOffsets() {
+
+
+            return {
+
+
+                active: {
+
+
+                    pctOffset: 3,
+
+
+                    winTmsOffset: 4,
+
+
+                    rvrtTmsOffset: 5,
+
+
+                    rmpTmsOffset: 6,
+
+
+                    enaOffset: 7,
+
+
+                    sfIndex: 21
+
+
+                },
+
+
+                reactive: {
+
+
+                    pctOffset: 14,
+
+
+                    winTmsOffset: 16,
+
+
+                    rvrtTmsOffset: 17,
+
+
+                    rmpTmsOffset: 18,
+
+
+                    enaOffset: 20,
+
+
+                    sfIndex: 23
+
+
+                }
+
+
+            };
+
+
+        }
+
+
+
+        async function handleInput(msg) {
+
+
+            try {
+                const effectiveMsg = rewriteMessageForMultiInverter(msg);
+                const commandRequestedAtMs = optionalPositiveTimestampMs(effectiveMsg.payload, "command_requested_at_ms");
+                if (commandRequestedAtMs !== null && (Date.now() - commandRequestedAtMs) > node.maxCommandAgeMs) {
+                    throw new Error("Comanda Fronius a expirat in coada");
+                }
+
+                const writeStartedAtMs = Date.now();
+                const result = await executeWithRetry("fronius-write operation", async function () {
+
+
+                    await connect();
+
+
+                    if (!sunspecBase) {
+
+                        sunspecBase = await findBase();
+
+                    }
+
+
+                    if (!cachedControlModel) {
+
+                        cachedControlModel = await findControlModel(sunspecBase);
+
+                    }
+
+
+                    const controlModel = cachedControlModel;
+
+                    const controlOffsets = getControlOffsets();
+
+                    const input = extractInput(effectiveMsg);
+
+                    const selectedOffsets = input.powerType === "reactive"
+
+                        ? controlOffsets.reactive
+
+                        : controlOffsets.active;
+
+                    const otherOffsets = input.powerType === "reactive"
+
+                        ? controlOffsets.active
+
+                        : controlOffsets.reactive;
+
+
+                    let percent = computePercent(input.powerType, input.mode, input.value, input);
+
+                    percent = clampSignedPercent(input.powerType, percent);
+
+                    const directionalRamp = selectDirectionalRamp(input, percent);
+
+                    input.ramp = directionalRamp.ramp;
+
+
+                    const rampTimeSeconds = computeRampTimeSeconds(input.powerType, percent, input.ramp, input);
+
+                    const sfRaw = controlModel.raw[selectedOffsets.sfIndex];
+
+
+                    if (sfRaw === undefined) {
+
+                        throw new Error("Scale factor index inexistent pentru modelul de control " + controlModel.modelId);
+
+                    }
+
+
+                    const sf = toSigned16(sfRaw);
+
+                    let scaledValue = invScale(percent, sf);
+
+
+                    if (input.powerType === "reactive") {
+
+                        if (scaledValue > 32767) scaledValue = 32767;
+
+                        if (scaledValue < -32768) scaledValue = -32768;
+
+                    } else {
+
+                        if (scaledValue < 0) scaledValue = 0;
+
+                        if (scaledValue > 32767) scaledValue = 32767;
+
+                    }
+
+
+                    const rawRegisterValue = input.powerType === "reactive"
+
+                        ? toUnsigned16FromSigned(scaledValue)
+
+                        : scaledValue;
+
+
+                    const rampRegisterValue = rampTimeSeconds !== null ? rampTimeSeconds : 0;
+                    assertRange(rampRegisterValue, 0, 65535, "Ramp Time (s)");
+
+                    const selectedEnableAddr = controlModel.baseAddr + selectedOffsets.enaOffset;
+                    const otherEnableAddr = controlModel.baseAddr + otherOffsets.enaOffset;
+                    const rampAddr = controlModel.baseAddr + selectedOffsets.rmpTmsOffset;
+                    const windowAddr = controlModel.baseAddr + selectedOffsets.winTmsOffset;
+                    const revertAddr = controlModel.baseAddr + selectedOffsets.rvrtTmsOffset;
+                    const setpointAddr = controlModel.baseAddr + selectedOffsets.pctOffset;
+                    let setpointReadback = null;
+                    let selectedEnableReadback = null;
+                    let otherEnableReadback = null;
+                    let appliedSetpointReadback = null;
+                    async function runFullWriteSequence() {
+                        // Keep the opposite control loop disabled; do not drop the selected loop to 0
+                        // because some Fronius firmwares only latch the limit after an enabled write.
+                        await writeSingleLabeled(otherEnableAddr, 0, "Enable control opus");
+                        otherEnableReadback = await verifyOppositeEnableRegister(otherEnableAddr, 0);
+
+                        await writeSingleLabeled(rampAddr, rampRegisterValue, "Ramp Time");
+                        await writeSingleLabeled(windowAddr, 0, "Window Time");
+                        await writeSingleLabeled(revertAddr, 0, "Revert Time");
+                        await writeSingleLabeled(setpointAddr, rawRegisterValue, "Setpoint");
+
+                        await verifyRegister(rampAddr, rampRegisterValue, "Ramp Time");
+                        await verifyRegister(windowAddr, 0, "Window Time");
+                        await verifyRegister(revertAddr, 0, "Revert Time");
+                        setpointReadback = await verifyRegister(setpointAddr, rawRegisterValue, "Setpoint");
+
+                        await writeSingleLabeled(selectedEnableAddr, 1, "Enable control selectat");
+                        selectedEnableReadback = await verifyRegister(selectedEnableAddr, 1, "Enable control selectat");
+                        otherEnableReadback = await verifyOppositeEnableRegister(otherEnableAddr, 0);
+
+                        await writeSingleLabeled(setpointAddr, rawRegisterValue, "Setpoint activ");
+                        appliedSetpointReadback = await verifyRegister(setpointAddr, rawRegisterValue, "Setpoint activ");
+
+                    }
+
+                    try {
+                        await runFullWriteSequence();
+                        confirmedControlState = {
+                            powerType: input.powerType,
+                            controlModelBaseAddr: controlModel.baseAddr,
+                            rampRegisterValue: rampRegisterValue,
+                            selectedEnableAddr: selectedEnableAddr,
+                            otherEnableAddr: otherEnableAddr,
+                            rawRegisterValue: rawRegisterValue
+                        };
+                    } catch (writeError) {
+                        confirmedControlState = null;
+                        // Best effort: a partial command must not remain enabled.
+                        await writeSingleLabeled(selectedEnableAddr, 0, "Rollback enable control selectat").catch(function () {});
+                        await writeSingleLabeled(otherEnableAddr, 0, "Rollback enable control opus").catch(function () {});
+                        throw writeError;
+                    }
+
+
+                    return {
+
+                        input: input,
+
+                        percent: percent,
+
+                        rampDirection: directionalRamp.direction,
+
+                        rampTimeSeconds: rampTimeSeconds,
+
+                        sf: sf,
+
+                        scaledValue: scaledValue,
+
+                        rawRegisterValue: rawRegisterValue,
+
+                        controlModel: controlModel,
+
+                        selectedOffsets: selectedOffsets,
+                        setpointAddr: setpointAddr,
+                        selectedEnableAddr: selectedEnableAddr,
+                        otherEnableAddr: otherEnableAddr,
+                        rampAddr: rampAddr,
+                        windowAddr: windowAddr,
+                        revertAddr: revertAddr,
+                        setpointReadback: setpointReadback,
+                        appliedSetpointReadback: appliedSetpointReadback,
+                        selectedEnableReadback: selectedEnableReadback,
+                        otherEnableReadback: otherEnableReadback,
+                        readbackVerificationDisabled: node.disableReadbackVerification,
+                        commandMeta: effectiveMsg.payload && typeof effectiveMsg.payload === "object" ? {
+                            commandId: effectiveMsg.payload.command_id || null,
+                            requestedAtMs: optionalPositiveTimestampMs(effectiveMsg.payload, "command_requested_at_ms"),
+                            controlReceivedAtMs: optionalPositiveTimestampMs(effectiveMsg.payload, "control_received_at_ms"),
+                            controlCalculatedAtMs: optionalPositiveTimestampMs(effectiveMsg.payload, "control_calculated_at_ms"),
+                            allocatedAtMs: optionalPositiveTimestampMs(effectiveMsg.payload, "allocated_at_ms")
+                        } : {}
+
+                    };
+
+                });
+
+
+                const verifiedAtMs = Date.now();
+                lastAppliedPercentByPowerType[result.input.powerType] = result.percent;
+                const endToEndLatencyMs = Number.isFinite(result.commandMeta.requestedAtMs)
+                    ? Math.max(0, verifiedAtMs - result.commandMeta.requestedAtMs)
+                    : null;
+                const statusText = buildStatusText(
+
+                    result.input.powerType,
+
+                    result.input.mode,
+
+                    result.input.value,
+
+                    result.percent,
+
+                    result.rampTimeSeconds,
+
+                    result.input.ramp
+
+                );
+
+
+                node.status({
+
+                    fill: "green",
+
+                    shape: "dot",
+
+                    text: statusText
+
+                });
+
+                if (Number.isFinite(endToEndLatencyMs) && endToEndLatencyMs > node.latencyTargetMs) {
+                    node.status({ fill: "yellow", shape: "ring", text: statusText + " | latency " + endToEndLatencyMs + "ms" });
+                    node.warn("Fronius Write latency target exceeded: " + endToEndLatencyMs + "ms > " + node.latencyTargetMs + "ms");
+                }
+
+
+                node.send({
+
+                    topic: "fronius/write",
+
+                    payload: {
+
+                        status: "ok",
+
+                        detection_mode: "auto",
+
+                        power_type: result.input.powerType,
+
+                        mode: result.input.mode,
+
+                        input_value: result.input.value,
+
+                        max_power_w:
+
+                            result.input.powerType === "active"
+
+                                ? node.maxPower
+
+                                : null,
+
+                        nominal_power_w:
+
+                            result.input.powerType === "active" &&
+
+                            (result.input.mode === "watts" || result.input.ramp.type === "gradient_w")
+
+                                ? effectiveNominalPower(result.input)
+
+                                : null,
+
+                        nominal_reactive_power_var:
+
+                            result.input.powerType === "reactive" &&
+
+                            (result.input.mode === "vars" || result.input.ramp.type === "gradient_w")
+
+                                ? effectiveNominalReactivePower(result.input)
+
+                                : null,
+
+                        applied_percent: result.percent,
+
+                        scaled_signed_value: result.scaledValue,
+
+                        raw_written: result.rawRegisterValue,
+
+                        scale_factor: result.sf,
+
+                        ramp_type: result.input.ramp.type,
+
+                        ramp_direction: result.rampDirection,
+
+                        ramp_time_seconds: result.rampTimeSeconds,
+
+                        ramp_input: result.input.ramp.type === "none" ? null : result.input.ramp.value,
+
+                        setpoint_addr: result.setpointAddr,
+
+                        enable_addr: result.selectedEnableAddr,
+
+                        other_enable_addr: result.otherEnableAddr,
+
+                        ramp_addr: result.rampAddr,
+
+                        window_addr: result.windowAddr,
+
+                        revert_addr: result.revertAddr,
+
+                        enable_written: 1,
+
+                        other_enable_written: 0,
+
+                        setpoint_readback: result.setpointReadback,
+
+                        applied_setpoint_readback: result.appliedSetpointReadback,
+
+                        selected_enable_readback: result.selectedEnableReadback,
+
+                        other_enable_readback: result.otherEnableReadback,
+
+                        readback_verification_disabled: result.readbackVerificationDisabled,
+
+                        command_id: result.commandMeta.commandId,
+
+                        command_requested_at_ms: result.commandMeta.requestedAtMs,
+
+                        control_received_at_ms: result.commandMeta.controlReceivedAtMs,
+
+                        control_calculated_at_ms: result.commandMeta.controlCalculatedAtMs,
+
+                        allocated_at_ms: result.commandMeta.allocatedAtMs,
+
+                        write_started_at_ms: writeStartedAtMs,
+
+                        verified_at_ms: verifiedAtMs,
+
+                        end_to_end_latency_ms: endToEndLatencyMs,
+
+                        latency_target_ms: node.latencyTargetMs,
+
+                        latency_target_exceeded: Number.isFinite(endToEndLatencyMs) && endToEndLatencyMs > node.latencyTargetMs,
+
+                        sunspec_base: sunspecBase,
+
+                        control_model_id: result.controlModel.modelId,
+
+                        control_model_addr: result.controlModel.addr,
+
+                        control_model_base_addr: result.controlModel.baseAddr,
+
+                        written_register_offset: result.selectedOffsets.pctOffset,
+
+                        ts: new Date().toISOString()
+
+                    }
+
+                });
+
+
+                setNodeRuntimeState(node.id, {
+
+                    status: "ok",
+
+                    node_id: node.id,
+
+                    host: node.host,
+
+                    port: node.port,
+
+                    unit_id: node.unitId,
+
+                    multi_inverter: !!node.multiInverter,
+
+                    inverter_id: node.inverterId || null,
+
+                    power_type: result.input.powerType,
+
+                    mode: result.input.mode,
+
+                    input_value: result.input.value,
+
+                    applied_percent: result.percent,
+
+                    ramp_type: result.input.ramp.type,
+
+                    ramp_time_seconds: result.rampTimeSeconds,
+
+                    control_model_id: result.controlModel.modelId,
+
+                    written_register_offset: result.selectedOffsets.pctOffset,
+
+                    readback_verification_disabled: result.readbackVerificationDisabled,
+
+                    ts: new Date().toISOString()
+
+                });
+
+
+            } catch (e) {
+
+
+                if (isRetryableModbusError(e)) {
+
+                    await resetRuntimeAfterCommFailure();
+
+                } else {
+
+                    cachedControlModel = null;
+
+                }
+
+
+
+                node.status({
+
+
+                    fill: "red",
+
+
+                    shape: "ring",
+
+
+                    text: "error"
+
+
+                });
+
+
+
+                node.error(e.message, msg);
+
+
+
+                node.send({
+
+
+                    topic: "fronius/error",
+
+
+                    payload: {
+
+
+                        status: "error",
+
+
+                        detection_mode: "auto",
+
+
+                        error: e.message,
+
+
+                        ts: new Date().toISOString()
+
+
+                    }
+
+
+                });
+
+
+                setNodeRuntimeState(node.id, {
+
+                    status: "error",
+
+                    node_id: node.id,
+
+                    host: node.host,
+
+                    port: node.port,
+
+                    unit_id: node.unitId,
+
+                    multi_inverter: !!node.multiInverter,
+
+                    inverter_id: node.inverterId || null,
+
+                    error: e.message,
+
+                    ts: new Date().toISOString()
+
+                });
+
+
+            }
+
+
+        }
+
+        node.on("input", function (msg, send, done) {
+            if (pendingOperation && pendingOperation.done) pendingOperation.done();
+            pendingOperation = { msg: msg, done: done };
+            if (operationWorkerRunning) return;
+
+            operationWorkerRunning = true;
+            operationWorker = (async function () {
+                while (pendingOperation) {
+                    const current = pendingOperation;
+                    pendingOperation = null;
+                    try {
+                        await handleInput(current.msg);
+                        if (current.done) current.done();
+                    } catch (error) {
+                        if (current.done) current.done(error);
+                        else node.error(error, current.msg);
+                    }
+                }
+            })().finally(function () {
+                operationWorkerRunning = false;
+            });
+        });
+
+
+
+        node.on("close", async function (done) {
+            await operationWorker.catch(function () {});
+
+
+            try {
+
+
+                if (client && client.isOpen) {
+
+
+                    await client.close();
+
+
+                }
+
+
+                clearNodeRuntimeState(node.id);
+
+
+            } catch (e) {
+
+
+                // ignore
+
+
+            }
+
+
+            done();
+
+
+        });
+
+
+    
+        });
+    }
+
+
+
+    RED.nodes.registerType("fronius-write", FroniusWriteNode);
+
+
+};