@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/pylontech-write/pylontech-write.js

@@ -0,0 +1,546 @@
+module.exports = function (RED) {
+
+    "use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+
+    const ModbusRTU = require("modbus-serial");
+    const {
+        atLeast
+    } = require("../lib/numbers");
+
+
+    function toNumber(value) {
+
+        const n = Number(value);
+
+        return Number.isFinite(n) ? n : null;
+
+    }
+
+
+    function toPositiveInt(value, fallback) {
+
+        const n = Math.round(Number(value));
+
+        return Number.isFinite(n) && n > 0 ? n : fallback;
+
+    }
+
+
+    function toNonNegativeInt(value, fallback) {
+
+        const n = Math.round(Number(value));
+
+        return Number.isFinite(n) && n >= 0 ? n : fallback;
+
+    }
+
+
+    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 firstDefined() {
+
+        for (let i = 0; i < arguments.length; i += 1) {
+
+            if (arguments[i] !== undefined) {
+
+                return arguments[i];
+
+            }
+
+        }
+
+        return undefined;
+
+    }
+
+
+    function parseBooleanLike(value) {
+
+        if (typeof value === "boolean") return value;
+
+
+        if (typeof value === "number") {
+
+            if (value === 85 || value === 1) return true;
+
+            if (value === 170 || value === 0) return false;
+
+        }
+
+
+        if (typeof value === "string") {
+
+            const normalized = value.trim().toLowerCase();
+
+
+            if (["1", "true", "on", "enable", "enabled", "activ", "active", "auto"].includes(normalized)) {
+
+                return true;
+
+            }
+
+
+            if (["0", "false", "off", "disable", "disabled", "dezactiv", "inactive", "manual"].includes(normalized)) {
+
+                return false;
+
+            }
+
+
+            if (normalized === "85") return true;
+
+            if (normalized === "170") return false;
+
+        }
+
+
+        return null;
+
+    }
+
+
+    function PylontechWriteNode(config) {
+
+        RED.nodes.createNode(this, config);
+
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+
+
+        node.name = String(config.name || "").trim();
+
+        node.host = String(config.host || "").trim();
+
+        node.port = toPositiveInt(config.port, 502);
+
+        node.unitId = toPositiveInt(config.unitId, 1);
+
+
+        node.externalControlRegister = toNonNegativeInt(config.externalControlRegister, 3006);
+
+        node.externalControlEnabledValue = toNonNegativeInt(config.externalControlEnabledValue, 85);
+
+        node.externalControlDisabledValue = toNonNegativeInt(config.externalControlDisabledValue, 170);
+
+
+        node.powerRegister = toNonNegativeInt(config.powerRegister, 3007);
+
+        node.powerScaleKw = atLeast(config.powerScaleKw, 0.000001, 0.1);
+
+
+        let client = new ModbusRTU();
+        let operationQueue = Promise.resolve();
+
+
+        async function connect() {
+
+            if (!client.isOpen) {
+
+                await client.connectTCP(node.host, { port: node.port });
+
+            }
+
+
+            client.setID(node.unitId);
+
+            client.setTimeout(2500);
+
+        }
+
+
+        async function closeConnection() {
+
+            try {
+
+                if (client && client.isOpen) {
+
+                    await client.close();
+
+                }
+
+            } catch (e) {
+
+                // ignore
+
+            }
+
+            client = new ModbusRTU();
+
+        }
+
+
+        function externalControlRaw(enabled) {
+
+            return enabled
+
+                ? node.externalControlEnabledValue
+
+                : node.externalControlDisabledValue;
+
+        }
+
+
+        function powerRawFromKw(powerKw) {
+
+            if (!Number.isFinite(powerKw)) {
+
+                throw new Error("Puterea trebuie să fie numerică");
+
+            }
+
+
+            if (!Number.isFinite(node.powerScaleKw) || node.powerScaleKw <= 0) {
+
+                throw new Error("Power Scale (kW/unitate) trebuie să fie > 0");
+
+            }
+
+
+            const signed = Math.round(powerKw / node.powerScaleKw);
+
+            return toUnsigned16FromSigned(signed);
+
+        }
+
+
+        function extractInput(msg) {
+
+            let powerKw = null;
+
+            let externalControlEnabled = null;
+
+            let batteryId = String(
+
+                firstDefined(
+
+                    msg.batteryId,
+
+                    msg.payload && msg.payload.batteryId,
+
+                    msg.payload && msg.payload.battery_id
+
+                ) || ""
+
+            ).trim();
+
+
+            if (typeof msg.payload === "number" || (typeof msg.payload === "string" && String(msg.payload).trim() !== "")) {
+
+                const direct = Number(msg.payload);
+
+                if (Number.isFinite(direct)) {
+
+                    powerKw = direct;
+
+                }
+
+            } else if (msg.payload && typeof msg.payload === "object") {
+
+                const p = msg.payload;
+
+
+                const externalRaw = firstDefined(
+
+                    p.external_control,
+
+                    p.externalControl,
+
+                    p.enable_external_control,
+
+                    p.enableExternalControl,
+
+                    p.control_extern,
+
+                    p.enabled,
+
+                    p.enable
+
+                );
+
+
+                if (externalRaw !== undefined) {
+
+                    externalControlEnabled = parseBooleanLike(externalRaw);
+
+                }
+
+
+                const powerKwRaw = firstDefined(
+
+                    p.power_kw,
+
+                    p.limit_kw,
+
+                    p.value_kw,
+
+                    p.kw,
+
+                    p.power
+
+                );
+
+                const powerWRaw = firstDefined(
+
+                    p.power_w,
+
+                    p.limit_w,
+
+                    p.value_w,
+
+                    p.watts
+
+                );
+
+
+                if (powerKwRaw !== undefined) {
+
+                    powerKw = toNumber(powerKwRaw);
+
+                } else if (powerWRaw !== undefined) {
+
+                    const watts = toNumber(powerWRaw);
+
+                    powerKw = Number.isFinite(watts) ? (watts / 1000) : null;
+
+                }
+
+            }
+
+
+            if (msg.externalControl !== undefined && externalControlEnabled === null) {
+
+                externalControlEnabled = parseBooleanLike(msg.externalControl);
+
+            }
+
+            if (msg.powerKw !== undefined && powerKw === null) {
+
+                powerKw = toNumber(msg.powerKw);
+
+            }
+
+            if (msg.powerW !== undefined && powerKw === null) {
+
+                const watts = toNumber(msg.powerW);
+
+                powerKw = Number.isFinite(watts) ? (watts / 1000) : null;
+
+            }
+
+
+            if (externalControlEnabled === null && powerKw === null) {
+
+                throw new Error("msg.payload trebuie să conțină power_kw/power_w sau external_control");
+
+            }
+
+
+            return {
+
+                powerKw: powerKw,
+
+                externalControlEnabled: externalControlEnabled,
+
+                batteryId: batteryId || null
+
+            };
+
+        }
+
+
+        function buildStatusText(powerKw, externalControlEnabled) {
+
+            const parts = [];
+
+
+            if (externalControlEnabled !== null) {
+
+                parts.push(externalControlEnabled ? "ext on" : "ext off");
+
+            }
+
+
+            if (Number.isFinite(powerKw)) {
+
+                parts.push("P " + powerKw.toFixed(1) + "kW");
+
+            }
+
+
+            return parts.length ? parts.join(" | ") : "write";
+
+        }
+
+
+        async function handleInput(msg) {
+
+            try {
+
+                await connect();
+
+
+                const input = extractInput(msg);
+
+                let externalRaw = null;
+
+                let powerRaw = null;
+
+
+                if (input.externalControlEnabled !== null) {
+
+                    externalRaw = externalControlRaw(input.externalControlEnabled);
+
+                    await client.writeRegister(node.externalControlRegister, externalRaw);
+
+                }
+
+
+                if (input.powerKw !== null) {
+
+                    powerRaw = powerRawFromKw(input.powerKw);
+
+                    await client.writeRegister(node.powerRegister, powerRaw);
+
+                }
+
+
+                node.status({
+
+                    fill: "green",
+
+                    shape: "dot",
+
+                    text: buildStatusText(input.powerKw, input.externalControlEnabled)
+
+                });
+
+
+                node.send({
+
+                    topic: "pylontech/write",
+
+                    batteryId: input.batteryId,
+
+                    payload: {
+
+                        status: "ok",
+
+                        host: node.host,
+
+                        port: node.port,
+
+                        unit_id: node.unitId,
+
+                        battery_id: input.batteryId,
+
+                        external_control_written: input.externalControlEnabled !== null,
+
+                        external_control_enabled: input.externalControlEnabled,
+
+                        external_control_register: input.externalControlEnabled !== null ? node.externalControlRegister : null,
+
+                        external_control_raw: externalRaw,
+
+                        power_written: input.powerKw !== null,
+
+                        power_kw: input.powerKw,
+
+                        power_register: input.powerKw !== null ? node.powerRegister : null,
+
+                        power_raw: powerRaw,
+
+                        power_scale_kw: node.powerScaleKw,
+
+                        ts: new Date().toISOString()
+
+                    }
+
+                });
+
+            } catch (err) {
+
+                node.status({ fill: "red", shape: "ring", text: "error" });
+
+                node.error(err.message, msg);
+
+
+                node.send({
+
+                    topic: "pylontech/error",
+
+                    batteryId: msg && msg.batteryId ? msg.batteryId : (msg && msg.payload ? (msg.payload.batteryId || msg.payload.battery_id || null) : null),
+
+                    payload: {
+
+                        status: "error",
+
+                        host: node.host,
+
+                        port: node.port,
+
+                        unit_id: node.unitId,
+
+                        battery_id: msg && msg.batteryId ? msg.batteryId : (msg && msg.payload ? (msg.payload.batteryId || msg.payload.battery_id || null) : null),
+
+                        error: err.message,
+
+                        ts: new Date().toISOString()
+
+                    }
+
+                });
+
+
+                await closeConnection();
+
+            }
+
+        }
+
+        node.on("input", function (msg, send, done) {
+            operationQueue = operationQueue.catch(function () {}).then(function () {
+                return handleInput(msg);
+            });
+            operationQueue.then(function () {
+                if (done) done();
+            }).catch(function (error) {
+                if (done) done(error);
+                else node.error(error, msg);
+            });
+        });
+
+
+        node.on("close", async function (done) {
+            await operationQueue.catch(function () {});
+
+            await closeConnection();
+
+            done();
+
+        });
+
+    
+        });
+    }
+
+
+    RED.nodes.registerType("pylontech-write", PylontechWriteNode);
+
+};

