@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/sma-write/sma-write.js

@@ -0,0 +1,270 @@
+"use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+module.exports = function (RED) {
+    const ModbusRTU = require("modbus-serial");
+    const { atLeast, clampNumber } = require("../lib/numbers");
+    const RUNTIME_VERSION = require("../package.json").version;
+    const MODEL_123 = 123;
+    const BASES = [39999, 40000, 40001, 40002, 40199, 40200, 40201, 40202];
+    const MAX_MODELS = 256;
+    const states = new Map();
+
+    function state(id, value) {
+        states.set(id, Object.assign({ runtime_version: RUNTIME_VERSION, updated_at: new Date().toISOString() }, value));
+    }
+
+    async function readHolding(client, address, count) {
+        const data = [];
+        for (let offset = 0; offset < count;) {
+            const size = Math.min(120, count - offset);
+            const response = await client.readHoldingRegisters(address + offset, size);
+            if (!response || !Array.isArray(response.data) || response.data.length !== size) {
+                throw new Error("Raspuns Modbus incomplet la registrul " + (address + offset));
+            }
+            data.push.apply(data, response.data);
+            offset += size;
+        }
+        return data;
+    }
+
+    async function findBase(client) {
+        for (const base of BASES) {
+            try {
+                const words = await readHolding(client, base, 2);
+                const signature = words.map(function (word) {
+                    return String.fromCharCode((word >> 8) & 0xff) + String.fromCharCode(word & 0xff);
+                }).join("");
+                if (signature === "SunS") return base;
+            } catch (error) { /* try next standard base */ }
+        }
+        throw new Error("SunSpec not found");
+    }
+
+    async function scanModels(client, base) {
+        const models = [];
+        let address = base + 2;
+        while (true) {
+            if (models.length >= MAX_MODELS || address > 0xfffd) throw new Error("Tabel SunSpec invalid sau neterminat");
+            const header = await readHolding(client, address, 2);
+            const id = header[0];
+            const length = header[1];
+            if (id === 0xffff) break;
+            if (!Number.isInteger(length) || length < 1 || address + 2 + length > 0x10000) {
+                throw new Error("Lungime SunSpec invalida pentru modelul " + id);
+            }
+            const model = { modelId: id, addr: address, baseAddr: address + 2, len: length, raw: null };
+            if (id === MODEL_123) model.raw = await readHolding(client, model.baseAddr, length);
+            models.push(model);
+            address += 2 + length;
+        }
+        return models;
+    }
+
+    function controlModel(models) {
+        const model = models.find(function (item) { return item.modelId === MODEL_123; });
+        if (!model) throw new Error("Modelul SunSpec 123 nu este publicat. Modele: " + models.map(function (m) { return m.modelId; }).join(", "));
+        if (model.len < 24 || !Array.isArray(model.raw) || model.raw.length < 24) throw new Error("Modelul SunSpec 123 este incomplet");
+        if (model.raw[21] === 0x8000) throw new Error("Limitarea puterii active nu este implementata in modelul SunSpec 123");
+        return model;
+    }
+
+    RED.httpAdmin.get("/sma-write/state/:id", function (req, res) {
+        const value = states.get(req.params.id);
+        res.json(value ? { ok: true, state: value } : { ok: false, error: "No cached state" });
+    });
+
+    RED.httpAdmin.get("/sma-write/probe", async function (req, res) {
+        const host = String(req.query.host || "").trim();
+        const port = atLeast(req.query.port, 1, 502);
+        const unitId = Math.min(247, atLeast(req.query.unitId, 1, 126));
+        const client = new ModbusRTU();
+        if (!host) return res.json({ ok: false, error: "IP lipsa" });
+        try {
+            await client.connectTCP(host, { port: port });
+            client.setID(unitId);
+            client.setTimeout(3000);
+            const base = await findBase(client);
+            const models = await scanModels(client, base);
+            const model = controlModel(models);
+            res.json({ ok: true, runtime_version: RUNTIME_VERSION, unit_id: unitId, sunspec_base: base, control_model_id: MODEL_123, control_model_length: model.len });
+        } catch (error) {
+            res.json({ ok: false, runtime_version: RUNTIME_VERSION, error: error.message || String(error) });
+        } finally {
+            try { if (client.isOpen) await client.close(); } catch (error) { /* ignore */ }
+        }
+    });
+
+    function SmaWriteNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+        node.host = String(config.host || "").trim();
+        node.port = atLeast(config.port, 1, 502);
+        node.unitId = Math.min(247, atLeast(config.unitId, 1, 126));
+        node.maxPower = clampNumber(config.maxPower || config.nominalPower, 1, 125000, 125000);
+        node.nominalPower = clampNumber(config.nominalPower || node.maxPower, node.maxPower, 125000, node.maxPower);
+        node.multiInverter = !!config.multiInverter;
+        node.inverterId = String(config.inverterId || "").trim();
+        node.timeout = 3000;
+
+        let client = new ModbusRTU();
+        let base = null;
+        let model = null;
+        let pending = null;
+        let worker = false;
+        let closing = false;
+        let lastRaw = null;
+
+        async function closeClient() {
+            try { if (client.isOpen) await client.close(); } catch (error) { /* ignore */ }
+        }
+
+        async function reset() {
+            await closeClient();
+            client = new ModbusRTU();
+            base = null;
+            model = null;
+        }
+
+        async function connect() {
+            if (!client.isOpen) await client.connectTCP(node.host, { port: node.port });
+            client.setID(node.unitId);
+            client.setTimeout(node.timeout);
+        }
+
+        function valueFromMessage(msg) {
+            let payload = msg ? msg.payload : undefined;
+            if (node.multiInverter && payload && typeof payload === "object") {
+                if (Array.isArray(payload.inverters)) {
+                    payload = payload.inverters.find(function (item) {
+                        return String(item.inverter_id || item.id || item.topic || "") === node.inverterId;
+                    }) || payload;
+                } else if (node.inverterId && payload[node.inverterId] !== undefined) {
+                    payload = payload[node.inverterId];
+                }
+                if (payload && payload.payload !== undefined) payload = payload.payload;
+            }
+            if (typeof payload === "number" || typeof payload === "string") return { value: Number(payload), mode: "watts" };
+            if (!payload || typeof payload !== "object") throw new Error("Payload SMA invalid");
+            if (payload.powerType === "reactive" || payload.power_type === "reactive" || payload.mode === "vars" || payload.vars !== undefined || payload.var !== undefined) {
+                throw new Error("Controlul reactiv nu este disponibil");
+            }
+            const percentValue = payload.percent !== undefined ? payload.percent : payload.limit_pct;
+            if (percentValue !== undefined || payload.mode === "percent") {
+                const value = percentValue !== undefined ? percentValue : payload.value;
+                return { value: Number(value), mode: "percent" };
+            }
+            const candidates = [payload.value, payload.limit_w, payload.watts, payload.power_w, payload.site_limit_w, payload.allocated_limit_w];
+            const value = candidates.find(function (item) { return item !== undefined && item !== null; });
+            return { value: Number(value), mode: "watts" };
+        }
+
+        function command(msg) {
+            const input = valueFromMessage(msg);
+            if (!Number.isFinite(input.value)) throw new Error("Valoare SMA invalida");
+            let percent;
+            if (input.mode === "percent") percent = input.value;
+            else {
+                if (input.value < 0 || input.value > node.maxPower) throw new Error("Puterea trebuie sa fie intre 0 si " + node.maxPower + " W");
+                percent = input.value / node.nominalPower * 100;
+            }
+            percent = Math.max(0, Math.min(100, percent));
+            const sf = model.raw[21] >= 0x8000 ? model.raw[21] - 0x10000 : model.raw[21];
+            const raw = Math.round(percent / Math.pow(10, sf));
+            if (raw < 0 || raw > 0xffff) throw new Error("Setpoint SunSpec in afara domeniului");
+            return { input: input, percent: percent, sf: sf, raw: raw };
+        }
+
+        async function prepare() {
+            await connect();
+            if (base === null) base = await findBase(client);
+            if (!model) model = controlModel(await scanModels(client, base));
+        }
+
+        async function run(msg) {
+            const started = Date.now();
+            let lastError;
+            for (let attempt = 1; attempt <= 3; attempt += 1) {
+                try {
+                    await prepare();
+                    const item = command(msg);
+                    const setpointAddr = model.baseAddr + 3;
+                    const enableAddr = model.baseAddr + 7;
+                    const duplicate = item.raw === lastRaw;
+                    if (!duplicate) {
+                        await client.writeRegisters(setpointAddr, [item.raw]);
+                        await client.writeRegisters(enableAddr, [1]);
+                        lastRaw = item.raw;
+                    }
+                    const finished = Date.now();
+                    const output = {
+                        status: "ok",
+                        accepted_unverified: true,
+                        write_skipped_duplicate: duplicate,
+                        runtime_version: RUNTIME_VERSION,
+                        power_type: "active",
+                        mode: item.input.mode,
+                        input_value: item.input.value,
+                        max_power_w: node.maxPower,
+                        nominal_power_w: node.nominalPower,
+                        applied_percent: item.percent,
+                        raw_written: item.raw,
+                        scale_factor: item.sf,
+                        setpoint_addr: setpointAddr,
+                        enable_addr: enableAddr,
+                        sunspec_base: base,
+                        control_model_id: MODEL_123,
+                        write_duration_ms: finished - started,
+                        ts: new Date(finished).toISOString()
+                    };
+                    node.status({ fill: duplicate ? "blue" : "green", shape: "dot", text: duplicate ? "neschimbat " + item.percent.toFixed(1) + "%" : item.percent.toFixed(1) + "%" });
+                    node.send({ topic: "sma/write", payload: output });
+                    state(node.id, Object.assign({ status: "ok", host: node.host, port: node.port, unit_id: node.unitId }, output));
+                    return;
+                } catch (error) {
+                    lastError = error;
+                    await reset();
+                    if (attempt < 3) await new Promise(function (resolve) { setTimeout(resolve, attempt * 250); });
+                }
+            }
+            const message = lastError && lastError.message ? lastError.message : String(lastError);
+            node.status({ fill: "red", shape: "ring", text: "error" });
+            node.send({ topic: "sma/error", payload: { status: "error", runtime_version: RUNTIME_VERSION, error: message, ts: new Date().toISOString() } });
+            state(node.id, { status: "error", host: node.host, port: node.port, unit_id: node.unitId, error: message });
+        }
+
+        node.on("input", function (msg, send, done) {
+            if (pending && pending.done) pending.done();
+            pending = { msg: msg, done: done };
+            if (worker) return;
+            worker = true;
+            (async function () {
+                while (pending && !closing) {
+                    const current = pending;
+                    pending = null;
+                    await run(current.msg);
+                    if (current.done) current.done();
+                }
+                worker = false;
+            })().catch(function (error) {
+                worker = false;
+                node.error(error);
+            });
+        });
+
+        node.on("close", function (done) {
+            closing = true;
+            states.delete(node.id);
+            closeClient().then(done).catch(done);
+        });
+
+        node.status({});
+    
+        });
+    }
+
+    RED.nodes.registerType("sma-write", SmaWriteNode);
+};

