@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/janitza/janitza.js

@@ -0,0 +1,1500 @@
+module.exports = function (RED) {
+
+    "use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+
+    const net = require("net");
+
+    const janitzaProfiles = require("./lib/janitza-profiles");
+    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 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 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) {
+
+        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 invalid editor state
+
+                }
+
+            }
+
+            return [trimmed];
+
+        }
+
+
+        return keepEmpty ? [] : ["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 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.current.neutral_a": "Curent neutral",
+
+            "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": "Cos phi L1",
+
+            "summary.power_factor.l2": "Cos phi L2",
+
+            "summary.power_factor.l3": "Cos phi L3",
+
+            "summary.frequency_hz": "Frecventa",
+
+            "summary.phase_sequence": "Ordine faze",
+
+            "summary.energy.import_kwh": "Energie importata",
+
+            "summary.energy.export_kwh": "Energie exportata",
+
+            "summary.energy.l1_kwh": "Energie L1",
+
+            "summary.energy.l2_kwh": "Energie L2",
+
+            "summary.energy.l3_kwh": "Energie L3",
+
+            "summary.energy.apparent_kvah": "Energie aparenta",
+
+            "summary.energy.reactive_import_kvarh": "Energie reactiva",
+
+            "summary.energy.reactive_inductive_kvarh": "Energie reactiva inductiva",
+
+            "summary.energy.reactive_capacitive_kvarh": "Energie reactiva capacitiva",
+
+            "summary.thd.voltage.l1_pct": "THD tensiune L1",
+
+            "summary.thd.voltage.l2_pct": "THD tensiune L2",
+
+            "summary.thd.voltage.l3_pct": "THD tensiune L3",
+
+            "summary.thd.current.l1_pct": "THD curent L1",
+
+            "summary.thd.current.l2_pct": "THD curent L2",
+
+            "summary.thd.current.l3_pct": "THD curent L3"
+
+        };
+
+        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.current.neutral_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.frequency_hz": "Hz",
+
+            "summary.energy.import_kwh": "kWh",
+
+            "summary.energy.export_kwh": "kWh",
+
+            "summary.energy.l1_kwh": "kWh",
+
+            "summary.energy.l2_kwh": "kWh",
+
+            "summary.energy.l3_kwh": "kWh",
+
+            "summary.energy.apparent_kvah": "kVAh",
+
+            "summary.energy.reactive_import_kvarh": "kvarh",
+
+            "summary.energy.reactive_inductive_kvarh": "kvarh",
+
+            "summary.energy.reactive_capacitive_kvarh": "kvarh",
+
+            "summary.thd.voltage.l1_pct": "%",
+
+            "summary.thd.voltage.l2_pct": "%",
+
+            "summary.thd.voltage.l3_pct": "%",
+
+            "summary.thd.current.l1_pct": "%",
+
+            "summary.thd.current.l2_pct": "%",
+
+            "summary.thd.current.l3_pct": "%"
+
+        };
+
+        return units[path] || "";
+
+    }
+
+
+    function getCompactPayloadKey(path) {
+
+        const mapping = {
+
+            "summary.power.total_w": "power_w",
+
+            "summary.reactive.total_var": "reactive_total_var"
+
+        };
+
+        return mapping[path] || path.replace(/^summary\./, "").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 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 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 parsePhaseSequence(raw) {
+
+        if (raw === 1) {
+
+            return "right";
+
+        }
+
+        if (raw === -1) {
+
+            return "left";
+
+        }
+
+        if (raw === 0) {
+
+            return "none";
+
+        }
+
+        return String(raw);
+
+    }
+
+
+    function parseMeterResponse(buffer, expectedUnitId, profile) {
+
+        const modelProfile = profile || janitzaProfiles.getProfile();
+
+        const expectedByteCount = modelProfile.registerCount * 2;
+
+
+        if (!Buffer.isBuffer(buffer) || 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 (buffer.length < 6 + messageLength) {
+
+            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 !== expectedByteCount) {
+
+            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 readFloat(address) {
+
+            return data.readFloatBE((address - modelProfile.startAddress) * 2);
+
+        }
+
+
+        function whToKwh(value) {
+
+            return value / 1000;
+
+        }
+
+
+        function varhToKvarh(value) {
+
+            return value / 1000;
+
+        }
+
+
+        return {
+
+            summary: {
+
+                voltage: {
+
+                    l1_n_v: readFloat(19000),
+
+                    l2_n_v: readFloat(19002),
+
+                    l3_n_v: readFloat(19004),
+
+                    l1_l2_v: readFloat(19006),
+
+                    l2_l3_v: readFloat(19008),
+
+                    l3_l1_v: readFloat(19010)
+
+                },
+
+                current: {
+
+                    l1_a: readFloat(19012),
+
+                    l2_a: readFloat(19014),
+
+                    l3_a: readFloat(19016),
+
+                    neutral_a: readFloat(19018)
+
+                },
+
+                power: {
+
+                    l1_w: readFloat(19020),
+
+                    l2_w: readFloat(19022),
+
+                    l3_w: readFloat(19024),
+
+                    total_w: readFloat(19026)
+
+                },
+
+                apparent: {
+
+                    l1_va: readFloat(19028),
+
+                    l2_va: readFloat(19030),
+
+                    l3_va: readFloat(19032),
+
+                    total_va: readFloat(19034)
+
+                },
+
+                reactive: {
+
+                    l1_var: readFloat(19036),
+
+                    l2_var: readFloat(19038),
+
+                    l3_var: readFloat(19040),
+
+                    total_var: readFloat(19042)
+
+                },
+
+                power_factor: {
+
+                    l1: readFloat(19044),
+
+                    l2: readFloat(19046),
+
+                    l3: readFloat(19048)
+
+                },
+
+                frequency_hz: readFloat(19050),
+
+                phase_sequence: parsePhaseSequence(readFloat(19052)),
+
+                energy: {
+
+                    l1_kwh: whToKwh(readFloat(19054)),
+
+                    l2_kwh: whToKwh(readFloat(19056)),
+
+                    l3_kwh: whToKwh(readFloat(19058)),
+
+                    import_kwh: whToKwh(readFloat(19062) + readFloat(19064) + readFloat(19066)),
+
+                    export_kwh: whToKwh(readFloat(19076)),
+
+                    apparent_kvah: whToKwh(readFloat(19084)),
+
+                    reactive_import_kvarh: varhToKvarh(readFloat(19092)),
+
+                    reactive_inductive_kvarh: varhToKvarh(readFloat(19100)),
+
+                    reactive_capacitive_kvarh: varhToKvarh(readFloat(19108))
+
+                },
+
+                thd: {
+
+                    voltage: {
+
+                        l1_pct: readFloat(19110),
+
+                        l2_pct: readFloat(19112),
+
+                        l3_pct: readFloat(19114)
+
+                    },
+
+                    current: {
+
+                        l1_pct: readFloat(19116),
+
+                        l2_pct: readFloat(19118),
+
+                        l3_pct: readFloat(19120)
+
+                    }
+
+                }
+
+            },
+
+            meta: {
+
+                model: modelProfile.id,
+
+                device: modelProfile.deviceName,
+
+                unit_id: expectedUnitId,
+
+                register_count: modelProfile.registerCount,
+
+                start_address: modelProfile.startAddress,
+
+                timestamp: new Date().toISOString(),
+
+                raw_hex: dumpBuffer(buffer.slice(0, expectedPayloadEnd))
+
+            }
+
+        };
+
+    }
+
+
+    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 JanitzaNode(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 || janitzaProfiles.DEFAULT_PROFILE_ID).trim();
+
+        node.profile = janitzaProfiles.getProfile(node.model);
+
+        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 || ("janitza" + 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")) {
+                flattenNumericFields(baseParsed && baseParsed.summary ? baseParsed.summary : {}, "", fields);
+                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)) {
+                    flattenNumericFields(value, getCompactPayloadKey(field), fields);
+                }
+            });
+
+            return fields;
+
+        }
+
+
+        function buildInfluxMessage(baseParsed, selectedFields) {
+
+            const timestamp = baseParsed && baseParsed.meta ? baseParsed.meta.timestamp : new Date().toISOString();
+            const meterId = getEffectiveMeterId();
+            const fields = buildInfluxFields(baseParsed, selectedFields);
+
+            return {
+                topic: meterId,
+                meter_id: meterId,
+                payload_field: selectedFields.includes("full") ? "full" : (selectedFields[0] || "full"),
+                janitza: baseParsed,
+                timestamp: timestamp,
+                payload: fields,
+                influx: {
+                    measurement: getInfluxMeasurement(),
+                    tags: {
+                        device_type: "janitza",
+                        meter_id: meterId,
+                        host: node.host,
+                        unit_id: String(node.unitId),
+                        model: node.profile && node.profile.id ? node.profile.id : ""
+                    },
+                    fields: fields,
+                    timestamp: timestamp
+                }
+            };
+
+        }
+
+
+        function buildSingleMessage(baseParsed, field, value) {
+
+            const outMsg = {
+
+                payload_field: field,
+
+                janitza: baseParsed,
+
+                timestamp: baseParsed && baseParsed.meta ? baseParsed.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 = "janitza";
+            outMsg.model = node.profile && node.profile.id ? node.profile.id : "";
+
+
+            if (node.multiGrid || node.bessControl || node.controlExportReactive || 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[node.scadaServer ? getScadaPayloadKey(field) : getCompactPayloadKey(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];
+
+                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 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 (e) {
+
+                        // ignore socket 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)) {
+
+                            try {
+
+                                parseMeterResponse(total, node.unitId, node.profile);
+
+                            } catch (err) {
+
+                                done(err);
+
+                            }
+
+                            return;
+
+                        }
+
+
+                        const byteCount = total.readUInt8(8);
+
+                        const expectedLength = 9 + byteCount;
+
+                        if (total.length >= expectedLength) {
+
+                            try {
+
+                                if (byteCount !== registerCount * 2) {
+
+                                    throw new Error("Byte count invalid: " + byteCount);
+
+                                }
+
+                                done(null, {
+
+                                    buffer: total.slice(0, expectedLength),
+
+                                    data: total.slice(9, expectedLength)
+
+                                });
+
+                            } 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"));
+
+                    }
+
+                });
+
+            });
+
+        }
+
+
+        async function readMeter() {
+
+            const base = await readRegisterBlock(node.profile.startAddress, node.profile.registerCount);
+
+            const parsed = parseMeterResponse(base.buffer, node.unitId, node.profile);
+
+            const selectedFields = normalizePayloadFields(
+
+                node.payloadFields,
+
+                !!(node.expertMode && (node.multiGrid || node.bessControl || node.controlExportReactive || node.scadaServer || node.influxDb))
+
+            );
+
+
+            if (!selectedFields.includes("full")) {
+
+                const ranges = janitzaProfiles.buildExtendedReadRanges(selectedFields, node.profile, normalizePayloadFields);
+
+
+                for (let i = 0; i < ranges.length; i += 1) {
+
+                    const range = ranges[i];
+
+                    const block = await readRegisterBlock(range.start, range.count);
+
+
+                    range.items.forEach(function (item) {
+
+                        setByPath(parsed, item.field, janitzaProfiles.readValueFromRegisterData(block.data, range.start, item.definition));
+
+                    });
+
+                }
+
+            }
+
+
+            return parsed;
+
+        }
+
+
+        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("Janitza 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) {
+
+                    aggregatedPayload[node.scadaServer ? getScadaPayloadKey(field) : getCompactPayloadKey(field)] = getByPath(parsed, field);
+
+                });
+
+                const integratedMessage = buildSingleMessage(parsed, node.scadaServer ? "scada" : "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("Janitza: 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 {
+
+                setReadingStatus();
+
+                sendParsedResult(await readMeter());
+
+            } catch (err) {
+
+                setDisconnectedStatus(err.message);
+
+                node.error("Eroare Janitza (" + 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("Janitza 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("janitza", JanitzaNode);
+
+};