package/scada-aggregator/lib/aggregate.js

@@ -0,0 +1,72 @@
+"use strict";
+
+const SIGNALS = ["p", "q", "u_l1n", "u_l2n", "u_l3n", "u_ln_avg", "u_l12", "u_l23", "u_l31", "u_ll_avg", "f"];
+const SUM_SIGNALS = new Set(["p", "q"]);
+
+function average(values) {
+    const contributors = values.filter(function (value) { return value !== 0; });
+    if (!contributors.length) return null;
+    return contributors.reduce(function (sum, value) { return sum + value; }, 0) / contributors.length;
+}
+
+function finite(value) {
+    const number = Number(value);
+    return Number.isFinite(number) ? number : null;
+}
+
+function firstValue(message, paths) {
+    for (const path of paths) {
+        const parts = path.split(".");
+        let value = message;
+        for (const part of parts) value = value == null ? undefined : value[part];
+        const number = finite(value);
+        if (number !== null) return number;
+    }
+    return null;
+}
+
+const PATHS = {
+    p: ["payload.p", "payload.power_w", "payload.active_power_w", "payload.power_total_w", "payload.summary.ac.power_w", "payload.summary.meter.power_w", "payload.summary.power.total_w"],
+    q: ["payload.q", "payload.reactive_power_var", "payload.reactive_total_var", "payload.summary.ac.reactive_power_var", "payload.summary.meter.reactive_power_var", "payload.summary.reactive.total_var"],
+    f: ["payload.f", "payload.frequency_hz", "payload.summary.ac.frequency_hz", "payload.summary.meter.frequency_hz", "payload.summary.frequency_hz"],
+    u_l1n: ["payload.u_l1n", "payload.voltage_l1_n_v", "payload.voltage_l1_v", "payload.summary.ac.voltage_l1_v", "payload.summary.meter.voltage_l1_v"],
+    u_l2n: ["payload.u_l2n", "payload.voltage_l2_n_v", "payload.voltage_l2_v", "payload.summary.ac.voltage_l2_v", "payload.summary.meter.voltage_l2_v"],
+    u_l3n: ["payload.u_l3n", "payload.voltage_l3_n_v", "payload.voltage_l3_v", "payload.summary.ac.voltage_l3_v", "payload.summary.meter.voltage_l3_v"],
+    u_ln_avg: ["payload.u_ln_avg", "payload.voltage_ln_avg_v", "payload.summary.meter.voltage_ln_avg_v"],
+    u_l12: ["payload.u_l12", "payload.voltage_l1_l2_v", "payload.summary.ac.voltage_ll_ab_v", "payload.summary.meter.voltage_ll_ab_v", "payload.summary.voltage.l1_l2_v"],
+    u_l23: ["payload.u_l23", "payload.voltage_l2_l3_v", "payload.summary.ac.voltage_ll_bc_v", "payload.summary.meter.voltage_ll_bc_v", "payload.summary.voltage.l2_l3_v"],
+    u_l31: ["payload.u_l31", "payload.voltage_l3_l1_v", "payload.voltage_l1_l3_v", "payload.summary.ac.voltage_ll_ca_v", "payload.summary.meter.voltage_ll_ca_v", "payload.summary.voltage.l3_l1_v"],
+    u_ll_avg: ["payload.u_ll_avg", "payload.voltage_ll_avg_v", "payload.summary.meter.voltage_ll_avg_v"]
+};
+
+function normalizeMessage(message) {
+    const input = message && message.payload === undefined ? { payload: message } : message;
+    const result = {};
+    SIGNALS.forEach(function (signal) { result[signal] = firstValue(input, PATHS[signal]); });
+    if (result.u_ln_avg === null) {
+        const values = [result.u_l1n, result.u_l2n, result.u_l3n].filter(function (value) { return value !== null; });
+        result.u_ln_avg = average(values);
+    }
+    if (result.u_ll_avg === null) {
+        const values = [result.u_l12, result.u_l23, result.u_l31].filter(function (value) { return value !== null; });
+        result.u_ll_avg = average(values);
+    }
+    return result;
+}
+
+function summarize(items) {
+    const result = { active: items.length };
+    SIGNALS.forEach(function (signal) {
+        const values = items.map(function (item) { return item.values[signal]; }).filter(function (value) { return value !== null && value !== undefined; });
+        if (!values.length) return;
+        if (SUM_SIGNALS.has(signal)) {
+            result[signal] = values.reduce(function (sum, value) { return sum + value; }, 0);
+            return;
+        }
+        const mean = average(values);
+        if (mean !== null) result[signal] = mean;
+    });
+    return result;
+}
+
+module.exports = { SIGNALS, average, normalizeMessage, summarize };

