@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/fronius-emulator/fronius-emulator.js

@@ -0,0 +1,520 @@
+"use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+const { createModbusTcpServer } = require("./lib/modbus-tcp-server");
+const { createFroniusRegisterMap, DEFAULT_MEASUREMENTS } = require("./lib/fronius-register-map");
+const {
+    integerInRange,
+    cleanText,
+    canonicalKey,
+    finiteMeasurement,
+    getByPath,
+    normalizePayload
+} = require("./lib/validation");
+const {
+    normalizeMeterRole,
+    gridReferenceFromSnapshot,
+    deriveSecondaryMeasurements,
+    normalizedEnergyState,
+    integrateDirectionalEnergy
+} = require("./lib/virtual-meter");
+
+module.exports = function (RED) {
+    // Nodes on the same bind/port share one listener and are selected by Unit ID.
+    // Grid providers are also registered separately, allowing PV/battery nodes
+    // bound to other local IPs to reuse the freshest Grid voltage reference.
+    const sharedServers = new Map();
+    const gridProviders = new Map();
+
+    function serverKey(bindAddress, port) {
+        return bindAddress + ":" + port;
+    }
+
+    function forEachMeter(group, callback) {
+        group.meters.forEach(function (meter) {
+            try { callback(meter); } catch (error) { meter.onInternalError(error); }
+        });
+    }
+
+    function createSharedServerGroup(settings) {
+        const group = {
+            key: serverKey(settings.bindAddress, settings.port),
+            bindAddress: settings.bindAddress,
+            port: settings.port,
+            maxClients: settings.maxClients,
+            clientIdleTimeout: settings.clientIdleTimeout,
+            meters: new Map(),
+            listening: false,
+            server: null,
+            startPromise: null
+        };
+
+        group.server = createModbusTcpServer({
+            bindAddress: group.bindAddress,
+            port: group.port,
+            maxClients: group.maxClients,
+            clientIdleTimeout: group.clientIdleTimeout,
+            allowWrites: true,
+            isUnitIdAllowed: function (unitId) {
+                return group.meters.has(unitId);
+            },
+            readRegisters: function (startAddress, quantity, functionCode, unitId) {
+                const meter = group.meters.get(unitId);
+                return meter ? meter.readRegisters(startAddress, quantity, functionCode) : { exceptionCode: 2 };
+            },
+            writeRegisters: function (startAddress, values, unitId) {
+                const meter = group.meters.get(unitId);
+                return meter ? meter.writeRegisters(startAddress, values) : { exceptionCode: 2 };
+            },
+            onClientConnected: function (info) {
+                forEachMeter(group, function (meter) { meter.onClientConnected(info); });
+            },
+            onClientDisconnected: function (info) {
+                forEachMeter(group, function (meter) { meter.onClientDisconnected(info); });
+            },
+            onClientRejected: function (info) {
+                forEachMeter(group, function (meter) { meter.onClientRejected(info); });
+            },
+            onRequest: function (info) {
+                const meter = group.meters.get(info.unitId);
+                if (meter) meter.onRequest(info);
+            },
+            onProtocolError: function (info) {
+                forEachMeter(group, function (meter) { meter.onProtocolError(info); });
+            },
+            onSocketError: function (error) {
+                forEachMeter(group, function (meter) { meter.onSocketError(error); });
+            },
+            onError: function (error) {
+                forEachMeter(group, function (meter) { meter.onServerError(error); });
+            }
+        });
+
+        group.startPromise = group.server.start().then(function (address) {
+            group.listening = true;
+            if (address && address.port) group.port = address.port;
+            return address;
+        }).catch(function (error) {
+            group.listening = false;
+            if (sharedServers.get(group.key) === group) sharedServers.delete(group.key);
+            throw error;
+        });
+        return group;
+    }
+
+    function acquireSharedServer(node, meter) {
+        const key = serverKey(node.bindAddress, node.port);
+        let group = sharedServers.get(key);
+        if (!group) {
+            group = createSharedServerGroup({
+                bindAddress: node.bindAddress,
+                port: node.port,
+                maxClients: node.maxClients,
+                clientIdleTimeout: node.clientIdleTimeout
+            });
+            sharedServers.set(key, group);
+        } else if (group.maxClients !== node.maxClients || group.clientIdleTimeout !== node.clientIdleTimeout) {
+            node.warn("fronius-emulator: serverul comun " + key + " foloseste setarile de clienti ale primei instante");
+        }
+        if (group.meters.has(node.unitId)) {
+            throw new Error("Unit ID " + node.unitId + " este deja folosit pe " + key);
+        }
+        group.meters.set(node.unitId, meter);
+        return group;
+    }
+
+    function releaseSharedServer(group, unitId) {
+        if (!group) return Promise.resolve();
+        group.meters.delete(unitId);
+        if (group.meters.size) return Promise.resolve();
+        if (sharedServers.get(group.key) === group) sharedServers.delete(group.key);
+        return group.startPromise.catch(function () { return null; }).then(function () {
+            group.listening = false;
+            return group.server.stop();
+        });
+    }
+
+    function freshestGridReference(preferredGroup) {
+        const preferred = preferredGroup && preferredGroup.meters.get(1);
+        const preferredReference = preferred && typeof preferred.getGridReference === "function" ? preferred.getGridReference() : null;
+        if (preferredReference) return preferredReference;
+
+        let freshest = null;
+        gridProviders.forEach(function (provider) {
+            const reference = provider.getGridReference();
+            if (!reference) return;
+            if (!freshest || Date.parse(reference.timestamp) > Date.parse(freshest.timestamp)) freshest = reference;
+        });
+        return freshest;
+    }
+
+    function FroniusEmulatorNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+        node.name = "Fronius Emulator";
+        node.meterRole = normalizeMeterRole(config.meterRole);
+        node.bindAddress = cleanText(config.bindAddress, "0.0.0.0", 255);
+        node.port = integerInRange(Number(config.port), 1502, 1, 65535);
+        node.unitId = node.meterRole === "grid"
+            ? 1
+            : integerInRange(Number(config.unitId), node.meterRole === "battery" ? 3 : 2, 2, 14);
+        node.manufacturer = cleanText(config.manufacturer, "Fronius", 64);
+        node.model = cleanText(config.model, "Smart Meter 63A", 64);
+        node.serialNumber = cleanText(config.serialNumber, "00000001", 32);
+        node.updateTimeout = integerInRange(Number(config.updateTimeout), 10000, 100, 86400000);
+        node.staleBehaviour = ["hold-last", "zero-power", "modbus-exception"].includes(config.staleBehaviour) ? config.staleBehaviour : "zero-power";
+        node.powerSignConvention = config.powerSignConvention === "export-positive" ? "export-positive" : "import-positive";
+        node.allowWrites = !!config.allowWrites;
+        node.logRequests = !!config.logRequests;
+        node.maxClients = integerInRange(Number(config.maxClients), 5, 1, 50);
+        node.clientIdleTimeout = integerInRange(Number(config.clientIdleTimeout), 30000, 500, 3600000);
+        node.inputMode = config.inputMode === "topic-values" ? "topic-values" : "payload-object";
+        node.contextType = config.contextType === "flow" ? "flow" : "global";
+        node.powerVariable = cleanText(
+            config.powerVariable || config.globalVariable,
+            node.meterRole === "battery" ? "batteryPower" : "pvPower",
+            255
+        );
+        node.legacyPath = String(config.globalPath || "").trim();
+        node.sourcePollInterval = integerInRange(Number(config.sourcePollInterval || config.globalPollInterval), 1000, 100, 3600000);
+
+        let measurements = Object.assign({}, DEFAULT_MEASUREMENTS);
+        let lastUpdate = null;
+        let stale = node.meterRole !== "grid";
+        let listening = false;
+        let closing = false;
+        let staleTimer = null;
+        let sourceTimer = null;
+        let sharedGroup = null;
+        let registered = false;
+        let inputGridReference = null;
+        let energyState = normalizedEnergyState(node.context().get("secondaryEnergy"));
+        const warningTimes = new Map();
+        const registerMap = createFroniusRegisterMap({
+            manufacturer: node.manufacturer,
+            model: node.model,
+            serialNumber: node.serialNumber,
+            unitId: node.unitId,
+            // PV/battery keep the source sign; the selectable convention applies to Grid.
+            powerSignConvention: node.meterRole === "grid" ? node.powerSignConvention : "import-positive"
+        });
+
+        function effectivePower() {
+            if (stale && node.staleBehaviour === "zero-power") return 0;
+            if (node.meterRole === "grid" && node.powerSignConvention === "export-positive") return -measurements.power;
+            return measurements.power;
+        }
+
+        function roleLabel() {
+            if (node.meterRole === "pv") return "PV";
+            if (node.meterRole === "battery") return "BAT";
+            return "GRID";
+        }
+
+        function clientCount() {
+            return sharedGroup ? sharedGroup.server.clientCount() : 0;
+        }
+
+        function refreshStatus(customText) {
+            if (customText) {
+                node.status({ fill: "yellow", shape: "ring", text: customText });
+                return;
+            }
+            if (!listening) return;
+            const clients = clientCount();
+            if (stale) {
+                node.status({ fill: "yellow", shape: "ring", text: roleLabel() + " U" + node.unitId + " stale | " + Math.round(effectivePower()) + " W" });
+            } else if (clients) {
+                node.status({ fill: "green", shape: "dot", text: roleLabel() + " U" + node.unitId + " | " + Math.round(effectivePower()) + " W | " + clients + " client" + (clients === 1 ? "" : "i") });
+            } else {
+                node.status({ fill: "green", shape: "dot", text: roleLabel() + " U" + node.unitId + " | listening " + node.port });
+            }
+        }
+
+        function emitEvent(event, details, send) {
+            const message = {
+                topic: "fronius-emulator/" + (event === "modbus-request" ? "request" : event),
+                payload: Object.assign({
+                    event,
+                    timestamp: new Date().toISOString(),
+                    meterRole: node.meterRole,
+                    unitId: node.unitId
+                }, details || {})
+            };
+            (send || node.send).call(node, message);
+        }
+
+        function throttledWarning(key, text) {
+            const now = Date.now();
+            if (!warningTimes.has(key) || now - warningTimes.get(key) >= 5000) {
+                warningTimes.set(key, now);
+                node.warn(text);
+            }
+        }
+
+        function scheduleStale() {
+            if (staleTimer) clearTimeout(staleTimer);
+            staleTimer = setTimeout(function () {
+                staleTimer = null;
+                stale = true;
+                refreshStatus();
+            }, node.updateTimeout);
+            if (typeof staleTimer.unref === "function") staleTimer.unref();
+        }
+
+        function markUpdated(timestamp) {
+            lastUpdate = timestamp || new Date().toISOString();
+            stale = false;
+            scheduleStale();
+            refreshStatus();
+        }
+
+        function snapshot() {
+            return {
+                listening,
+                bindAddress: node.bindAddress,
+                port: node.port,
+                unitId: node.unitId,
+                meterRole: node.meterRole,
+                clients: clientCount(),
+                stale,
+                lastUpdate,
+                measurements: Object.assign({}, measurements)
+            };
+        }
+
+        function meterRecord() {
+            return {
+                readRegisters: function (startAddress, quantity) {
+                    return registerMap.read(startAddress, quantity, { measurements, stale, staleBehaviour: node.staleBehaviour });
+                },
+                writeRegisters: function () {
+                    return { exceptionCode: 2 };
+                },
+                getGridReference: function () {
+                    return node.meterRole === "grid" ? gridReferenceFromSnapshot(snapshot()) : null;
+                },
+                onClientConnected: function (info) {
+                    emitEvent("client-connected", { remoteAddress: info.remoteAddress, clients: info.clients });
+                    refreshStatus();
+                },
+                onClientDisconnected: function (info) {
+                    emitEvent("client-disconnected", { remoteAddress: info.remoteAddress, clients: info.clients });
+                    refreshStatus();
+                },
+                onClientRejected: function (info) {
+                    throttledWarning("max-clients", "fronius-emulator: conexiune refuzata; limita de clienti a fost atinsa (" + (info.remoteAddress || "necunoscut") + ")");
+                },
+                onRequest: function (info) {
+                    if (node.logRequests) emitEvent("modbus-request", info);
+                },
+                onProtocolError: function (info) {
+                    throttledWarning(info.code, "fronius-emulator: cadru Modbus invalid de la " + info.remoteAddress + " (" + info.code + ")");
+                },
+                onSocketError: function (error) {
+                    throttledWarning("socket-" + error.code, "fronius-emulator: eroare client: " + error.message);
+                },
+                onServerError: function (error) {
+                    node.status({ fill: "red", shape: "ring", text: "server error" });
+                    const key = "server-" + (error.code || error.message);
+                    const now = Date.now();
+                    if (!warningTimes.has(key) || now - warningTimes.get(key) >= 5000) {
+                        warningTimes.set(key, now);
+                        emitEvent("server-error", { code: error.code || null, message: error.message });
+                        node.error("fronius-emulator: " + error.message);
+                    }
+                },
+                onInternalError: function (error) {
+                    node.error("fronius-emulator: " + error.message);
+                }
+            };
+        }
+
+        const record = meterRecord();
+        if (node.meterRole === "grid") gridProviders.set(node.id, record);
+
+        function readContextPower() {
+            const context = node.context();
+            const store = node.contextType === "flow" ? context.flow : context.global;
+            if (!store || typeof store.get !== "function") throw new Error("contextul " + node.contextType + " nu este disponibil");
+
+            let root = store.get(node.powerVariable);
+            let selected = node.legacyPath ? getByPath(root, node.legacyPath) : root;
+            if (selected === undefined && !node.legacyPath && node.powerVariable.includes(".")) {
+                const parts = node.powerVariable.split(".");
+                root = store.get(parts.shift());
+                selected = getByPath(root, parts.join("."));
+            }
+            if (selected && typeof selected === "object" && Object.prototype.hasOwnProperty.call(selected, "value")) {
+                selected = selected.value;
+            }
+            return finiteMeasurement("power", selected);
+        }
+
+        function updateInputGridReference(msg) {
+            const update = normalizePayload(msg && msg.payload, true, msg);
+            const timestamp = update.timestamp || new Date().toISOString();
+            delete update.timestamp;
+            const reference = gridReferenceFromSnapshot({
+                stale: false,
+                lastUpdate: timestamp,
+                measurements: update
+            });
+            if (!reference) throw new Error("intrarea Grid nu contine tensiuni L1/L2/L3 si frecventa valide");
+            inputGridReference = { reference, receivedAt: Date.now() };
+        }
+
+        function localGridReference() {
+            if (!inputGridReference) return null;
+            if (Date.now() - inputGridReference.receivedAt > node.updateTimeout) {
+                inputGridReference = null;
+                return null;
+            }
+            return inputGridReference.reference;
+        }
+
+        function pollSource() {
+            if (closing || node.meterRole === "grid" || !sharedGroup) return;
+            try {
+                const reference = localGridReference() || freshestGridReference(sharedGroup);
+                if (!reference) {
+                    stale = true;
+                    refreshStatus("U" + node.unitId + " asteapta Grid U1");
+                    return;
+                }
+                const sourcePower = readContextPower();
+                const derived = deriveSecondaryMeasurements(node.meterRole, sourcePower, reference, false);
+                const now = Date.now();
+                const maximumGap = Math.max(node.updateTimeout, node.sourcePollInterval * 5);
+                energyState = integrateDirectionalEnergy(energyState, derived.power, now, maximumGap);
+                node.context().set("secondaryEnergy", energyState);
+                derived.importEnergy = energyState.importEnergy;
+                derived.exportEnergy = energyState.exportEnergy;
+                measurements = Object.assign({}, measurements, derived);
+                markUpdated(new Date(now).toISOString());
+            } catch (error) {
+                stale = true;
+                refreshStatus("U" + node.unitId + " sursa " + node.contextType + " invalida");
+                throttledWarning("context-source-" + error.message, "fronius-emulator: " + error.message);
+            }
+        }
+
+        function startSourcePolling() {
+            if (node.meterRole === "grid" || sourceTimer) return;
+            pollSource();
+            sourceTimer = setInterval(pollSource, node.sourcePollInterval);
+            if (typeof sourceTimer.unref === "function") sourceTimer.unref();
+        }
+
+        node.on("input", function (msg, send, done) {
+            const output = typeof send === "function" ? send : node.send.bind(node);
+            const finish = typeof done === "function" ? done : function () {};
+            try {
+                if (msg && msg.command === "status") {
+                    emitEvent("status", snapshot(), output);
+                    finish();
+                    return;
+                }
+                if (msg && msg.reset === true) {
+                    measurements = Object.keys(DEFAULT_MEASUREMENTS).reduce(function (result, key) {
+                        result[key] = 0;
+                        return result;
+                    }, {});
+                    if (node.meterRole === "grid") {
+                        markUpdated(new Date().toISOString());
+                    } else {
+                        energyState = normalizedEnergyState(null);
+                        node.context().set("secondaryEnergy", energyState);
+                        inputGridReference = null;
+                        stale = true;
+                        lastUpdate = null;
+                        pollSource();
+                    }
+                } else if (node.meterRole !== "grid") {
+                    // Secondary power still comes only from context. The wired meter
+                    // supplies the Grid voltage/frequency reference used for derivation.
+                    updateInputGridReference(msg);
+                    pollSource();
+                } else if (node.inputMode === "topic-values") {
+                    const key = canonicalKey(msg && msg.topic);
+                    if (!key) throw new Error("msg.topic is not a supported measurement");
+                    measurements = Object.assign({}, measurements, { [key]: finiteMeasurement(key, msg.payload) });
+                    markUpdated(new Date().toISOString());
+                } else {
+                    // Preserve direct compatibility with Carlo Gavazzi, Phoenix and Janitza.
+                    const update = normalizePayload(msg && msg.payload, true, msg);
+                    const updateTimestamp = update.timestamp;
+                    delete update.timestamp;
+                    measurements = Object.assign({}, measurements, update);
+                    markUpdated(updateTimestamp || new Date().toISOString());
+                }
+                if (msg && msg.ack === true) emitEvent("status", Object.assign({ reason: "ack" }, snapshot()), output);
+                finish();
+            } catch (error) {
+                emitEvent("validation-error", { message: error.message }, output);
+                throttledWarning("validation-" + error.message, "fronius-emulator: " + error.message);
+                finish(error);
+            }
+        });
+
+        node.status({ fill: "grey", shape: "ring", text: "starting" });
+        try {
+            sharedGroup = acquireSharedServer(node, record);
+            registered = true;
+            sharedGroup.startPromise.then(function (address) {
+                if (closing) return null;
+                listening = true;
+                if (address && address.port) node.port = address.port;
+                if (node.meterRole === "grid") scheduleStale();
+                startSourcePolling();
+                refreshStatus();
+                emitEvent("server-started", {
+                    bindAddress: node.bindAddress,
+                    port: node.port,
+                    unitId: node.unitId,
+                    sharedMeters: sharedGroup.meters.size
+                });
+                return null;
+            }).catch(function (error) {
+                listening = false;
+                const portInUse = error && error.code === "EADDRINUSE";
+                node.status({ fill: "red", shape: "ring", text: portInUse ? "port in use" : "server error" });
+                let message = error.message;
+                if (error.code === "EACCES") message += "; foloseste portul 1502 sau configureaza un proxy/capabilitati OS";
+                emitEvent("server-error", { code: error.code || null, message });
+                node.error("fronius-emulator: " + message);
+            });
+        } catch (error) {
+            node.status({ fill: "red", shape: "ring", text: "duplicate Unit ID" });
+            node.error("fronius-emulator: " + error.message);
+        }
+
+        node.on("close", function (removed, done) {
+            const callback = typeof removed === "function" ? removed : (typeof done === "function" ? done : function () {});
+            closing = true;
+            listening = false;
+            if (node.meterRole === "grid") gridProviders.delete(node.id);
+            if (staleTimer) clearTimeout(staleTimer);
+            staleTimer = null;
+            if (sourceTimer) clearInterval(sourceTimer);
+            sourceTimer = null;
+            const release = registered ? releaseSharedServer(sharedGroup, node.unitId) : Promise.resolve();
+            registered = false;
+            release.then(function () {
+                node.status({ fill: "grey", shape: "ring", text: "stopped" });
+                emitEvent("server-stopped", { bindAddress: node.bindAddress, port: node.port, unitId: node.unitId });
+                callback();
+            }).catch(function (error) {
+                node.error("fronius-emulator: eroare la oprire: " + error.message);
+                callback();
+            });
+        });
+    
+        });
+    }
+
+    RED.nodes.registerType("fronius-emulator", FroniusEmulatorNode);
+};

