@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/phoenix-contact/phoenix-contact.js

@@ -0,0 +1,679 @@
+module.exports = function (RED) {
+    "use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+    const net = require("net");
+    const phoenixProfile = require("./lib/phoenix-contact-profile");
+    const { compactKey } = require("./lib/integrations");
+    const influxMeasurementRegistry = new Map();
+
+    const TRANSACTION_ID = 1;
+    const PROTOCOL_ID = 0;
+    const MESSAGE_LENGTH = 6;
+    const FUNCTION_CODE = 3;
+    const SOCKET_TIMEOUT_MS = 5000;
+    const READ_BLOCK_RETRIES = 3;
+    const READ_BLOCK_RETRY_DELAY_MS = 250;
+
+    const MULTI_GRID_DEFAULT_FIELDS = [
+        "summary.power.total_w",
+        "summary.power.l1_w",
+        "summary.power.l2_w",
+        "summary.power.l3_w"
+    ];
+    const BESS_CONTROL_DEFAULT_FIELDS = MULTI_GRID_DEFAULT_FIELDS.slice();
+    const CONTROL_EXPORT_REACTIVE_DEFAULT_FIELDS = [
+        "summary.power.total_w",
+        "summary.power.l1_w",
+        "summary.power.l2_w",
+        "summary.power.l3_w",
+        "summary.reactive.total_var",
+        "summary.reactive.l1_var",
+        "summary.reactive.l2_var",
+        "summary.reactive.l3_var"
+    ];
+    const SCADA_DEFAULT_FIELDS = [
+        "summary.power.total_w",
+        "summary.reactive.total_var",
+        "summary.frequency_hz",
+        "summary.voltage.l1_l2_v",
+        "summary.voltage.l2_l3_v",
+        "summary.voltage.l3_l1_v"
+    ];
+
+    function toPositiveNumber(value, fallback) {
+        const n = Number(value);
+        return Number.isFinite(n) && n > 0 ? n : fallback;
+    }
+
+    function toPollInterval(value, fallback) {
+        const text = String(value || "").trim().toLowerCase();
+        if (text === "off" || text === "0") return 0;
+        const n = Number(value);
+        return Number.isFinite(n) && n > 0 ? n : fallback;
+    }
+
+    function wait(ms) {
+        return new Promise(function (resolve) {
+            setTimeout(resolve, ms);
+        });
+    }
+
+    function isRetryableReadError(err) {
+        const msg = String(err && err.message ? err.message : err || "").toLowerCase();
+        return msg.includes("timeout") ||
+            msg.includes("conexiune pierduta") ||
+            msg.includes("econnreset") ||
+            msg.includes("econnrefused") ||
+            msg.includes("etimedout") ||
+            msg.includes("fara raspuns");
+    }
+
+    function getByPath(obj, path) {
+        if (!path || path === "full") {
+            return obj;
+        }
+        return path.split(".").reduce(function (acc, key) {
+            return acc !== null && acc !== undefined ? acc[key] : undefined;
+        }, obj);
+    }
+
+    function setByPath(obj, path, value) {
+        const parts = String(path || "").split(".");
+        let target = obj;
+
+        parts.forEach(function (part, index) {
+            if (index === parts.length - 1) {
+                target[part] = value;
+                return;
+            }
+            if (!target[part] || typeof target[part] !== "object") {
+                target[part] = {};
+            }
+            target = target[part];
+        });
+    }
+
+    function normalizePayloadFields(fields, allowEmpty) {
+        if (Array.isArray(fields) && fields.length) {
+            const normalized = Array.from(new Set(fields.map(function (field) {
+                return String(field || "").trim();
+            }).filter(Boolean)));
+
+            if (normalized.includes("full")) {
+                return ["full"];
+            }
+            return normalized.length ? normalized : (allowEmpty ? [] : ["full"]);
+        }
+
+        if (typeof fields === "string" && fields.trim()) {
+            const trimmed = fields.trim();
+            if (trimmed[0] === "[") {
+                try {
+                    return normalizePayloadFields(JSON.parse(trimmed), allowEmpty);
+                } catch (err) {
+                    return [trimmed];
+                }
+            }
+            return [trimmed];
+        }
+
+        return allowEmpty ? [] : ["full"];
+    }
+
+    function sanitizePayloadFieldsForMode(fields, multiGrid, bessControl, controlExportReactive, scadaServer, influxDb, expertMode) {
+        const hasSpecialMode = !!(multiGrid || bessControl || controlExportReactive || scadaServer || influxDb);
+        const normalized = normalizePayloadFields(fields, !!(hasSpecialMode && expertMode));
+
+        if (multiGrid && normalized.includes("full")) {
+            return MULTI_GRID_DEFAULT_FIELDS.slice();
+        }
+        if (bessControl && normalized.includes("full")) {
+            return BESS_CONTROL_DEFAULT_FIELDS.slice();
+        }
+        if (controlExportReactive && normalized.includes("full")) {
+            return CONTROL_EXPORT_REACTIVE_DEFAULT_FIELDS.slice();
+        }
+        if (scadaServer && normalized.includes("full")) {
+            return SCADA_DEFAULT_FIELDS.slice();
+        }
+        if (influxDb && normalized.includes("full")) {
+            return ["full"];
+        }
+
+        return normalized;
+    }
+
+    function getPayloadDefinition(path) {
+        return phoenixProfile.PAYLOAD_FIELDS.find(function (field) {
+            return field.path === path;
+        }) || phoenixProfile.getField(path);
+    }
+
+    function getPayloadLabel(path) {
+        const definition = getPayloadDefinition(path);
+        return definition && definition.label ? definition.label : path;
+    }
+
+    function getPayloadUnit(path) {
+        const definition = getPayloadDefinition(path);
+        return definition && definition.unit ? definition.unit : "";
+    }
+
+    function getCompactPayloadKey(path) {
+        return compactKey(path);
+    }
+
+    function getScadaPayloadKey(path) {
+        const mapping = {
+            "summary.power.total_w": "active_power_w",
+            "summary.reactive.total_var": "reactive_power_var",
+            "summary.frequency_hz": "frequency_hz",
+            "summary.voltage.l1_l2_v": "voltage_l1_l2_v",
+            "summary.voltage.l2_l3_v": "voltage_l2_l3_v",
+            "summary.voltage.l3_l1_v": "voltage_l1_l3_v",
+            "summary.power.l1_w": "power_l1_w",
+            "summary.power.l2_w": "power_l2_w",
+            "summary.power.l3_w": "power_l3_w",
+            "summary.current.l1_a": "current_l1_a",
+            "summary.current.l2_a": "current_l2_a",
+            "summary.current.l3_a": "current_l3_a",
+            "summary.voltage.l1_n_v": "voltage_l1_n_v",
+            "summary.voltage.l2_n_v": "voltage_l2_n_v",
+            "summary.voltage.l3_n_v": "voltage_l3_n_v"
+        };
+        return mapping[path] || getCompactPayloadKey(path);
+    }
+
+    function flattenNumericFields(source, prefix, target) {
+        Object.keys(source || {}).forEach(function (key) {
+            const value = source[key];
+            const nextKey = prefix ? prefix + "_" + key : key;
+
+            if (typeof value === "number" && Number.isFinite(value)) {
+                target[nextKey] = value;
+                return;
+            }
+            if (typeof value === "boolean" || typeof value === "string") {
+                target[nextKey] = value;
+                return;
+            }
+            if (value && typeof value === "object" && !Array.isArray(value)) {
+                flattenNumericFields(value, nextKey, target);
+            }
+        });
+    }
+
+    function registerInfluxMeasurement(nodeId, identityKey) {
+        const key = String(identityKey || "").trim().toLowerCase();
+        if (!key) {
+            return;
+        }
+        if (!influxMeasurementRegistry.has(key)) {
+            influxMeasurementRegistry.set(key, new Set());
+        }
+        influxMeasurementRegistry.get(key).add(nodeId);
+    }
+
+    function unregisterInfluxMeasurement(nodeId, identityKey) {
+        const key = String(identityKey || "").trim().toLowerCase();
+        if (!key || !influxMeasurementRegistry.has(key)) {
+            return;
+        }
+        const ids = influxMeasurementRegistry.get(key);
+        ids.delete(nodeId);
+        if (!ids.size) {
+            influxMeasurementRegistry.delete(key);
+        }
+    }
+
+    function hasDuplicateInfluxMeasurement(nodeId, identityKey) {
+        const key = String(identityKey || "").trim().toLowerCase();
+        if (!key || !influxMeasurementRegistry.has(key)) {
+            return false;
+        }
+        const ids = influxMeasurementRegistry.get(key);
+        return ids.size > 1 || (ids.size === 1 && !ids.has(nodeId));
+    }
+
+    function setInfluxField(target, key, value) {
+        if (!key) {
+            return;
+        }
+        if (typeof value === "number" && Number.isFinite(value)) {
+            target[key] = value;
+            return;
+        }
+        if (typeof value === "boolean" || typeof value === "string") {
+            target[key] = value;
+        }
+    }
+
+    function buildInfluxFields(parsed, selectedFields) {
+        const fields = {};
+
+        if (selectedFields.includes("full")) {
+            flattenNumericFields(parsed && parsed.summary ? parsed.summary : {}, "", fields);
+            return fields;
+        }
+
+        selectedFields.forEach(function (field) {
+            const value = getByPath(parsed, field);
+            if (value && typeof value === "object" && !Array.isArray(value)) {
+                flattenNumericFields(value, getCompactPayloadKey(field), fields);
+                return;
+            }
+            setInfluxField(fields, getCompactPayloadKey(field), value);
+        });
+
+        return fields;
+    }
+
+    function formatSingleStatus(path, value) {
+        const unit = getPayloadUnit(path);
+        if (value === undefined || value === null) {
+            return getPayloadLabel(path) + ": n/a";
+        }
+        return getPayloadLabel(path) + ": " + String(value) + (unit ? " " + unit : "");
+    }
+
+    function dumpBuffer(buffer) {
+        return buffer.toString("hex").toUpperCase();
+    }
+
+    function buildRequestBuffer(unitId, startAddress, registerCount) {
+        const buffer = Buffer.alloc(12);
+        buffer.writeUInt16BE(TRANSACTION_ID, 0);
+        buffer.writeUInt16BE(PROTOCOL_ID, 2);
+        buffer.writeUInt16BE(MESSAGE_LENGTH, 4);
+        buffer.writeUInt8(unitId, 6);
+        buffer.writeUInt8(FUNCTION_CODE, 7);
+        buffer.writeUInt16BE(startAddress, 8);
+        buffer.writeUInt16BE(registerCount, 10);
+        return buffer;
+    }
+
+    function PhoenixContactNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+
+        node.name = String(config.name || "").trim();
+        node.model = String(config.model || phoenixProfile.DEFAULT_PROFILE_ID).trim();
+        node.host = String(config.host || "").trim();
+        node.port = toPositiveNumber(config.port, 502);
+        node.unitId = toPositiveNumber(config.unitId, 1);
+        node.timestep = toPollInterval(config.timestep, 1000);
+        node.expertMode = !!config.expertMode;
+        node.multiGrid = !!config.multiGrid;
+        node.bessControl = !!config.bessControl;
+        node.controlExportReactive = !!config.controlExportReactive;
+        node.scadaServer = !!config.scadaServer;
+        node.influxDb = !!config.influxDb;
+        if (node.multiGrid) {
+            node.bessControl = false; node.controlExportReactive = false; node.scadaServer = false;
+        } else if (node.bessControl) {
+            node.controlExportReactive = false; node.scadaServer = false;
+        } else if (node.controlExportReactive) {
+            node.scadaServer = false;
+        }
+        node.logReadRetries = !!config.logReadRetries;
+        node.influxMeasurement = String(config.influxMeasurement || "").trim();
+        node.influxNode = String(config.influxNode || "").trim();
+        node.meterId = String(config.meterId || "").trim();
+        if (!node.meterId) {
+            node.meterId = "phoenix" + String(node.unitId);
+        }
+        node.payloadFields = sanitizePayloadFieldsForMode(config.payloadFields, node.multiGrid, node.bessControl, node.controlExportReactive, node.scadaServer, node.influxDb, node.expertMode);
+
+        let intervalHandle = null;
+        let startupHandle = null;
+        let running = false;
+        let closed = false;
+        let registeredInfluxIdentityKey = "";
+
+        function getEffectiveMeterId() {
+            return node.meterId || ("phoenix" + String(node.unitId));
+        }
+
+        function getInfluxMeasurement() {
+            return node.influxMeasurement || getEffectiveMeterId();
+        }
+
+        function getInfluxIdentityKey() {
+            return String(getInfluxMeasurement() || "").trim().toLowerCase() + "::" + String(getEffectiveMeterId() || "").trim().toLowerCase();
+        }
+
+        function hasInfluxMeasurementConflict() {
+            return node.influxDb && hasDuplicateInfluxMeasurement(node.id, getInfluxIdentityKey());
+        }
+
+        function readRegisterBlock(startAddress, registerCount) {
+            return new Promise(function (resolve, reject) {
+                const socket = new net.Socket();
+                let chunks = [];
+                let finished = false;
+
+                function done(err, result) {
+                    if (finished) {
+                        return;
+                    }
+                    finished = true;
+                    try {
+                        socket.destroy();
+                    } catch (cleanupErr) {
+                        // ignore cleanup errors
+                    }
+                    if (err) {
+                        reject(err);
+                    } else {
+                        resolve(result);
+                    }
+                }
+
+                socket.setTimeout(SOCKET_TIMEOUT_MS);
+                socket.connect(node.port, node.host, function () {
+                    try {
+                        socket.write(buildRequestBuffer(node.unitId, startAddress, registerCount));
+                    } catch (err) {
+                        done(err);
+                    }
+                });
+
+                socket.on("data", function (data) {
+                    chunks.push(data);
+                    const total = Buffer.concat(chunks);
+
+                    if (total.length >= 9) {
+                        const functionCode = total.readUInt8(7);
+                        if (functionCode === (FUNCTION_CODE | 0x80)) {
+                            const exceptionCode = total.length > 8 ? total.readUInt8(8) : -1;
+                            done(new Error("Modbus exception code: " + exceptionCode));
+                            return;
+                        }
+                        if (functionCode !== FUNCTION_CODE) {
+                            done(new Error("Function code invalid: " + functionCode));
+                            return;
+                        }
+
+                        const byteCount = total.readUInt8(8);
+                        const expectedLength = 9 + byteCount;
+                        if (total.length >= expectedLength) {
+                            if (byteCount !== registerCount * 2) {
+                                done(new Error("Byte count invalid: " + byteCount));
+                                return;
+                            }
+                            done(null, {
+                                buffer: total.slice(0, expectedLength),
+                                data: total.slice(9, expectedLength)
+                            });
+                        }
+                    }
+                });
+
+                socket.on("timeout", function () {
+                    done(new Error("conexiune pierduta: timeout"));
+                });
+                socket.on("error", function (err) {
+                    done(new Error("conexiune pierduta: " + err.message));
+                });
+                socket.on("close", function () {
+                    if (!finished && chunks.length === 0) {
+                        done(new Error("conexiune pierduta: fara raspuns"));
+                    }
+                });
+            });
+        }
+
+        async function readRegisterBlockWithRetry(startAddress, registerCount) {
+            let lastError = null;
+            for (let attempt = 1; attempt <= READ_BLOCK_RETRIES; attempt += 1) {
+                try {
+                    return await readRegisterBlock(startAddress, registerCount);
+                } catch (err) {
+                    lastError = err;
+                    if (attempt >= READ_BLOCK_RETRIES || !isRetryableReadError(err)) {
+                        throw err;
+                    }
+                    if (node.logReadRetries) {
+                        node.warn(
+                            "Phoenix Contact read retry " +
+                                attempt +
+                                "/" +
+                                READ_BLOCK_RETRIES +
+                                " pentru registrele " +
+                                startAddress +
+                                "-" +
+                                (startAddress + registerCount - 1) +
+                                ": " +
+                                (err.message || String(err))
+                        );
+                    }
+                    await wait(READ_BLOCK_RETRY_DELAY_MS);
+                }
+            }
+            throw lastError || new Error("citire Phoenix Contact esuata");
+        }
+
+        async function readMeter() {
+            const selectedFields = normalizePayloadFields(
+                node.payloadFields,
+                !!(node.expertMode && (node.multiGrid || node.bessControl || node.controlExportReactive || node.scadaServer || node.influxDb))
+            );
+            const ranges = phoenixProfile.buildReadRanges(selectedFields, false);
+            const parsed = {
+                summary: {},
+                registers: {},
+                meta: {
+                    model: phoenixProfile.DEFAULT_PROFILE_ID,
+                    device: "Phoenix Contact EEM-MA370",
+                    unit_id: node.unitId,
+                    timestamp: new Date().toISOString(),
+                    ranges: ranges.map(function (range) {
+                        return { start: range.start, count: range.count };
+                    }),
+                    raw_hex: []
+                }
+            };
+
+            for (let i = 0; i < ranges.length; i += 1) {
+                const range = ranges[i];
+                const block = await readRegisterBlockWithRetry(range.start, range.count);
+                parsed.meta.raw_hex.push(dumpBuffer(block.buffer));
+
+                range.items.forEach(function (item) {
+                    const value = phoenixProfile.readValueFromRegisterData(block.data, range.start, item.definition);
+                    setByPath(parsed, item.field, value);
+                });
+            }
+
+            return parsed;
+        }
+
+        function buildSingleMessage(parsed, field, value) {
+            const outMsg = {
+                payload_field: field,
+                phoenixContact: parsed,
+                source_id: node.meterId,
+                timestamp: parsed && parsed.meta ? parsed.meta.timestamp : new Date().toISOString()
+            };
+            outMsg.ip = node.host;
+            outMsg.host = node.host;
+            outMsg.port = node.port;
+            outMsg.unit_id = node.unitId;
+            outMsg.device_type = "phoenix_contact";
+            outMsg.model = parsed && parsed.meta ? parsed.meta.model : "";
+
+            if (node.multiGrid || node.bessControl || node.controlExportReactive) {
+                outMsg.topic = getEffectiveMeterId();
+                outMsg.meter_id = getEffectiveMeterId();
+                outMsg.payload = field === "full" ? parsed : value;
+            } else if (node.scadaServer) {
+                outMsg.topic = getEffectiveMeterId();
+                outMsg.meter_id = getEffectiveMeterId();
+                outMsg.payload = field === "full" ? parsed : value;
+            } else {
+                outMsg.topic = getPayloadLabel(field);
+                outMsg.payload = value;
+            }
+
+            return outMsg;
+        }
+
+        function buildInfluxMessage(parsed, selectedFields) {
+            const timestamp = parsed && parsed.meta ? parsed.meta.timestamp : new Date().toISOString();
+            const fields = buildInfluxFields(parsed, selectedFields);
+            const meterId = getEffectiveMeterId();
+            const measurement = getInfluxMeasurement();
+
+            return {
+                topic: meterId,
+                meter_id: meterId,
+                source_id: node.meterId,
+                payload_field: selectedFields.includes("full") ? "full" : (selectedFields[0] || "full"),
+                phoenixContact: parsed,
+                timestamp: timestamp,
+                payload: fields,
+                influx: {
+                    measurement: measurement,
+                    tags: {
+                        device_type: "phoenix_contact",
+                        meter_id: meterId,
+                        host: node.host,
+                        unit_id: String(node.unitId)
+                    },
+                    fields: fields,
+                    timestamp: timestamp
+                }
+            };
+        }
+
+        function setStatusForSelection(selectedFields, parsed) {
+            if (selectedFields.includes("full")) {
+                node.status({ fill: "green", shape: "dot", text: "Valori principale" });
+                return;
+            }
+
+            if (selectedFields.length === 1) {
+                const field = selectedFields[0];
+                node.status({ fill: "green", shape: "dot", text: formatSingleStatus(field, getByPath(parsed, field)) });
+                return;
+            }
+
+            node.status({ fill: "green", shape: "dot", text: String(selectedFields.length) + " valori selectate" });
+        }
+
+        function setDisconnectedStatus(message) {
+            node.status({ fill: "red", shape: "ring", text: message });
+        }
+
+        function sendParsedResult(parsed) {
+            const selectedFields = normalizePayloadFields(
+                node.payloadFields,
+                !!(node.expertMode && (node.multiGrid || node.bessControl || node.controlExportReactive || node.scadaServer || node.influxDb))
+            );
+
+            setStatusForSelection(selectedFields, parsed);
+
+            const secondaryInflux = node.influxDb && !!(node.multiGrid || node.bessControl || node.controlExportReactive || node.scadaServer);
+            let influxMessage = null;
+            if (node.influxDb) {
+                if (hasInfluxMeasurementConflict()) {
+                    node.status({ fill: "red", shape: "ring", text: "meter_id+measurement duplicat" });
+                    node.error("Phoenix Contact InfluxDB: combinatie duplicata Meter ID + Measurement ('" + getEffectiveMeterId() + "' @ '" + getInfluxMeasurement() + "'). Configureaza un Meter ID unic pentru acelasi measurement.");
+                    return;
+                }
+                influxMessage = buildInfluxMessage(parsed, selectedFields);
+                if (!secondaryInflux) {
+                    node.send(influxMessage);
+                    return;
+                }
+            }
+
+            if (selectedFields.includes("full")) {
+                node.send(buildSingleMessage(parsed, "full", parsed));
+                return;
+            }
+
+            if (node.multiGrid || node.bessControl || node.controlExportReactive || node.scadaServer) {
+                const aggregatedPayload = {};
+                selectedFields.forEach(function (field) {
+                    const key = node.scadaServer ? getScadaPayloadKey(field) : getCompactPayloadKey(field);
+                    aggregatedPayload[key] = getByPath(parsed, field);
+                });
+                const integratedMessage = buildSingleMessage(parsed, "selected", aggregatedPayload);
+                if (influxMessage) {
+                    const target = RED.nodes.getNode(node.influxNode);
+                    if (target && typeof target.receive === "function") target.receive(RED.util.cloneMessage(influxMessage));
+                    else node.warn("Phoenix Contact: selecteaza un nod adt-influxdb pentru integrarea secundara.");
+                }
+                node.send(integratedMessage);
+                return;
+            }
+
+            node.send(selectedFields.map(function (field) {
+                return buildSingleMessage(parsed, field, getByPath(parsed, field));
+            }));
+        }
+
+        async function executeRead() {
+            if (closed || running) {
+                return;
+            }
+            running = true;
+
+            try {
+                node.status({ fill: "yellow", shape: "dot", text: "citire..." });
+                sendParsedResult(await readMeter());
+            } catch (err) {
+                setDisconnectedStatus(err.message);
+                node.error("Eroare Phoenix Contact (" + node.host + ":" + node.port + ", unitId=" + node.unitId + "): " + err.message);
+            } finally {
+                running = false;
+            }
+        }
+
+        if (!node.host) {
+            setDisconnectedStatus("IP lipsa");
+            node.error("Configuratie invalida: IP lipsa");
+        } else {
+            if (node.influxDb) {
+                registeredInfluxIdentityKey = getInfluxIdentityKey();
+                registerInfluxMeasurement(node.id, registeredInfluxIdentityKey);
+                if (hasInfluxMeasurementConflict()) {
+                    node.status({ fill: "red", shape: "ring", text: "meter_id+measurement duplicat" });
+                    node.error("Phoenix Contact InfluxDB: combinatie duplicata Meter ID + Measurement ('" + getEffectiveMeterId() + "' @ '" + getInfluxMeasurement() + "'). Configureaza un Meter ID unic pentru acelasi measurement.");
+                }
+            }
+            if (node.timestep > 0) {
+                startupHandle = setTimeout(executeRead, 0);
+                intervalHandle = setInterval(executeRead, node.timestep);
+            }
+        }
+
+        node.on("input", function () {
+            executeRead();
+        });
+
+        node.on("close", function (done) {
+            closed = true;
+            if (registeredInfluxIdentityKey) {
+                unregisterInfluxMeasurement(node.id, registeredInfluxIdentityKey);
+                registeredInfluxIdentityKey = "";
+            }
+            if (startupHandle) {
+                clearTimeout(startupHandle);
+            }
+            if (intervalHandle) {
+                clearInterval(intervalHandle);
+            }
+            done();
+        });
+    
+        });
+    }
+
+    RED.nodes.registerType("phoenix-contact", PhoenixContactNode);
+};