package/scada-aggregator/lib/groups.js

@@ -0,0 +1,39 @@
+"use strict";
+
+const DEFAULT_GROUPS = [
+    { id: "grid_meter", label: "Grid meter", count: 3 },
+    { id: "pv_inverter", label: "PV inverter", count: 13 },
+    { id: "bess", label: "BESS", count: 1 }
+];
+
+function slug(value, fallback) {
+    return String(value || "").toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || fallback;
+}
+
+function count(value, fallback) {
+    const number = Number(value);
+    return Number.isFinite(number) ? Math.max(0, Math.min(99, Math.round(number))) : fallback;
+}
+
+function groupList(config) {
+    let parsed;
+    try {
+        parsed = typeof config.aggregatorGroups === "string" ? JSON.parse(config.aggregatorGroups) : config.aggregatorGroups;
+    } catch (_) {
+        parsed = null;
+    }
+    if (!Array.isArray(parsed) || !parsed.length) return DEFAULT_GROUPS.map(function (group) { return Object.assign({}, group); });
+    const used = new Set();
+    return parsed.map(function (group, index) {
+        let id = slug(group && group.id, "group_" + (index + 1));
+        while (used.has(id)) id += "_" + (index + 1);
+        used.add(id);
+        return {
+            id: id,
+            label: String(group && group.label || id).trim() || id,
+            count: count(group && group.count, 1)
+        };
+    });
+}
+
+module.exports = { DEFAULT_GROUPS, groupList };