package/fronius-emulator/lib/binary-codec.js

@@ -0,0 +1,65 @@
+"use strict";
+
+/** Encode an ASCII SunSpec string as two characters per 16-bit register. */
+function stringToRegisters(value, registerCount) {
+    const count = Number(registerCount);
+    if (!Number.isInteger(count) || count < 0 || count > 32768) {
+        throw new RangeError("registerCount must be an integer between 0 and 32768");
+    }
+    const source = String(value == null ? "" : value);
+    let ascii = "";
+    for (const character of source) {
+        const code = character.codePointAt(0);
+        ascii += code >= 0x20 && code <= 0x7e ? character : "?";
+    }
+    const bytes = Buffer.alloc(count * 2);
+    Buffer.from(ascii, "ascii").copy(bytes, 0, 0, bytes.length);
+    const words = [];
+    for (let offset = 0; offset < bytes.length; offset += 2) {
+        words.push(bytes.readUInt16BE(offset));
+    }
+    return words;
+}
+
+/** Decode an array of SunSpec string registers, stripping trailing NUL bytes. */
+function registersToString(registers) {
+    if (!Array.isArray(registers)) throw new TypeError("registers must be an array");
+    const buffer = Buffer.alloc(registers.length * 2);
+    registers.forEach(function (word, index) {
+        if (!Number.isInteger(word) || word < 0 || word > 0xffff) {
+            throw new RangeError("register value is outside uint16");
+        }
+        buffer.writeUInt16BE(word, index * 2);
+    });
+    return buffer.toString("ascii").replace(/\0+$/, "");
+}
+
+/** Encode a finite number as IEEE-754 float32, big-endian, high word first (ABCD). */
+function float32ToRegisters(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new TypeError("float32 value must be finite");
+    }
+    const buffer = Buffer.allocUnsafe(4);
+    buffer.writeFloatBE(value, 0);
+    return [buffer.readUInt16BE(0), buffer.readUInt16BE(2)];
+}
+
+/** Decode two high-word-first registers as an IEEE-754 float32. */
+function registersToFloat32(highWord, lowWord) {
+    if (![highWord, lowWord].every(function (word) {
+        return Number.isInteger(word) && word >= 0 && word <= 0xffff;
+    })) {
+        throw new RangeError("float32 registers must be uint16 values");
+    }
+    const buffer = Buffer.allocUnsafe(4);
+    buffer.writeUInt16BE(highWord, 0);
+    buffer.writeUInt16BE(lowWord, 2);
+    return buffer.readFloatBE(0);
+}
+
+module.exports = {
+    stringToRegisters,
+    registersToString,
+    float32ToRegisters,
+    registersToFloat32
+};