@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/carlo-gavazzi/carlo-gavazzi.js

@@ -0,0 +1,3081 @@
+module.exports = function (RED) {
+
+
+    "use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+
+
+    const net = require("net");
+
+
+    const influxMeasurementRegistry = new Map();
+
+
+
+    const TRANSACTION_ID = 1;
+
+
+    const PROTOCOL_ID = 0;
+
+
+    const MESSAGE_LENGTH = 6;
+
+
+    const FUNCTION_CODE = 3;
+
+
+    const START_ADDRESS = 0;
+
+
+    const REGISTER_COUNT = 124;
+
+
+    const EXPECTED_BYTE_COUNT = 248;
+
+
+    const SOCKET_TIMEOUT_MS = 5000;
+
+
+    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 = [
+
+
+        "summary.power.total_w",
+
+
+        "summary.power.l1_w",
+
+
+        "summary.power.l2_w",
+
+
+        "summary.power.l3_w"
+
+
+    ];
+
+
+    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 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 normalizePayloadFields(fields, allowEmpty) {
+
+
+        const keepEmpty = !!allowEmpty;
+
+
+
+        if (Array.isArray(fields) && fields.length) {
+
+
+            const normalized = Array.from(
+
+
+                new Set(
+
+
+                    fields
+
+
+                        .map(function (f) { return String(f || "").trim(); })
+
+
+                        .filter(Boolean)
+
+
+                )
+
+
+            );
+
+
+
+            if (!normalized.length) {
+
+
+                return keepEmpty ? [] : ["full"];
+
+
+            }
+
+
+
+            if (normalized.includes("full")) {
+
+
+                return ["full"];
+
+
+            }
+
+
+
+            return normalized;
+
+
+        }
+
+
+
+        if (typeof fields === "string" && fields.trim()) {
+
+
+            const trimmed = fields.trim();
+
+
+
+            if (trimmed[0] === "[") {
+
+
+                try {
+
+
+                    const parsed = JSON.parse(trimmed);
+
+
+                    if (Array.isArray(parsed)) {
+
+
+                        return normalizePayloadFields(parsed, keepEmpty);
+
+
+                    }
+
+
+                } catch (e) {
+
+
+                    // ignore
+
+
+                }
+
+
+            }
+
+
+
+            return [trimmed];
+
+
+        }
+
+
+
+        return keepEmpty ? [] : ["full"];
+
+
+    }
+
+
+
+    function sanitizePayloadFieldsForMode(fields, multiGrid, bessControl, controlExportReactive, scadaServer, influxDb, expertMode) {
+
+
+        const hasSpecialMode = !!(multiGrid || bessControl || controlExportReactive || scadaServer || influxDb);
+
+
+        const allowEmpty = !!(hasSpecialMode && expertMode);
+
+
+        const normalized = normalizePayloadFields(fields, allowEmpty);
+
+
+
+        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 getPayloadLabel(path) {
+
+
+        const labels = {
+
+
+            "full": "Toate valorile",
+
+
+
+            "summary.voltage.l1_n_v": "Tensiune L1-N",
+
+
+            "summary.voltage.l2_n_v": "Tensiune L2-N",
+
+
+            "summary.voltage.l3_n_v": "Tensiune L3-N",
+
+
+            "summary.voltage.l1_l2_v": "Tensiune L1-L2",
+
+
+            "summary.voltage.l2_l3_v": "Tensiune L2-L3",
+
+
+            "summary.voltage.l3_l1_v": "Tensiune L3-L1",
+
+
+
+            "summary.current.l1_a": "Curent L1",
+
+
+            "summary.current.l2_a": "Curent L2",
+
+
+            "summary.current.l3_a": "Curent L3",
+
+
+
+            "summary.power.l1_w": "Putere L1",
+
+
+            "summary.power.l2_w": "Putere L2",
+
+
+            "summary.power.l3_w": "Putere L3",
+
+
+            "summary.power.total_w": "Putere totala",
+
+
+
+            "summary.apparent.l1_va": "Putere aparenta L1",
+
+
+            "summary.apparent.l2_va": "Putere aparenta L2",
+
+
+            "summary.apparent.l3_va": "Putere aparenta L3",
+
+
+            "summary.apparent.total_va": "Putere aparenta totala",
+
+
+
+            "summary.reactive.l1_var": "Putere reactiva L1",
+
+
+            "summary.reactive.l2_var": "Putere reactiva L2",
+
+
+            "summary.reactive.l3_var": "Putere reactiva L3",
+
+
+            "summary.reactive.total_var": "Putere reactiva totala",
+
+
+
+            "summary.power_factor.l1": "Factor putere L1",
+
+
+            "summary.power_factor.l2": "Factor putere L2",
+
+
+            "summary.power_factor.l3": "Factor putere L3",
+
+
+
+            "summary.frequency_hz": "Frecventa",
+
+
+            "summary.phase_sequence": "Ordine faze",
+
+
+
+            "summary.energy.import_kwh": "Energie importata",
+
+
+            "summary.energy.reactive_import_kvarh": "Energie reactiva importata",
+
+
+            "summary.energy.l1_kwh": "Energie L1",
+
+
+            "summary.energy.l2_kwh": "Energie L2",
+
+
+            "summary.energy.l3_kwh": "Energie L3",
+
+
+
+            "summary.energy.tariff.t1_kwh": "Energie T1",
+
+
+            "summary.energy.tariff.t2_kwh": "Energie T2",
+
+
+            "summary.energy.tariff.t3_kwh": "Energie T3",
+
+
+            "summary.energy.tariff.t4_kwh": "Energie T4",
+
+
+
+            "summary.energy.export_kwh": "Energie exportata",
+
+
+            "summary.energy.export_reactive_kvarh": "Energie reactiva exportata",
+
+
+
+            "summary.energy.reactive_tariff.t1_kvarh": "Energie reactiva T1",
+
+
+            "summary.energy.reactive_tariff.t2_kvarh": "Energie reactiva T2",
+
+
+            "summary.energy.reactive_tariff.t3_kvarh": "Energie reactiva T3",
+
+
+            "summary.energy.reactive_tariff.t4_kvarh": "Energie reactiva T4"
+
+
+        };
+
+
+
+        return labels[path] || path;
+
+
+    }
+
+
+
+    function getPayloadUnit(path) {
+
+
+        const units = {
+
+
+            "summary.voltage.l1_n_v": "V",
+
+
+            "summary.voltage.l2_n_v": "V",
+
+
+            "summary.voltage.l3_n_v": "V",
+
+
+            "summary.voltage.l1_l2_v": "V",
+
+
+            "summary.voltage.l2_l3_v": "V",
+
+
+            "summary.voltage.l3_l1_v": "V",
+
+
+
+            "summary.current.l1_a": "A",
+
+
+            "summary.current.l2_a": "A",
+
+
+            "summary.current.l3_a": "A",
+
+
+
+            "summary.power.l1_w": "W",
+
+
+            "summary.power.l2_w": "W",
+
+
+            "summary.power.l3_w": "W",
+
+
+            "summary.power.total_w": "W",
+
+
+
+            "summary.apparent.l1_va": "VA",
+
+
+            "summary.apparent.l2_va": "VA",
+
+
+            "summary.apparent.l3_va": "VA",
+
+
+            "summary.apparent.total_va": "VA",
+
+
+
+            "summary.reactive.l1_var": "var",
+
+
+            "summary.reactive.l2_var": "var",
+
+
+            "summary.reactive.l3_var": "var",
+
+
+            "summary.reactive.total_var": "var",
+
+
+
+            "summary.power_factor.l1": "",
+
+
+            "summary.power_factor.l2": "",
+
+
+            "summary.power_factor.l3": "",
+
+
+
+            "summary.frequency_hz": "Hz",
+
+
+            "summary.phase_sequence": "",
+
+
+
+            "summary.energy.import_kwh": "kWh",
+
+
+            "summary.energy.reactive_import_kvarh": "kvarh",
+
+
+            "summary.energy.l1_kwh": "kWh",
+
+
+            "summary.energy.l2_kwh": "kWh",
+
+
+            "summary.energy.l3_kwh": "kWh",
+
+
+            "summary.energy.tariff.t1_kwh": "kWh",
+
+
+            "summary.energy.tariff.t2_kwh": "kWh",
+
+
+            "summary.energy.tariff.t3_kwh": "kWh",
+
+
+            "summary.energy.tariff.t4_kwh": "kWh",
+
+
+            "summary.energy.export_kwh": "kWh",
+
+
+            "summary.energy.export_reactive_kvarh": "kvarh",
+
+
+            "summary.energy.reactive_tariff.t1_kvarh": "kvarh",
+
+
+            "summary.energy.reactive_tariff.t2_kvarh": "kvarh",
+
+
+            "summary.energy.reactive_tariff.t3_kvarh": "kvarh",
+
+
+            "summary.energy.reactive_tariff.t4_kvarh": "kvarh"
+
+
+        };
+
+
+
+        return units[path] || "";
+
+
+    }
+
+
+
+    function getCompactPayloadKey(path) {
+
+
+        const mapping = {
+
+
+            "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",
+
+
+            "summary.voltage.l1_l2_v": "voltage_l1_l2_v",
+
+
+            "summary.voltage.l2_l3_v": "voltage_l2_l3_v",
+
+
+            "summary.voltage.l3_l1_v": "voltage_l3_l1_v",
+
+
+
+            "summary.current.l1_a": "current_l1_a",
+
+
+            "summary.current.l2_a": "current_l2_a",
+
+
+            "summary.current.l3_a": "current_l3_a",
+
+
+
+            "summary.power.l1_w": "power_l1_w",
+
+
+            "summary.power.l2_w": "power_l2_w",
+
+
+            "summary.power.l3_w": "power_l3_w",
+
+
+            "summary.power.total_w": "power_w",
+
+
+
+            "summary.apparent.l1_va": "apparent_l1_va",
+
+
+            "summary.apparent.l2_va": "apparent_l2_va",
+
+
+            "summary.apparent.l3_va": "apparent_l3_va",
+
+
+            "summary.apparent.total_va": "apparent_total_va",
+
+
+
+            "summary.reactive.l1_var": "reactive_l1_var",
+
+
+            "summary.reactive.l2_var": "reactive_l2_var",
+
+
+            "summary.reactive.l3_var": "reactive_l3_var",
+
+
+            "summary.reactive.total_var": "reactive_total_var",
+
+
+
+            "summary.power_factor.l1": "power_factor_l1",
+
+
+            "summary.power_factor.l2": "power_factor_l2",
+
+
+            "summary.power_factor.l3": "power_factor_l3",
+
+
+
+            "summary.frequency_hz": "frequency_hz",
+
+
+            "summary.phase_sequence": "phase_sequence",
+
+
+
+            "summary.energy.import_kwh": "energy_import_kwh",
+
+
+            "summary.energy.reactive_import_kvarh": "energy_reactive_import_kvarh",
+
+
+            "summary.energy.l1_kwh": "energy_l1_kwh",
+
+
+            "summary.energy.l2_kwh": "energy_l2_kwh",
+
+
+            "summary.energy.l3_kwh": "energy_l3_kwh",
+
+
+            "summary.energy.tariff.t1_kwh": "energy_t1_kwh",
+
+
+            "summary.energy.tariff.t2_kwh": "energy_t2_kwh",
+
+
+            "summary.energy.tariff.t3_kwh": "energy_t3_kwh",
+
+
+            "summary.energy.tariff.t4_kwh": "energy_t4_kwh",
+
+
+            "summary.energy.export_kwh": "energy_export_kwh",
+
+
+            "summary.energy.export_reactive_kvarh": "energy_export_reactive_kvarh",
+
+
+            "summary.energy.reactive_tariff.t1_kvarh": "energy_reactive_t1_kvarh",
+
+
+            "summary.energy.reactive_tariff.t2_kvarh": "energy_reactive_t2_kvarh",
+
+
+            "summary.energy.reactive_tariff.t3_kvarh": "energy_reactive_t3_kvarh",
+
+
+            "summary.energy.reactive_tariff.t4_kvarh": "energy_reactive_t4_kvarh"
+
+
+        };
+
+
+
+        return mapping[path] || path.replace(/\./g, "_");
+
+
+    }
+
+
+
+    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") {
+
+
+                target[nextKey] = value;
+
+
+                return;
+
+
+            }
+
+
+
+            if (value && typeof value === "object" && !Array.isArray(value)) {
+
+
+                flattenNumericFields(value, nextKey, target);
+
+
+            }
+
+
+        });
+
+
+    }
+
+
+
+    function setInfluxField(target, key, value) {
+
+
+        if (!key) {
+
+
+            return;
+
+
+        }
+
+
+
+        if (typeof value === "number" && Number.isFinite(value)) {
+
+
+            target[key] = value;
+
+
+            return;
+
+
+        }
+
+
+
+        if (typeof value === "boolean") {
+
+
+            target[key] = value;
+
+
+        }
+
+
+    }
+
+
+
+    function formatSingleStatus(path, value) {
+
+
+        const label = getPayloadLabel(path);
+
+
+        const unit = getPayloadUnit(path);
+
+
+
+        if (value === undefined || value === null) {
+
+
+            return label + ": n/a";
+
+
+        }
+
+
+
+        if (unit) {
+
+
+            return label + ": " + String(value) + " " + unit;
+
+
+        }
+
+
+
+        return label + ": " + String(value);
+
+
+    }
+
+
+
+    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 dumpBuffer(buffer) {
+
+
+        return buffer.toString("hex").toUpperCase();
+
+
+    }
+
+
+
+    function readSwappedInt32BE(buffer, offset) {
+
+
+        const lowWord = buffer.readUInt16BE(offset);
+
+
+        const highWord = buffer.readUInt16BE(offset + 2);
+
+
+        let value = (highWord * 0x10000) + lowWord;
+
+
+
+        if (value >= 0x80000000) {
+
+
+            value = value - 0x100000000;
+
+
+        }
+
+
+
+        return value;
+
+
+    }
+
+
+
+    function parsePhaseSequence(raw) {
+
+
+        if (raw === -1) {
+
+
+            return "L1-L3-L2";
+
+
+        }
+
+
+        if (raw === 0) {
+
+
+            return "L1-L2-L3";
+
+
+        }
+
+
+        return String(raw);
+
+
+    }
+
+
+
+    function parseMeterResponse(buffer, expectedUnitId) {
+
+
+        if (!Buffer.isBuffer(buffer)) {
+
+
+            throw new Error("Raspuns invalid");
+
+
+        }
+
+
+
+        if (buffer.length < 9) {
+
+
+            throw new Error("Raspuns Modbus prea scurt");
+
+
+        }
+
+
+
+        const transactionId = buffer.readUInt16BE(0);
+
+
+        if (transactionId !== TRANSACTION_ID) {
+
+
+            throw new Error("Transaction ID invalid: " + transactionId);
+
+
+        }
+
+
+
+        const protocolId = buffer.readUInt16BE(2);
+
+
+        if (protocolId !== PROTOCOL_ID) {
+
+
+            throw new Error("Protocol ID invalid: " + protocolId);
+
+
+        }
+
+
+
+        const messageLength = buffer.readUInt16BE(4);
+
+
+        if (!Number.isFinite(messageLength) || messageLength <= 0) {
+
+
+            throw new Error("Message length invalid");
+
+
+        }
+
+
+
+        const expectedTotalLengthFromHeader = 6 + messageLength;
+
+
+        if (buffer.length < expectedTotalLengthFromHeader) {
+
+
+            throw new Error("Pachet Modbus incomplet");
+
+
+        }
+
+
+
+        const unitId = buffer.readUInt8(6);
+
+
+        if (unitId !== expectedUnitId) {
+
+
+            throw new Error("Unit ID invalid: " + unitId);
+
+
+        }
+
+
+
+        const functionCode = buffer.readUInt8(7);
+
+
+
+        if (functionCode === (FUNCTION_CODE | 0x80)) {
+
+
+            const exceptionCode = buffer.length > 8 ? buffer.readUInt8(8) : -1;
+
+
+            throw new Error("Modbus exception code: " + exceptionCode);
+
+
+        }
+
+
+
+        if (functionCode !== FUNCTION_CODE) {
+
+
+            throw new Error("Function code invalid: " + functionCode);
+
+
+        }
+
+
+
+        const byteCount = buffer.readUInt8(8);
+
+
+        if (byteCount !== EXPECTED_BYTE_COUNT) {
+
+
+            throw new Error("Byte count invalid: " + byteCount);
+
+
+        }
+
+
+
+        const expectedPayloadEnd = 9 + byteCount;
+
+
+        if (buffer.length < expectedPayloadEnd) {
+
+
+            throw new Error("Date Modbus incomplete");
+
+
+        }
+
+
+
+        const data = buffer.slice(9, expectedPayloadEnd);
+
+
+
+        function read32(offset, scale) {
+
+
+            return readSwappedInt32BE(data, offset) / scale;
+
+
+        }
+
+
+
+        function read16(offset, scale) {
+
+
+            return data.readInt16BE(offset) / scale;
+
+
+        }
+
+
+
+        const l1_n_voltage = read32(0, 10);      // 0000h
+
+
+        const l2_n_voltage = read32(4, 10);      // 0002h
+
+
+        const l3_n_voltage = read32(8, 10);      // 0004h
+
+
+
+        const l1_l2_voltage = read32(12, 10);    // 0006h
+
+
+        const l2_l3_voltage = read32(16, 10);    // 0008h
+
+
+        const l3_l1_voltage = read32(20, 10);    // 000Ah
+
+
+
+        const l1_current = read32(24, 1000);     // 000Ch
+
+
+        const l2_current = read32(28, 1000);     // 000Eh
+
+
+        const l3_current = read32(32, 1000);     // 0010h
+
+
+
+        const l1_power = read32(36, 10);         // 0012h
+
+
+        const l2_power = read32(40, 10);         // 0014h
+
+
+        const l3_power = read32(44, 10);         // 0016h
+
+
+
+        const l1_va = read32(48, 10);            // 0018h
+
+
+        const l2_va = read32(52, 10);            // 001Ah
+
+
+        const l3_va = read32(56, 10);            // 001Ch
+
+
+
+        const l1_var = read32(60, 10);           // 001Eh
+
+
+        const l2_var = read32(64, 10);           // 0020h
+
+
+        const l3_var = read32(68, 10);           // 0022h
+
+
+
+        const total_power = read32(80, 10);      // 0028h W Σ
+
+
+        const total_va = read32(84, 10);         // 002Ah VA Σ
+
+
+        const total_var = read32(88, 10);        // 002Ch VAR Σ
+
+
+
+        const pf_l1 = read16(92, 1000);          // 002Eh
+
+
+        const pf_l2 = read16(94, 1000);          // 002Fh
+
+
+        const pf_l3 = read16(96, 1000);          // 0030h
+
+
+
+        const ph_sq = data.readInt16BE(100);     // 0032h
+
+
+        const ph_sq_msg = parsePhaseSequence(ph_sq);
+
+
+
+        const freq = data.readUInt16BE(102) / 10; // 0033h
+
+
+
+        const energy = read32(104, 10);          // 0034h KWh(+) TOT
+
+
+        const reactive_energy = read32(108, 10); // 0036h Kvarh(+) TOT
+
+
+
+        const l1_energy = read32(128, 10);       // 0040h KWh(+) L1
+
+
+        const l2_energy = read32(132, 10);       // 0042h KWh(+) L2
+
+
+        const l3_energy = read32(136, 10);       // 0044h KWh(+) L3
+
+
+
+        const t1_energy = read32(140, 10);       // 0046h KWh(+) T1
+
+
+        const t2_energy = read32(144, 10);       // 0048h KWh(+) T2
+
+
+        const t3_energy = read32(148, 10);       // 004Ah KWh(+) T3
+
+
+        const t4_energy = read32(152, 10);       // 004Ch KWh(+) T4
+
+
+
+        const exported_energy = read32(156, 10); // 004Eh KWh(-) TOT
+
+
+        const exported_reactive = read32(160, 10); // 0050h Kvarh(-) TOT
+
+
+
+        const t1_reactive_energy = read32(220, 10); // 006Eh Kvarh(+) T1
+
+
+        const t2_reactive_energy = read32(224, 10); // 0070h Kvarh(+) T2
+
+
+        const t3_reactive_energy = read32(228, 10); // 0072h Kvarh(+) T3
+
+
+        const t4_reactive_energy = read32(232, 10); // 0074h Kvarh(+) T4
+
+
+
+        return {
+
+
+            summary: {
+
+
+                voltage: {
+
+
+                    l1_n_v: l1_n_voltage,
+
+
+                    l2_n_v: l2_n_voltage,
+
+
+                    l3_n_v: l3_n_voltage,
+
+
+                    l1_l2_v: l1_l2_voltage,
+
+
+                    l2_l3_v: l2_l3_voltage,
+
+
+                    l3_l1_v: l3_l1_voltage
+
+
+                },
+
+
+                current: {
+
+
+                    l1_a: l1_current,
+
+
+                    l2_a: l2_current,
+
+
+                    l3_a: l3_current
+
+
+                },
+
+
+                power: {
+
+
+                    l1_w: l1_power,
+
+
+                    l2_w: l2_power,
+
+
+                    l3_w: l3_power,
+
+
+                    total_w: total_power
+
+
+                },
+
+
+                apparent: {
+
+
+                    l1_va: l1_va,
+
+
+                    l2_va: l2_va,
+
+
+                    l3_va: l3_va,
+
+
+                    total_va: total_va
+
+
+                },
+
+
+                reactive: {
+
+
+                    l1_var: l1_var,
+
+
+                    l2_var: l2_var,
+
+
+                    l3_var: l3_var,
+
+
+                    total_var: total_var
+
+
+                },
+
+
+                power_factor: {
+
+
+                    l1: pf_l1,
+
+
+                    l2: pf_l2,
+
+
+                    l3: pf_l3
+
+
+                },
+
+
+                frequency_hz: freq,
+
+
+                phase_sequence: ph_sq_msg,
+
+
+                energy: {
+
+
+                    import_kwh: energy,
+
+
+                    reactive_import_kvarh: reactive_energy,
+
+
+                    l1_kwh: l1_energy,
+
+
+                    l2_kwh: l2_energy,
+
+
+                    l3_kwh: l3_energy,
+
+
+                    tariff: {
+
+
+                        t1_kwh: t1_energy,
+
+
+                        t2_kwh: t2_energy,
+
+
+                        t3_kwh: t3_energy,
+
+
+                        t4_kwh: t4_energy
+
+
+                    },
+
+
+                    export_kwh: exported_energy,
+
+
+                    export_reactive_kvarh: exported_reactive,
+
+
+                    reactive_tariff: {
+
+
+                        t1_kvarh: t1_reactive_energy,
+
+
+                        t2_kvarh: t2_reactive_energy,
+
+
+                        t3_kvarh: t3_reactive_energy,
+
+
+                        t4_kvarh: t4_reactive_energy
+
+
+                    }
+
+
+                }
+
+
+            },
+
+
+            meta: {
+
+
+                unit_id: expectedUnitId,
+
+
+                register_count: REGISTER_COUNT,
+
+
+                start_address: START_ADDRESS,
+
+
+                timestamp: new Date().toISOString(),
+
+                timestamp_ms: Date.now(),
+
+
+                raw_hex: dumpBuffer(buffer.slice(0, expectedPayloadEnd))
+
+
+            }
+
+
+        };
+
+
+    }
+
+
+
+    function buildRequestBuffer(unitId) {
+
+
+        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(START_ADDRESS, 8);
+
+
+        buffer.writeUInt16BE(REGISTER_COUNT, 10);
+
+
+
+        return buffer;
+
+
+    }
+
+
+
+    function CarloGavazziNode(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 = toPositiveNumber(config.port, 502);
+
+
+        node.unitId = toPositiveNumber(config.unitId, 1);
+
+
+        node.timestep = toPollInterval(config.timestep, 1000);
+
+
+        node.expertMode = !!config.expertMode;
+
+
+        node.payloadFields = sanitizePayloadFieldsForMode(config.payloadFields, !!config.multiGrid, !!config.bessControl, !!config.controlExportReactive, !!config.scadaServer, !!config.influxDb, node.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.influxMeasurement = String(config.influxMeasurement || "").trim();
+        node.influxNode = String(config.influxNode || "").trim();
+
+
+        node.meterId = String(config.meterId || "").trim();
+
+
+
+        let intervalHandle = null;
+
+
+        let startupHandle = null;
+
+
+        let running = false;
+
+
+        let closed = false;
+
+
+        let registeredInfluxIdentityKey = "";
+
+
+
+        function getEffectiveMeterId() {
+
+
+            return node.meterId || ("meter" + 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 buildInfluxFields(baseParsed, selectedFields) {
+
+
+            const fields = {};
+
+
+
+            if (selectedFields.includes("full")) {
+
+
+                const summary = baseParsed && baseParsed.summary ? baseParsed.summary : {};
+
+
+                setInfluxField(fields, "voltage_l1_n_v", getByPath(summary, "voltage.l1_n_v"));
+
+
+                setInfluxField(fields, "voltage_l2_n_v", getByPath(summary, "voltage.l2_n_v"));
+
+
+                setInfluxField(fields, "voltage_l3_n_v", getByPath(summary, "voltage.l3_n_v"));
+
+
+                setInfluxField(fields, "voltage_l1_l2_v", getByPath(summary, "voltage.l1_l2_v"));
+
+
+                setInfluxField(fields, "voltage_l2_l3_v", getByPath(summary, "voltage.l2_l3_v"));
+
+
+                setInfluxField(fields, "voltage_l3_l1_v", getByPath(summary, "voltage.l3_l1_v"));
+
+
+                setInfluxField(fields, "current_l1_a", getByPath(summary, "current.l1_a"));
+
+
+                setInfluxField(fields, "current_l2_a", getByPath(summary, "current.l2_a"));
+
+
+                setInfluxField(fields, "current_l3_a", getByPath(summary, "current.l3_a"));
+
+
+                setInfluxField(fields, "power_l1_w", getByPath(summary, "power.l1_w"));
+
+
+                setInfluxField(fields, "power_l2_w", getByPath(summary, "power.l2_w"));
+
+
+                setInfluxField(fields, "power_l3_w", getByPath(summary, "power.l3_w"));
+
+
+                setInfluxField(fields, "power_w", getByPath(summary, "power.total_w"));
+
+
+                setInfluxField(fields, "apparent_l1_va", getByPath(summary, "apparent.l1_va"));
+
+
+                setInfluxField(fields, "apparent_l2_va", getByPath(summary, "apparent.l2_va"));
+
+
+                setInfluxField(fields, "apparent_l3_va", getByPath(summary, "apparent.l3_va"));
+
+
+                setInfluxField(fields, "apparent_total_va", getByPath(summary, "apparent.total_va"));
+
+
+                setInfluxField(fields, "reactive_l1_var", getByPath(summary, "reactive.l1_var"));
+
+
+                setInfluxField(fields, "reactive_l2_var", getByPath(summary, "reactive.l2_var"));
+
+
+                setInfluxField(fields, "reactive_l3_var", getByPath(summary, "reactive.l3_var"));
+
+
+                setInfluxField(fields, "reactive_total_var", getByPath(summary, "reactive.total_var"));
+
+
+                setInfluxField(fields, "power_factor_l1", getByPath(summary, "power_factor.l1"));
+
+
+                setInfluxField(fields, "power_factor_l2", getByPath(summary, "power_factor.l2"));
+
+
+                setInfluxField(fields, "power_factor_l3", getByPath(summary, "power_factor.l3"));
+
+
+                setInfluxField(fields, "frequency_hz", getByPath(summary, "frequency_hz"));
+
+
+                setInfluxField(fields, "energy_import_kwh", getByPath(summary, "energy.import_kwh"));
+
+
+                setInfluxField(fields, "energy_reactive_import_kvarh", getByPath(summary, "energy.reactive_import_kvarh"));
+
+
+                setInfluxField(fields, "energy_l1_kwh", getByPath(summary, "energy.l1_kwh"));
+
+
+                setInfluxField(fields, "energy_l2_kwh", getByPath(summary, "energy.l2_kwh"));
+
+
+                setInfluxField(fields, "energy_l3_kwh", getByPath(summary, "energy.l3_kwh"));
+
+
+                setInfluxField(fields, "energy_t1_kwh", getByPath(summary, "energy.tariff.t1_kwh"));
+
+
+                setInfluxField(fields, "energy_t2_kwh", getByPath(summary, "energy.tariff.t2_kwh"));
+
+
+                setInfluxField(fields, "energy_t3_kwh", getByPath(summary, "energy.tariff.t3_kwh"));
+
+
+                setInfluxField(fields, "energy_t4_kwh", getByPath(summary, "energy.tariff.t4_kwh"));
+
+
+                setInfluxField(fields, "energy_export_kwh", getByPath(summary, "energy.export_kwh"));
+
+
+                setInfluxField(fields, "energy_export_reactive_kvarh", getByPath(summary, "energy.export_reactive_kvarh"));
+
+
+                setInfluxField(fields, "energy_reactive_t1_kvarh", getByPath(summary, "energy.reactive_tariff.t1_kvarh"));
+
+
+                setInfluxField(fields, "energy_reactive_t2_kvarh", getByPath(summary, "energy.reactive_tariff.t2_kvarh"));
+
+
+                setInfluxField(fields, "energy_reactive_t3_kvarh", getByPath(summary, "energy.reactive_tariff.t3_kvarh"));
+
+
+                setInfluxField(fields, "energy_reactive_t4_kvarh", getByPath(summary, "energy.reactive_tariff.t4_kvarh"));
+
+
+                return fields;
+
+
+            }
+
+
+
+            selectedFields.forEach(function (field) {
+
+
+                const value = getByPath(baseParsed, field);
+
+
+                if (typeof value === "number" && Number.isFinite(value)) {
+
+
+                    fields[getCompactPayloadKey(field)] = value;
+
+
+                    return;
+
+
+                }
+
+
+
+                if (typeof value === "boolean") {
+
+
+                    fields[getCompactPayloadKey(field)] = value;
+
+
+                    return;
+
+
+                }
+
+
+
+                if (value && typeof value === "object" && !Array.isArray(value)) {
+
+
+                    setInfluxField(fields, getCompactPayloadKey(field), getByPath(baseParsed, field));
+
+
+                }
+
+
+            });
+
+
+
+            return fields;
+
+
+        }
+
+
+
+        function buildInfluxMessage(baseParsed, selectedFields) {
+
+
+            const timestamp = baseParsed && baseParsed.meta ? baseParsed.meta.timestamp : new Date().toISOString();
+
+
+            const fields = buildInfluxFields(baseParsed, selectedFields);
+
+
+            const measurement = getInfluxMeasurement();
+
+
+            const meterId = getEffectiveMeterId();
+
+
+
+            return {
+
+
+                topic: meterId,
+
+
+                meter_id: meterId,
+
+                source_id: meterId,
+
+
+                payload_field: selectedFields.includes("full") ? "full" : (selectedFields[0] || "full"),
+
+
+                carloGavazzi: baseParsed,
+
+
+                timestamp: timestamp,
+
+                timestamp_ms: baseParsed && baseParsed.meta && Number.isFinite(Number(baseParsed.meta.timestamp_ms))
+                    ? Number(baseParsed.meta.timestamp_ms)
+                    : Date.parse(timestamp),
+
+
+                payload: fields,
+
+
+                influx: {
+
+
+                    measurement: measurement,
+
+
+                    tags: {
+
+
+                        device_type: "carlo_gavazzi",
+
+
+                        meter_id: meterId,
+
+
+                        host: node.host,
+
+
+                        unit_id: String(node.unitId)
+
+
+                    },
+
+
+                    fields: fields,
+
+
+                    timestamp: timestamp
+
+
+                }
+
+
+            };
+
+
+        }
+
+
+
+        function buildSingleMessage(baseParsed, field, value) {
+
+
+            const outMsg = {
+
+
+                payload_field: field,
+
+
+                carloGavazzi: baseParsed,
+
+
+                timestamp: baseParsed && baseParsed.meta ? baseParsed.meta.timestamp : new Date().toISOString()
+
+
+            };
+
+            const meterId = getEffectiveMeterId();
+            outMsg.meter_id = meterId;
+            outMsg.source_id = meterId;
+            outMsg.ip = node.host;
+            outMsg.host = node.host;
+            outMsg.port = node.port;
+            outMsg.unit_id = node.unitId;
+            outMsg.device_type = "carlo_gavazzi";
+            outMsg.timestamp_ms = baseParsed && baseParsed.meta && Number.isFinite(Number(baseParsed.meta.timestamp_ms))
+                ? Number(baseParsed.meta.timestamp_ms)
+                : Date.parse(outMsg.timestamp);
+
+
+
+            if (node.multiGrid) {
+
+
+                outMsg.topic = getEffectiveMeterId();
+
+
+                outMsg.meter_id = getEffectiveMeterId();
+
+
+
+                if (field === "full") {
+
+
+                    outMsg.payload = baseParsed;
+
+
+                } else if (value && typeof value === "object" && !Array.isArray(value)) {
+
+
+                    outMsg.payload = value;
+
+
+                } else {
+
+
+                    outMsg.payload = {};
+
+
+                    outMsg.payload[getCompactPayloadKey(field)] = value;
+
+
+                }
+
+
+            } else if (node.bessControl) {
+
+
+                outMsg.topic = getEffectiveMeterId();
+
+
+                outMsg.meter_id = getEffectiveMeterId();
+
+
+
+                if (field === "full") {
+
+
+                    outMsg.payload = baseParsed;
+
+
+                } else if (value && typeof value === "object" && !Array.isArray(value)) {
+
+
+                    outMsg.payload = value;
+
+
+                } else {
+
+
+                    outMsg.payload = {};
+
+
+                    outMsg.payload[getCompactPayloadKey(field)] = value;
+
+
+                }
+
+
+            } else if (node.controlExportReactive) {
+
+
+                outMsg.topic = getEffectiveMeterId();
+
+
+                outMsg.meter_id = getEffectiveMeterId();
+
+
+
+                if (field === "full") {
+
+
+                    outMsg.payload = baseParsed;
+
+
+                } else if (value && typeof value === "object" && !Array.isArray(value)) {
+
+
+                    outMsg.payload = value;
+
+
+                } else {
+
+
+                    outMsg.payload = {};
+
+
+                    outMsg.payload[getCompactPayloadKey(field)] = value;
+
+
+                }
+
+
+            } else if (node.scadaServer) {
+
+
+                outMsg.topic = getEffectiveMeterId();
+
+
+                outMsg.meter_id = getEffectiveMeterId();
+
+
+
+                if (field === "full") {
+
+
+                    outMsg.payload = baseParsed;
+
+
+                } else if (value && typeof value === "object" && !Array.isArray(value)) {
+
+
+                    outMsg.payload = value;
+
+
+                } else {
+
+
+                    outMsg.payload = {};
+
+
+                    outMsg.payload[getScadaPayloadKey(field)] = value;
+
+
+                }
+
+
+            } else {
+
+
+                outMsg.topic = getPayloadLabel(field);
+
+
+                outMsg.payload = value;
+
+
+            }
+
+
+
+            return outMsg;
+
+
+        }
+
+
+
+        function setDisconnectedStatus(message) {
+
+
+            node.status({
+
+
+                fill: "red",
+
+
+                shape: "ring",
+
+
+                text: message
+
+
+            });
+
+
+        }
+
+
+
+        function setReadingStatus() {
+
+
+            node.status({
+
+
+                fill: "yellow",
+
+
+                shape: "dot",
+
+
+                text: "citire..."
+
+
+            });
+
+
+        }
+
+
+
+        function setStatusForSelection(selectedFields, parsed) {
+
+
+            if (selectedFields.includes("full")) {
+
+
+                node.status({
+
+
+                    fill: "green",
+
+
+                    shape: "dot",
+
+
+                    text: "Toate valorile"
+
+
+                });
+
+
+                return;
+
+
+            }
+
+
+
+            if (selectedFields.length === 1) {
+
+
+                const field = selectedFields[0];
+
+
+                const value = getByPath(parsed, field);
+
+
+
+                node.status({
+
+
+                    fill: "green",
+
+
+                    shape: "dot",
+
+
+                    text: formatSingleStatus(field, value)
+
+
+                });
+
+
+                return;
+
+
+            }
+
+
+
+            node.status({
+
+
+                fill: "green",
+
+
+                shape: "dot",
+
+
+                text: String(selectedFields.length) + " valori selectate"
+
+
+            });
+
+
+        }
+
+
+
+        function readMeter() {
+
+
+            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 (e) {
+
+
+                        // ignore
+
+
+                    }
+
+
+
+                    if (err) {
+
+
+                        reject(err);
+
+
+                    } else {
+
+
+                        resolve(result);
+
+
+                    }
+
+
+                }
+
+
+
+                socket.setTimeout(SOCKET_TIMEOUT_MS);
+
+
+
+                socket.connect(node.port, node.host, function () {
+
+
+                    try {
+
+
+                        const request = buildRequestBuffer(node.unitId);
+
+
+                        socket.write(request);
+
+
+                    } 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)) {
+
+
+                            try {
+
+
+                                parseMeterResponse(total, node.unitId);
+
+
+                            } catch (err) {
+
+
+                                done(err);
+
+
+                            }
+
+
+                            return;
+
+
+                        }
+
+
+
+                        const byteCount = total.readUInt8(8);
+
+
+                        const expectedLength = 9 + byteCount;
+
+
+
+                        if (total.length >= expectedLength) {
+
+
+                            try {
+
+
+                                const parsed = parseMeterResponse(total.slice(0, expectedLength), node.unitId);
+
+
+                                done(null, parsed);
+
+
+                            } catch (err) {
+
+
+                                done(err);
+
+
+                            }
+
+
+                        }
+
+
+                    }
+
+
+                });
+
+
+
+                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"));
+
+
+                    }
+
+
+                });
+
+
+            });
+
+
+        }
+
+
+
+        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("Carlo Gavazzi 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;
+                }
+            }
+
+            function sendIntegrated(message) {
+                if (influxMessage) {
+                    const target = RED.nodes.getNode(node.influxNode);
+                    if (target && typeof target.receive === "function") {
+                        target.receive(RED.util.cloneMessage(influxMessage));
+                    } else {
+                        node.warn("Carlo Gavazzi: selecteaza un nod adt-influxdb pentru integrarea secundara.");
+                    }
+                }
+                node.send(message);
+            }
+
+
+
+            if (selectedFields.includes("full")) {
+
+
+                node.send(buildSingleMessage(parsed, "full", parsed));
+
+
+                return;
+
+
+            }
+
+
+
+            if (node.multiGrid) {
+
+
+                const aggregatedPayload = {};
+
+
+
+                selectedFields.forEach(function (field) {
+
+
+                    aggregatedPayload[getCompactPayloadKey(field)] = getByPath(parsed, field);
+
+
+                });
+
+
+
+                sendIntegrated(buildSingleMessage(parsed, "multi", aggregatedPayload));
+
+
+                return;
+
+
+            }
+
+
+
+            if (node.bessControl) {
+
+
+                const aggregatedPayload = {};
+
+
+
+                selectedFields.forEach(function (field) {
+
+
+                    aggregatedPayload[getCompactPayloadKey(field)] = getByPath(parsed, field);
+
+
+                });
+
+
+
+                sendIntegrated(buildSingleMessage(parsed, "bess", aggregatedPayload));
+
+
+                return;
+
+
+            }
+
+
+
+            if (node.controlExportReactive) {
+
+
+                const aggregatedPayload = {};
+
+
+
+                selectedFields.forEach(function (field) {
+
+
+                    aggregatedPayload[getCompactPayloadKey(field)] = getByPath(parsed, field);
+
+
+                });
+
+
+
+                sendIntegrated(buildSingleMessage(parsed, "control_export_reactive", aggregatedPayload));
+
+
+                return;
+
+
+            }
+
+
+
+            if (node.scadaServer) {
+
+
+                const aggregatedPayload = {};
+
+
+
+                selectedFields.forEach(function (field) {
+
+
+                    aggregatedPayload[getScadaPayloadKey(field)] = getByPath(parsed, field);
+
+
+                });
+
+
+
+                sendIntegrated(buildSingleMessage(parsed, "scada", aggregatedPayload));
+
+
+                return;
+
+
+            }
+
+
+
+            const outputMessages = [];
+
+
+            let i;
+
+
+
+            for (i = 0; i < selectedFields.length; i += 1) {
+
+
+                outputMessages.push(null);
+
+
+            }
+
+
+
+            selectedFields.forEach(function (field, index) {
+
+
+                const value = getByPath(parsed, field);
+
+
+                outputMessages[index] = buildSingleMessage(parsed, field, value);
+
+
+            });
+
+
+
+            node.send(outputMessages);
+
+
+        }
+
+
+
+        async function executeRead() {
+
+
+            if (closed || running) {
+
+
+                return;
+
+
+            }
+
+
+
+            running = true;
+
+
+
+            try {
+
+
+                setReadingStatus();
+
+
+                const parsed = await readMeter();
+
+
+                sendParsedResult(parsed);
+
+
+            } catch (err) {
+
+
+                setDisconnectedStatus(err.message);
+
+
+                node.error(
+
+
+                    "Eroare Carlo Gavazzi (" +
+
+
+                    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("Carlo Gavazzi InfluxDB: combinatie duplicata Meter ID + Measurement ('" + getEffectiveMeterId() + "' @ '" + getInfluxMeasurement() + "'). Configureaza un Meter ID unic pentru acelasi measurement.");
+
+
+                }
+
+
+            }
+
+
+            if (node.timestep > 0) {
+                startupHandle = setTimeout(function () {
+
+
+                    executeRead();
+
+
+                }, 0);
+
+
+
+                intervalHandle = setInterval(function () {
+
+
+                    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);
+
+
+                startupHandle = null;
+
+
+            }
+
+
+
+            if (intervalHandle) {
+
+
+                clearInterval(intervalHandle);
+
+
+                intervalHandle = null;
+
+
+            }
+
+
+
+            done();
+
+
+        });
+
+
+    
+        });
+    }
+
+
+
+    RED.nodes.registerType("carlo-gavazzi", CarloGavazziNode);
+
+
+};