package/victron-read/lib/mqtt-state.js

@@ -0,0 +1,176 @@
+"use strict";
+
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function sanitizePathSegment(segment) {
+    return String(segment || "").trim()
+        .replace(/[^a-zA-Z0-9_\-]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
+
+function topicSegments(topic) {
+    return String(topic || "").split("/").map(sanitizePathSegment).filter(Boolean);
+}
+
+function detectPortalId(topic) {
+    const segments = topicSegments(topic);
+    return segments.length > 1 && ["N", "R", "W"].includes(segments[0]) ? segments[1] : "";
+}
+
+function normalizeSegments(segments, topicPathMode, stripPortalId) {
+    if (topicPathMode === "victron") {
+        if (["N", "R", "W"].includes(segments[0])) segments.shift();
+        if (stripPortalId && segments.length > 1) segments.shift();
+    }
+    return segments.join(".");
+}
+
+function normalizeTopicPath(topic, topicPathMode, stripPortalId) {
+    return normalizeSegments(topicSegments(topic), topicPathMode, stripPortalId);
+}
+
+function normalizeFlatTelemetryKey(key, topicPathMode, stripPortalId) {
+    const segments = String(key || "").split(".").map(sanitizePathSegment).filter(Boolean);
+    return normalizeSegments(segments, topicPathMode, stripPortalId);
+}
+
+function looksLikeFlatTelemetryMap(value) {
+    if (!isPlainObject(value)) return false;
+    const keys = Object.keys(value);
+    if (!keys.length) return false;
+    const inspected = keys.slice(0, 500);
+    const dotted = inspected.filter(function (key) { return String(key).includes("."); }).length;
+    return dotted >= Math.max(3, Math.floor(inspected.length * 0.5));
+}
+
+function getByPath(source, path) {
+    if (isPlainObject(source) && Object.prototype.hasOwnProperty.call(source, path)) return source[path];
+    const parts = String(path || "").split(".").filter(Boolean);
+    let current = source;
+    for (let index = 0; index < parts.length; index += 1) {
+        if (current === null || current === undefined) return undefined;
+        current = current[parts[index]];
+    }
+    return current;
+}
+
+function setByPath(target, path, value) {
+    const parts = String(path || "").split(".").filter(Boolean);
+    if (!isPlainObject(target) || !parts.length) return;
+    let current = target;
+    for (let index = 0; index < parts.length - 1; index += 1) {
+        const key = parts[index];
+        if (!isPlainObject(current[key])) current[key] = {};
+        current = current[key];
+    }
+    current[parts[parts.length - 1]] = value;
+}
+
+function deleteByPath(target, path) {
+    if (!isPlainObject(target) || !path) return false;
+    if (Object.prototype.hasOwnProperty.call(target, path)) {
+        delete target[path];
+        return true;
+    }
+
+    const parts = String(path).split(".").filter(Boolean);
+    const parents = [];
+    let current = target;
+    for (let index = 0; index < parts.length - 1; index += 1) {
+        if (!isPlainObject(current[parts[index]])) return false;
+        parents.push({ object: current, key: parts[index] });
+        current = current[parts[index]];
+    }
+    const leaf = parts[parts.length - 1];
+    if (!Object.prototype.hasOwnProperty.call(current, leaf)) return false;
+    delete current[leaf];
+    for (let index = parents.length - 1; index >= 0; index -= 1) {
+        const parent = parents[index];
+        if (Object.keys(parent.object[parent.key]).length) break;
+        delete parent.object[parent.key];
+    }
+    return true;
+}
+
+function valuesEqual(left, right) {
+    if (Object.is(left, right)) return true;
+    if ((isPlainObject(left) || Array.isArray(left)) && (isPlainObject(right) || Array.isArray(right))) {
+        try {
+            return JSON.stringify(left) === JSON.stringify(right);
+        } catch (error) {
+            return false;
+        }
+    }
+    return false;
+}
+
+function mergeDecodedMessage(snapshot, updatedAt, topic, decodedValue, options) {
+    const opts = options || {};
+    const now = Number.isFinite(opts.now) ? opts.now : Date.now();
+    const mode = opts.topicPathMode === "raw" ? "raw" : "victron";
+    const stripPortalId = opts.stripPortalId !== false;
+    const changedPaths = [];
+
+    function assign(path, value, direct) {
+        if (!path) return;
+        const previous = direct ? snapshot[path] : getByPath(snapshot, path);
+        if (!valuesEqual(previous, value)) changedPaths.push(path);
+        if (direct) snapshot[path] = value;
+        else setByPath(snapshot, path, value);
+        updatedAt.set(path, now);
+    }
+
+    if (looksLikeFlatTelemetryMap(decodedValue)) {
+        Object.keys(decodedValue).forEach(function (key) {
+            assign(normalizeFlatTelemetryKey(key, mode, stripPortalId), decodedValue[key], true);
+        });
+    } else {
+        assign(normalizeTopicPath(topic, mode, stripPortalId), decodedValue, false);
+    }
+
+    return {
+        changed: changedPaths.length > 0,
+        changedPaths: changedPaths,
+        portalId: detectPortalId(topic)
+    };
+}
+
+function pruneStale(snapshot, updatedAt, staleAfterMs, now) {
+    const maxAge = Number(staleAfterMs);
+    if (!Number.isFinite(maxAge) || maxAge <= 0) return [];
+    const currentTime = Number.isFinite(now) ? now : Date.now();
+    const removed = [];
+    updatedAt.forEach(function (timestamp, path) {
+        if ((currentTime - timestamp) <= maxAge) return;
+        if (deleteByPath(snapshot, path)) removed.push(path);
+        updatedAt.delete(path);
+    });
+    return removed;
+}
+
+function decodePayload(payloadBuffer) {
+    const text = (Buffer.isBuffer(payloadBuffer) ? payloadBuffer.toString("utf8") : String(payloadBuffer || "")).trim();
+    if (!text) return undefined;
+    try {
+        const parsed = JSON.parse(text);
+        if (isPlainObject(parsed) && Object.prototype.hasOwnProperty.call(parsed, "value")) return parsed.value;
+        return parsed;
+    } catch (error) {
+        const lower = text.toLowerCase();
+        if (lower === "true") return true;
+        if (lower === "false") return false;
+        const numberValue = Number(text);
+        return Number.isFinite(numberValue) ? numberValue : text;
+    }
+}
+
+module.exports = {
+    decodePayload,
+    detectPortalId,
+    mergeDecodedMessage,
+    normalizeFlatTelemetryKey,
+    normalizeTopicPath,
+    pruneStale
+};