@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/fronius-read/fronius-read.js

@@ -0,0 +1,1466 @@
+module.exports = function (RED) {
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+    const {
+        ModbusRTU,
+        connectClient,
+        closeClient,
+        findBase,
+        scanModelDescriptors,
+        readModelByDescriptor,
+        readModelsByDescriptors,
+        probeInverterProfile
+    } = require("./lib/sunspec-core");
+
+    const {
+        buildSummary
+    } = require("./lib/sunspec-model-parsers");
+
+    const {
+        detectInverterProfile
+    } = require("./lib/inverter-profiles");
+
+    const {
+        atLeast
+    } = require("../lib/numbers");
+
+    const nodeRuntimeState = new Map();
+    const influxMeasurementRegistry = new Map();
+    const DEFAULT_INFLUX_PAYLOAD_FIELDS = [
+        "summary.ac.power_w",
+        "summary.dc.dc_total_power_w",
+        "summary.ac.voltage_l1_v",
+        "summary.ac.voltage_l2_v",
+        "summary.ac.voltage_l3_v"
+    ];
+    const DEFAULT_MULTI_GRID_PAYLOAD_FIELDS = [
+        "summary.meter.power_w",
+        "summary.meter.power_l1_w",
+        "summary.meter.power_l2_w",
+        "summary.meter.power_l3_w"
+    ];
+    const DEFAULT_METER_INFLUX_PAYLOAD_FIELDS = [
+        "summary.meter.power_w",
+        "summary.meter.power_l1_w",
+        "summary.meter.power_l2_w",
+        "summary.meter.power_l3_w",
+        "summary.meter.current_total_a",
+        "summary.meter.current_l1_a",
+        "summary.meter.current_l2_a",
+        "summary.meter.current_l3_a",
+        "summary.meter.voltage_ln_avg_v",
+        "summary.meter.voltage_l1_v",
+        "summary.meter.voltage_l2_v",
+        "summary.meter.voltage_l3_v",
+        "summary.meter.voltage_ll_avg_v",
+        "summary.meter.voltage_ll_ab_v",
+        "summary.meter.voltage_ll_bc_v",
+        "summary.meter.voltage_ll_ca_v",
+        "summary.meter.frequency_hz",
+        "summary.meter.apparent_power_va",
+        "summary.meter.apparent_power_l1_va",
+        "summary.meter.apparent_power_l2_va",
+        "summary.meter.apparent_power_l3_va",
+        "summary.meter.reactive_power_var",
+        "summary.meter.reactive_power_l1_var",
+        "summary.meter.reactive_power_l2_var",
+        "summary.meter.reactive_power_l3_var",
+        "summary.meter.power_factor"
+    ];
+    const METER_MODEL_IDS = [201, 202, 203, 204, 211, 212, 213, 214];
+
+    function toPollInterval(value, fallback) {
+        const text = String(value || "").trim().toLowerCase();
+        if (text === "off" || text === "0") return 0;
+        const n = Math.round(Number(value));
+        return Number.isFinite(n) && n > 0 ? n : fallback;
+    }
+
+    function getDefaultInfluxPayloadFieldsForDeviceType(deviceType) {
+        return deviceType === "smart_meter"
+            ? DEFAULT_METER_INFLUX_PAYLOAD_FIELDS.slice()
+            : DEFAULT_INFLUX_PAYLOAD_FIELDS.slice();
+    }
+
+    function setNodeRuntimeState(nodeId, state) {
+        nodeRuntimeState.set(nodeId, {
+            ...state,
+            updated_at: new Date().toISOString()
+        });
+    }
+
+    function clearNodeRuntimeState(nodeId) {
+        nodeRuntimeState.delete(nodeId);
+    }
+
+    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) {
+
+        if (!path || path === "full") {
+            return;
+        }
+
+        const parts = path.split(".");
+        let current = obj;
+
+        for (let i = 0; i < parts.length - 1; i++) {
+            const key = parts[i];
+
+            if (current[key] === undefined) {
+                current[key] = /^\d+$/.test(parts[i + 1]) ? [] : {};
+            }
+
+            current = current[key];
+        }
+
+        current[parts[parts.length - 1]] = value;
+
+    }
+
+    function normalizePayloadFields(fields) {
+
+        if (Array.isArray(fields) && fields.length) {
+            const normalized = Array.from(new Set(fields.filter(function (f) {
+                return !!String(f || "").trim();
+            })));
+
+            if (!normalized.length) {
+                return ["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);
+                    }
+                } catch (e) {
+                    // ignore
+                }
+            }
+
+            return [trimmed];
+        }
+
+        return ["full"];
+
+    }
+
+    function getPayloadLabel(path) {
+
+        const labels = {
+
+            "full": "Toate valorile",
+
+            "summary.ac.power_w": "Putere AC",
+            "summary.ac.current_total_a": "Curent total",
+            "summary.ac.current_l1_a": "Curent L1",
+            "summary.ac.current_l2_a": "Curent L2",
+            "summary.ac.current_l3_a": "Curent L3",
+            "summary.ac.voltage_ll_ab_v": "Tensiune AB",
+            "summary.ac.voltage_ll_bc_v": "Tensiune BC",
+            "summary.ac.voltage_ll_ca_v": "Tensiune CA",
+            "summary.ac.voltage_l1_v": "Tensiune L1",
+            "summary.ac.voltage_l2_v": "Tensiune L2",
+            "summary.ac.voltage_l3_v": "Tensiune L3",
+            "summary.ac.frequency_hz": "Frecvență",
+            "summary.ac.apparent_power_va": "Putere aparentă",
+            "summary.ac.reactive_power_var": "Putere reactivă",
+
+            "summary.meter.model_id": "Model ID",
+            "summary.meter.meter_model": "Model",
+            "summary.meter.power_w": "Putere activa",
+            "summary.meter.power_l1_w": "Putere L1",
+            "summary.meter.power_l2_w": "Putere L2",
+            "summary.meter.power_l3_w": "Putere L3",
+            "summary.meter.current_total_a": "Curent total",
+            "summary.meter.current_l1_a": "Curent L1",
+            "summary.meter.current_l2_a": "Curent L2",
+            "summary.meter.current_l3_a": "Curent L3",
+            "summary.meter.voltage_ln_avg_v": "Tensiune L-N medie",
+            "summary.meter.voltage_l1_v": "Tensiune L1",
+            "summary.meter.voltage_l2_v": "Tensiune L2",
+            "summary.meter.voltage_l3_v": "Tensiune L3",
+            "summary.meter.voltage_ll_avg_v": "Tensiune L-L medie",
+            "summary.meter.voltage_ll_ab_v": "Tensiune AB",
+            "summary.meter.voltage_ll_bc_v": "Tensiune BC",
+            "summary.meter.voltage_ll_ca_v": "Tensiune CA",
+            "summary.meter.frequency_hz": "Frecvență",
+            "summary.meter.apparent_power_va": "Putere aparentă",
+            "summary.meter.apparent_power_l1_va": "Putere aparentă L1",
+            "summary.meter.apparent_power_l2_va": "Putere aparentă L2",
+            "summary.meter.apparent_power_l3_va": "Putere aparentă L3",
+            "summary.meter.reactive_power_var": "Putere reactivă",
+            "summary.meter.reactive_power_l1_var": "Putere reactivă L1",
+            "summary.meter.reactive_power_l2_var": "Putere reactivă L2",
+            "summary.meter.reactive_power_l3_var": "Putere reactivă L3",
+            "summary.meter.power_factor": "Factor putere",
+            "summary.meter.power_factor_l1": "Factor putere L1",
+            "summary.meter.power_factor_l2": "Factor putere L2",
+            "summary.meter.power_factor_l3": "Factor putere L3",
+            "summary.meter.energy_import_wh": "Energie import",
+            "summary.meter.energy_import_l1_wh": "Energie import L1",
+            "summary.meter.energy_import_l2_wh": "Energie import L2",
+            "summary.meter.energy_import_l3_wh": "Energie import L3",
+            "summary.meter.energy_export_wh": "Energie export",
+            "summary.meter.energy_export_l1_wh": "Energie export L1",
+            "summary.meter.energy_export_l2_wh": "Energie export L2",
+            "summary.meter.energy_export_l3_wh": "Energie export L3",
+            "summary.meter.apparent_energy_import_vah": "Energie aparentă import",
+            "summary.meter.apparent_energy_export_vah": "Energie aparentă export",
+            "summary.meter.reactive_energy_import_q1_varh": "Energie reactivă import Q1",
+            "summary.meter.reactive_energy_import_q2_varh": "Energie reactivă import Q2",
+            "summary.meter.reactive_energy_export_q3_varh": "Energie reactivă export Q3",
+            "summary.meter.reactive_energy_export_q4_varh": "Energie reactivă export Q4",
+            "summary.meter.event_flags": "Event flags",
+
+            "summary.dc.dc_total_power_w": "Putere DC totală",
+            "summary.dc.module_count": "Număr module/stringuri DC",
+            "summary.dc.global_event": "Eveniment DC global",
+
+            "summary.dc.mppts.0.dc_voltage_v": "MPPT1 Tensiune",
+            "summary.dc.mppts.0.dc_current_a": "MPPT1 Curent",
+            "summary.dc.mppts.0.dc_power_w": "MPPT1 Putere",
+            "summary.dc.mppts.0.dc_energy_wh": "MPPT1 Energie",
+
+            "summary.dc.mppts.1.dc_voltage_v": "MPPT2 Tensiune",
+            "summary.dc.mppts.1.dc_current_a": "MPPT2 Curent",
+            "summary.dc.mppts.1.dc_power_w": "MPPT2 Putere",
+            "summary.dc.mppts.1.dc_energy_wh": "MPPT2 Energie",
+
+            "summary.dc.mppts.2.dc_voltage_v": "MPPT3 Tensiune",
+            "summary.dc.mppts.2.dc_current_a": "MPPT3 Curent",
+            "summary.dc.mppts.2.dc_power_w": "MPPT3 Putere",
+            "summary.dc.mppts.2.dc_energy_wh": "MPPT3 Energie",
+
+            "summary.dc.mppts.3.dc_voltage_v": "MPPT4 Tensiune",
+            "summary.dc.mppts.3.dc_current_a": "MPPT4 Curent",
+            "summary.dc.mppts.3.dc_power_w": "MPPT4 Putere",
+            "summary.dc.mppts.3.dc_energy_wh": "MPPT4 Energie",
+
+            "summary.common.manufacturer": "Producător",
+            "summary.common.model": "Model",
+            "summary.common.options": "Opțiuni",
+            "summary.common.version": "Versiune",
+            "summary.common.serial": "Serie",
+            "summary.common.device_address": "Adresă device"
+        };
+
+        return labels[path] || path;
+
+    }
+
+    function formatStatusValue(path, value, models, detection) {
+
+        if (path === "full") {
+
+            const profileText = detection && detection.profile_label
+                ? " | " + detection.profile_label
+                : "";
+
+            if (
+                value &&
+                value.summary &&
+                value.summary.ac &&
+                value.summary.ac.power_w !== null &&
+                value.summary.ac.power_w !== undefined
+            ) {
+                return String(value.summary.ac.power_w) + " W" + profileText;
+            }
+
+            if (
+                value &&
+                value.summary &&
+                value.summary.meter &&
+                value.summary.meter.power_w !== null &&
+                value.summary.meter.power_w !== undefined
+            ) {
+                return "meter " + String(value.summary.meter.power_w) + " W";
+            }
+
+            return String(models.length) + " models" + profileText;
+
+        }
+
+        if (value === undefined || value === null) {
+            return getPayloadLabel(path) + ": n/a";
+        }
+
+        const unitMap = {
+            "summary.ac.power_w": "W",
+            "summary.ac.current_total_a": "A",
+            "summary.ac.current_l1_a": "A",
+            "summary.ac.current_l2_a": "A",
+            "summary.ac.current_l3_a": "A",
+            "summary.ac.voltage_ll_ab_v": "V",
+            "summary.ac.voltage_ll_bc_v": "V",
+            "summary.ac.voltage_ll_ca_v": "V",
+            "summary.ac.voltage_l1_v": "V",
+            "summary.ac.voltage_l2_v": "V",
+            "summary.ac.voltage_l3_v": "V",
+            "summary.ac.frequency_hz": "Hz",
+            "summary.ac.apparent_power_va": "VA",
+            "summary.ac.reactive_power_var": "var",
+            "summary.meter.power_w": "W",
+            "summary.meter.power_l1_w": "W",
+            "summary.meter.power_l2_w": "W",
+            "summary.meter.power_l3_w": "W",
+            "summary.meter.current_total_a": "A",
+            "summary.meter.current_l1_a": "A",
+            "summary.meter.current_l2_a": "A",
+            "summary.meter.current_l3_a": "A",
+            "summary.meter.voltage_ln_avg_v": "V",
+            "summary.meter.voltage_l1_v": "V",
+            "summary.meter.voltage_l2_v": "V",
+            "summary.meter.voltage_l3_v": "V",
+            "summary.meter.voltage_ll_avg_v": "V",
+            "summary.meter.voltage_ll_ab_v": "V",
+            "summary.meter.voltage_ll_bc_v": "V",
+            "summary.meter.voltage_ll_ca_v": "V",
+            "summary.meter.frequency_hz": "Hz",
+            "summary.meter.apparent_power_va": "VA",
+            "summary.meter.apparent_power_l1_va": "VA",
+            "summary.meter.apparent_power_l2_va": "VA",
+            "summary.meter.apparent_power_l3_va": "VA",
+            "summary.meter.reactive_power_var": "var",
+            "summary.meter.reactive_power_l1_var": "var",
+            "summary.meter.reactive_power_l2_var": "var",
+            "summary.meter.reactive_power_l3_var": "var",
+            "summary.meter.energy_import_wh": "Wh",
+            "summary.meter.energy_import_l1_wh": "Wh",
+            "summary.meter.energy_import_l2_wh": "Wh",
+            "summary.meter.energy_import_l3_wh": "Wh",
+            "summary.meter.energy_export_wh": "Wh",
+            "summary.meter.energy_export_l1_wh": "Wh",
+            "summary.meter.energy_export_l2_wh": "Wh",
+            "summary.meter.energy_export_l3_wh": "Wh",
+            "summary.meter.apparent_energy_import_vah": "VAh",
+            "summary.meter.apparent_energy_export_vah": "VAh",
+            "summary.meter.reactive_energy_import_q1_varh": "varh",
+            "summary.meter.reactive_energy_import_q2_varh": "varh",
+            "summary.meter.reactive_energy_export_q3_varh": "varh",
+            "summary.meter.reactive_energy_export_q4_varh": "varh",
+            "summary.dc.dc_total_power_w": "W",
+
+            "summary.dc.mppts.0.dc_voltage_v": "V",
+            "summary.dc.mppts.0.dc_current_a": "A",
+            "summary.dc.mppts.0.dc_power_w": "W",
+            "summary.dc.mppts.0.dc_energy_wh": "Wh",
+
+            "summary.dc.mppts.1.dc_voltage_v": "V",
+            "summary.dc.mppts.1.dc_current_a": "A",
+            "summary.dc.mppts.1.dc_power_w": "W",
+            "summary.dc.mppts.1.dc_energy_wh": "Wh",
+
+            "summary.dc.mppts.2.dc_voltage_v": "V",
+            "summary.dc.mppts.2.dc_current_a": "A",
+            "summary.dc.mppts.2.dc_power_w": "W",
+            "summary.dc.mppts.2.dc_energy_wh": "Wh",
+
+            "summary.dc.mppts.3.dc_voltage_v": "V",
+            "summary.dc.mppts.3.dc_current_a": "A",
+            "summary.dc.mppts.3.dc_power_w": "W",
+            "summary.dc.mppts.3.dc_energy_wh": "Wh"
+        };
+
+        const label = getPayloadLabel(path);
+        const unit = unitMap[path] ? " " + unitMap[path] : "";
+
+        return label + ": " + value + unit;
+
+    }
+
+    function getTargetModelIdsForPath(path) {
+
+        if (!path || path === "full") {
+            return [];
+        }
+
+        if (path.indexOf("summary.common.") === 0) {
+            return [1];
+        }
+
+        if (path.indexOf("summary.ac.") === 0) {
+            return [101, 102, 103, 111, 112, 113];
+        }
+
+        if (path.indexOf("summary.dc.") === 0) {
+            return [160];
+        }
+
+        if (path.indexOf("summary.meter.") === 0) {
+            return METER_MODEL_IDS.slice();
+        }
+
+        return [];
+
+    }
+
+    function fieldPathToCompactKey(path) {
+
+        if (!path) {
+            return "value";
+        }
+
+        const trimmed = String(path).trim();
+
+        if (trimmed === "summary.ac.power_w") {
+            return "power_w";
+        }
+
+        const meterMapping = {
+            "summary.meter.power_w": "power_w",
+            "summary.meter.power_l1_w": "power_l1_w",
+            "summary.meter.power_l2_w": "power_l2_w",
+            "summary.meter.power_l3_w": "power_l3_w",
+            "summary.meter.current_total_a": "current_total_a",
+            "summary.meter.current_l1_a": "current_l1_a",
+            "summary.meter.current_l2_a": "current_l2_a",
+            "summary.meter.current_l3_a": "current_l3_a",
+            "summary.meter.voltage_ln_avg_v": "voltage_ln_avg_v",
+            "summary.meter.voltage_ll_avg_v": "voltage_ll_avg_v",
+            "summary.meter.frequency_hz": "frequency_hz",
+            "summary.meter.reactive_power_var": "reactive_power_var",
+            "summary.meter.apparent_power_va": "apparent_power_va",
+            "summary.meter.power_factor": "power_factor"
+        };
+
+        if (meterMapping[trimmed]) {
+            return meterMapping[trimmed];
+        }
+
+        return trimmed
+            .replace(/^summary\./, "")
+            .replace(/[^\w]+/g, "_")
+            .replace(/^_+|_+$/g, "");
+
+    }
+
+    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 getTargetModelIdsForPaths(paths) {
+
+        const ids = new Set();
+
+        normalizePayloadFields(paths).forEach(function (path) {
+            getTargetModelIdsForPath(path).forEach(function (modelId) {
+                ids.add(modelId);
+            });
+        });
+
+        return Array.from(ids);
+
+    }
+
+    function detectDeviceType(summary) {
+        if (summary && summary.meter) return "smart_meter";
+        if (summary && (summary.ac || summary.dc)) return "inverter";
+        return "unknown";
+    }
+
+    function getDefaultInfluxPayloadFields(summary) {
+        return detectDeviceType(summary) === "smart_meter"
+            ? DEFAULT_METER_INFLUX_PAYLOAD_FIELDS.slice()
+            : DEFAULT_INFLUX_PAYLOAD_FIELDS.slice();
+    }
+
+    function getDefaultControlField(summary) {
+        return detectDeviceType(summary) === "smart_meter"
+            ? "summary.meter.power_w"
+            : "summary.ac.power_w";
+    }
+
+    function toScadaNumber(value) {
+        const number = Number(value);
+        return Number.isFinite(number) ? number : null;
+    }
+
+    function buildScadaPayload(summary, deviceType) {
+        const values = deviceType === "smart_meter"
+            ? ((summary && summary.meter) || {})
+            : ((summary && summary.ac) || {});
+        return {
+            p: toScadaNumber(values.power_w),
+            q: toScadaNumber(values.reactive_power_var),
+            f: toScadaNumber(values.frequency_hz),
+            u_l1n: toScadaNumber(values.voltage_l1_v),
+            u_l2n: toScadaNumber(values.voltage_l2_v),
+            u_l3n: toScadaNumber(values.voltage_l3_v),
+            u_ln_avg: toScadaNumber(values.voltage_ln_avg_v),
+            u_l12: toScadaNumber(values.voltage_ll_ab_v),
+            u_l23: toScadaNumber(values.voltage_ll_bc_v),
+            u_l31: toScadaNumber(values.voltage_ll_ca_v),
+            u_ll_avg: toScadaNumber(values.voltage_ll_avg_v)
+        };
+    }
+
+    function buildDescriptorMap(descriptors) {
+
+        const map = {};
+
+        descriptors.forEach(function (descriptor) {
+            map[descriptor.model_id] = descriptor;
+        });
+
+        return map;
+
+    }
+
+    function pickSelectedEnvelope(envelope, payloadFields) {
+
+        const normalized = normalizePayloadFields(payloadFields);
+
+        if (normalized.includes("full")) {
+            return envelope;
+        }
+
+        const result = {};
+
+        normalized.forEach(function (path) {
+            setByPath(result, path, getByPath(envelope, path));
+        });
+
+        return result;
+
+    }
+
+    RED.httpAdmin.get("/fronius-read/probe", async function (req, res) {
+
+        const host = req.query.host;
+        const port = atLeast(req.query.port, 1, 502);
+        const unitId = atLeast(req.query.unitId, 1, 1);
+
+        if (!host) {
+            res.json({ ok: false, error: "Missing host" });
+            return;
+        }
+
+        try {
+            const result = await probeInverterProfile(host, port, unitId);
+            res.json(result);
+        } catch (e) {
+            res.json({
+                ok: false,
+                error: e.message || String(e)
+            });
+        }
+
+    });
+
+    RED.httpAdmin.get("/fronius-read/state/:id", function (req, res) {
+
+        const nodeId = req.params.id;
+
+        if (!nodeId) {
+            res.json({ ok: false, error: "Missing node id" });
+            return;
+        }
+
+        const state = nodeRuntimeState.get(nodeId);
+
+        if (!state) {
+            res.json({ ok: false, error: "No cached state" });
+            return;
+        }
+
+        res.json({
+            ok: true,
+            state: state
+        });
+
+    });
+
+    function FroniusReadNode(config) {
+
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+
+        node.host = config.host;
+        node.port = atLeast(config.port, 1, 502);
+        node.unitId = atLeast(config.unitId, 1, 1);
+        node.pollInterval = toPollInterval(config.pollInterval, 5000);
+        node.inverterType = "auto";
+        node.payloadField = config.payloadField || "full";
+        node.payloadFields = normalizePayloadFields(
+            config.payloadFields !== undefined
+                ? config.payloadFields
+                : config.payloadField
+        );
+        node.debugMode = !!config.debugMode;
+        node.multiInverter = !!config.multiInverter;
+        node.controlExport = !!config.controlExport;
+        node.multiGrid = !!config.multiGrid;
+        node.scadaAggregator = !!config.scadaAggregator;
+        node.multiGridUseSelectedFields = config.multiGridUseSelectedFields !== undefined
+            ? !!config.multiGridUseSelectedFields
+            : false;
+        if (node.multiGrid) {
+            node.multiInverter = false;
+            node.controlExport = false;
+        }
+        if (node.multiInverter && node.controlExport) {
+            node.controlExport = false;
+        }
+        node.influxDb = !!config.influxDb;
+        if (node.scadaAggregator) {
+            node.multiInverter = false;
+            node.controlExport = false;
+            node.multiGrid = false;
+            node.influxDb = false;
+        }
+        node.influxMeasurement = String(config.influxMeasurement || "").trim();
+        node.influxNode = String(config.influxNode || "").trim();
+        node.multiInverterExpertMode = !!config.multiInverterExpertMode;
+        node.multiInverterUseSelectedFields = config.multiInverterUseSelectedFields !== undefined
+            ? !!config.multiInverterUseSelectedFields
+            : !!config.multiInverterExpertMode;
+        if (node.influxDb && !(node.multiInverter || node.controlExport || node.multiGrid)) {
+            const selectedInfluxFields = normalizePayloadFields(node.payloadFields).filter(function (field) {
+                return field !== "full";
+            });
+            node.payloadFields = node.multiInverterUseSelectedFields
+                ? (selectedInfluxFields.length ? selectedInfluxFields : DEFAULT_INFLUX_PAYLOAD_FIELDS.slice())
+                : DEFAULT_INFLUX_PAYLOAD_FIELDS.slice();
+            node.payloadField = node.payloadFields[0];
+        }
+        node.inverterId = (config.inverterId || "").trim();
+        const compactOutputMode = node.multiInverter || node.controlExport || node.multiGrid;
+        const singleOutputMode = compactOutputMode || node.influxDb || node.scadaAggregator;
+        const primaryOutputs = compactOutputMode
+            ? 1
+            : (node.payloadFields.includes("full") ? 1 : Math.max(1, node.payloadFields.length));
+        node.outputs = (singleOutputMode ? 1 : primaryOutputs) + (node.debugMode ? 1 : 0);
+
+        let client = new ModbusRTU();
+        let timer = null;
+        let busy = false;
+        let closing = false;
+
+        let sunspecBase = null;
+        let modelDescriptors = null;
+        let modelDescriptorMap = null;
+        let cachedDetection = null;
+        let cachedDeviceType = null;
+        let registeredInfluxIdentityKey = "";
+
+        async function connect() {
+            await connectClient(client, node.host, node.port, node.unitId);
+        }
+
+        async function resetConnection() {
+
+            try {
+                await closeClient(client);
+            } catch (e) {
+                // ignore
+            }
+
+            client = new ModbusRTU();
+            sunspecBase = null;
+            modelDescriptors = null;
+            modelDescriptorMap = null;
+            cachedDetection = null;
+            cachedDeviceType = null;
+
+        }
+
+        async function ensureDiscovery() {
+
+            await connect();
+
+            if (!sunspecBase) {
+                sunspecBase = await findBase(client);
+            }
+
+            if (!modelDescriptors) {
+                modelDescriptors = await scanModelDescriptors(client, sunspecBase);
+                modelDescriptorMap = buildDescriptorMap(modelDescriptors);
+            }
+
+            if (!cachedDetection) {
+                const discoveryModels = await readModelsByDescriptors(client, modelDescriptors);
+                const discoverySummary = buildSummary(discoveryModels);
+                cachedDetection = detectInverterProfile(discoverySummary);
+                cachedDeviceType = detectDeviceType(discoverySummary);
+            }
+
+        }
+
+        async function readFullPayload() {
+
+            const models = await readModelsByDescriptors(client, modelDescriptors);
+                const summary = buildSummary(models);
+                const detection = detectInverterProfile(summary);
+
+                cachedDetection = detection;
+                cachedDeviceType = detectDeviceType(summary);
+
+            return {
+                mode: "full",
+                models: models,
+                summary: summary,
+                detection: detection
+            };
+
+        }
+
+        async function readOptimizedPayload(payloadFields) {
+
+            const targetModelIds = getTargetModelIdsForPaths(payloadFields);
+
+            if (!targetModelIds.length || !modelDescriptorMap) {
+                return readFullPayload();
+            }
+
+            const descriptors = targetModelIds
+                .map(function (id) {
+                    return modelDescriptorMap[id];
+                })
+                .filter(Boolean);
+
+            if (!descriptors.length) {
+                return readFullPayload();
+            }
+
+            let models;
+
+            if (descriptors.length === 1) {
+                models = [await readModelByDescriptor(client, descriptors[0])];
+            } else {
+                models = await readModelsByDescriptors(client, descriptors);
+            }
+
+            const summary = buildSummary(models);
+            const detection = cachedDetection || detectInverterProfile(summary);
+            cachedDeviceType = detectDeviceType(summary);
+
+            return {
+                mode: "optimized",
+                models: models,
+                summary: summary,
+                detection: detection
+            };
+
+        }
+
+        function getEffectiveInverterId() {
+
+            return node.inverterId || (
+                node.multiGrid || cachedDeviceType === "smart_meter"
+                    ? ("meter" + String(node.unitId))
+                    : ("inv" + String(node.unitId))
+            );
+
+        }
+
+        function getInfluxMeasurement() {
+
+            return node.influxMeasurement || getEffectiveInverterId();
+
+        }
+
+        function getInfluxIdentityKey() {
+
+            return String(getInfluxMeasurement() || "").trim().toLowerCase() + "::" + String(getEffectiveInverterId() || "").trim().toLowerCase();
+
+        }
+
+        function hasInfluxMeasurementConflict() {
+
+            return node.influxDb && hasDuplicateInfluxMeasurement(node.id, getInfluxIdentityKey());
+
+        }
+
+        function buildInfluxFields(envelope, selectedFields) {
+
+            const fields = {};
+
+            if (selectedFields.includes("full")) {
+                flattenNumericFields(envelope && envelope.summary ? envelope.summary : {}, "", fields);
+                return fields;
+            }
+
+            selectedFields.forEach(function (fieldPath) {
+                const value = getByPath(envelope, fieldPath);
+                const key = fieldPathToCompactKey(fieldPath);
+
+                if (typeof value === "number" && Number.isFinite(value)) {
+                    fields[key] = value;
+                    return;
+                }
+
+                if (typeof value === "boolean") {
+                    fields[key] = value;
+                    return;
+                }
+
+                if (value && typeof value === "object" && !Array.isArray(value)) {
+                    flattenNumericFields(value, key, fields);
+                }
+            });
+
+            return fields;
+
+        }
+
+        function scheduleNextPoll() {
+
+            if (closing) {
+                return;
+            }
+
+            timer = setTimeout(function () {
+                pollLoop();
+            }, node.pollInterval);
+
+        }
+
+        async function pollOnce() {
+
+            if (busy) {
+                return;
+            }
+
+            busy = true;
+
+            try {
+
+                await ensureDiscovery();
+
+                const discoveredDeviceType = cachedDeviceType || "unknown";
+                const inverterCompactRequested = node.multiInverter || node.controlExport;
+                const multiGridRequested = node.multiGrid;
+                const multiGridOutputMode = multiGridRequested && discoveredDeviceType === "smart_meter";
+                const compactOutputMode = inverterCompactRequested && discoveredDeviceType !== "smart_meter";
+                const effectivePayloadFields = multiGridOutputMode
+                    ? (
+                        node.multiGridUseSelectedFields
+                            ? (function () {
+                                const selected = normalizePayloadFields(node.payloadFields).filter(function (field) {
+                                    return field !== "full";
+                                });
+                                return selected.length ? selected : DEFAULT_MULTI_GRID_PAYLOAD_FIELDS.slice();
+                            })()
+                            : DEFAULT_MULTI_GRID_PAYLOAD_FIELDS.slice()
+                    )
+                    : multiGridRequested
+                    ? ["full"]
+                    : inverterCompactRequested && discoveredDeviceType === "smart_meter"
+                    ? ["full"]
+                    : compactOutputMode
+                    ? (
+                        node.multiInverterUseSelectedFields
+                            ? (function () {
+                                const selected = normalizePayloadFields(node.payloadFields).filter(function (field) {
+                                    return field !== "full";
+                                });
+                                return selected.length ? selected : ["summary.ac.power_w"];
+                            })()
+                            : (node.controlExport ? ["summary.ac.power_w", "summary.meter.power_w"] : ["summary.ac.power_w"])
+                    )
+                    : node.influxDb
+                        ? (function () {
+                            const defaultInfluxFields = getDefaultInfluxPayloadFieldsForDeviceType(discoveredDeviceType);
+                            if (!node.multiInverterUseSelectedFields) {
+                                return defaultInfluxFields;
+                            }
+                            const selected = normalizePayloadFields(node.payloadFields).filter(function (field) {
+                                return field !== "full";
+                            });
+                            return selected.length ? selected : defaultInfluxFields;
+                        })()
+                    : normalizePayloadFields(node.payloadFields);
+
+                const readResult =
+                    effectivePayloadFields.includes("full")
+                        ? await readFullPayload()
+                        : await readOptimizedPayload(effectivePayloadFields);
+
+                const models = readResult.models;
+                const summary = readResult.summary;
+                const detection = readResult.detection;
+                const deviceType = detectDeviceType(summary);
+                const defaultControlField = getDefaultControlField(summary);
+
+                const modelList = modelDescriptors
+                    ? modelDescriptors.map(function (m) {
+                        return {
+                            model_id: m.model_id,
+                            addr: m.addr,
+                            len: m.len
+                        };
+                    })
+                    : [];
+
+                const envelope = {
+                    status: "ok",
+                    ip: node.host,
+                    unit_id: node.unitId,
+                    device_type: deviceType,
+                    inverter_type: node.inverterType,
+                    inverter_profile: detection.profile_key,
+                    inverter_profile_label: detection.profile_label,
+                    manufacturer: detection.manufacturer,
+                    family: detection.family,
+                    phase_mode: detection.phase_mode,
+                    mppt_count: detection.mppt_count,
+                    detection_source: detection.detection_source,
+                    optimized_read: readResult.mode === "optimized",
+                    sunspec_base: sunspecBase,
+                    model_count: modelDescriptors ? modelDescriptors.length : models.length,
+                    models: modelList,
+                    summary: summary,
+                    ts: new Date().toISOString()
+                };
+
+                if (effectivePayloadFields.includes("full")) {
+                    envelope.raw_models = models;
+                }
+
+                const debugMessage = node.debugMode
+                    ? {
+                        topic: "fronius/raw",
+                        payload: {
+                            status: "ok",
+                            ip: node.host,
+                            unit_id: node.unitId,
+                            device_type: deviceType,
+                            inverter_type: node.inverterType,
+                            inverter_profile: detection.profile_key,
+                            inverter_profile_label: detection.profile_label,
+                            phase_mode: detection.phase_mode,
+                            mppt_count: detection.mppt_count,
+                            optimized_read: readResult.mode === "optimized",
+                            sunspec_base: sunspecBase,
+                            raw_models: models,
+                            summary: summary,
+                            ts: new Date().toISOString()
+                        },
+                        payload_field: "raw_models",
+                        payload_fields: effectivePayloadFields.slice()
+                    }
+                    : null;
+
+                const selectedPayload =
+                    effectivePayloadFields.includes("full")
+                        ? envelope
+                        : pickSelectedEnvelope(envelope, effectivePayloadFields);
+
+                const statusText =
+                    effectivePayloadFields.includes("full")
+                        ? formatStatusValue("full", selectedPayload, models, detection)
+                        : (
+                            effectivePayloadFields.length === 1
+                                ? formatStatusValue(
+                                    effectivePayloadFields[0],
+                                    getByPath(envelope, effectivePayloadFields[0]),
+                                    models,
+                                    detection
+                                )
+                                : String(effectivePayloadFields.length) + " valori"
+                        );
+
+                node.status({
+                    fill: "green",
+                    shape: "dot",
+                    text: statusText
+                });
+
+                setNodeRuntimeState(node.id, {
+                    status: "ok",
+                    node_id: node.id,
+                    ip: node.host,
+                    unit_id: node.unitId,
+                    device_type: deviceType,
+                    payload_field: effectivePayloadFields[0] || "full",
+                    payload_fields: effectivePayloadFields,
+                    inverter_profile: detection.profile_key,
+                    inverter_profile_label: detection.profile_label,
+                    manufacturer: detection.manufacturer,
+                    family: detection.family,
+                    phase_mode: detection.phase_mode,
+                    mppt_count: detection.mppt_count,
+                    detection_source: detection.detection_source,
+                    optimized_read: readResult.mode === "optimized",
+                    summary: summary
+                });
+
+                let message;
+
+                if (node.scadaAggregator) {
+                    const sourceId = getEffectiveInverterId();
+                    message = {
+                        topic: sourceId,
+                        scadaSource: sourceId,
+                        scadaGroup: deviceType === "smart_meter" ? "grid_meter" : "pv_inverter",
+                        payload: buildScadaPayload(summary, deviceType),
+                        device_type: deviceType,
+                        inverter_id: sourceId,
+                        ip: node.host,
+                        unit_id: node.unitId,
+                        summary_fragment: summary,
+                        ts: envelope.ts
+                    };
+                    if (debugMessage) node.send([message, debugMessage]); else node.send(message);
+                    return;
+                }
+
+                if (node.influxDb) {
+
+                    if (hasInfluxMeasurementConflict()) {
+                        node.status({
+                            fill: "red",
+                            shape: "ring",
+                            text: "inverter_id+measurement duplicat"
+                        });
+                        node.error("Fronius InfluxDB: combinatie duplicata Inverter ID + Measurement ('" + getEffectiveInverterId() + "' @ '" + getInfluxMeasurement() + "'). Configureaza un Inverter ID unic pentru acelasi measurement.");
+                        return;
+                    }
+
+                    const inverterId = getEffectiveInverterId();
+                    const influxFields = buildInfluxFields(envelope, effectivePayloadFields);
+                    const influxMessage = {
+                        topic: inverterId,
+                        payload: influxFields,
+                        payload_field: effectivePayloadFields.includes("full") ? "full" : (effectivePayloadFields[0] || "full"),
+                        payload_fields: effectivePayloadFields.slice(),
+                        inverter_id: inverterId,
+                        device_type: deviceType,
+                        inverter_type: node.inverterType,
+                        inverter_profile: detection.profile_key,
+                        inverter_profile_label: detection.profile_label,
+                        manufacturer: detection.manufacturer,
+                        family: detection.family,
+                        phase_mode: detection.phase_mode,
+                        mppt_count: detection.mppt_count,
+                        detection_source: detection.detection_source,
+                        optimized_read: readResult.mode === "optimized",
+                        summary_fragment: summary,
+                        influx: {
+                            measurement: getInfluxMeasurement(),
+                            tags: {
+                                device_type: deviceType === "smart_meter" ? "fronius_smart_meter" : "fronius_inverter",
+                                inverter_id: inverterId,
+                                host: node.host,
+                                unit_id: String(node.unitId),
+                                inverter_profile: detection.profile_key || ""
+                            },
+                            fields: influxFields,
+                            timestamp: envelope.ts
+                        }
+                    };
+
+                    if (compactOutputMode) {
+                        const target = RED.nodes.getNode(node.influxNode);
+                        if (target && typeof target.receive === "function") target.receive(RED.util.cloneMessage(influxMessage));
+                        else node.warn("Fronius Read: selecteaza un nod adt-influxdb pentru integrarea secundara.");
+                    } else {
+                        if (debugMessage) node.send([influxMessage, debugMessage]);
+                        else node.send(influxMessage);
+                        return;
+                    }
+                }
+
+                if (multiGridOutputMode) {
+                    const meterId = getEffectiveInverterId();
+                    const multiGridPayload = {};
+
+                    effectivePayloadFields.forEach(function (fieldPath) {
+                        multiGridPayload[fieldPathToCompactKey(fieldPath)] = getByPath(envelope, fieldPath);
+                    });
+
+                    const multiGridMessage = {
+                        topic: meterId,
+                        meter_id: meterId,
+                        payload: multiGridPayload,
+                        payload_field: "multi",
+                        payload_fields: effectivePayloadFields.slice(),
+                        device_type: deviceType,
+                        meter_model: summary && summary.meter ? summary.meter.meter_model : null,
+                        manufacturer: detection.manufacturer,
+                        family: detection.family,
+                        phase_mode: detection.phase_mode,
+                        detection_source: detection.detection_source,
+                        optimized_read: readResult.mode === "optimized",
+                        summary_fragment: summary
+                    };
+
+                    if (debugMessage) {
+                        node.send([multiGridMessage, debugMessage]);
+                    } else {
+                        node.send(multiGridMessage);
+                    }
+                    return;
+                }
+
+                if (compactOutputMode) {
+
+                    const inverterId = getEffectiveInverterId();
+                    const useSelectedFields = !!node.multiInverterUseSelectedFields;
+                    const compactPayload = {};
+
+                    if (useSelectedFields) {
+                        effectivePayloadFields.forEach(function (fieldPath) {
+                            compactPayload[fieldPathToCompactKey(fieldPath)] = getByPath(envelope, fieldPath);
+                        });
+                    }
+
+                    message = {
+                        topic: inverterId,
+                        payload: useSelectedFields
+                            ? compactPayload
+                            : {
+                                power_w: getByPath(envelope, defaultControlField)
+                            },
+                        payload_field: useSelectedFields
+                            ? (effectivePayloadFields[0] || defaultControlField)
+                            : defaultControlField,
+                        payload_fields: useSelectedFields
+                            ? effectivePayloadFields.slice()
+                            : [defaultControlField],
+                        inverter_id: inverterId,
+                        device_type: deviceType,
+                        inverter_type: node.inverterType,
+                        inverter_profile: detection.profile_key,
+                        inverter_profile_label: detection.profile_label,
+                        manufacturer: detection.manufacturer,
+                        family: detection.family,
+                        phase_mode: detection.phase_mode,
+                        mppt_count: detection.mppt_count,
+                        detection_source: detection.detection_source,
+                        optimized_read: readResult.mode === "optimized",
+                        summary_fragment: summary
+                    };
+
+                    if (debugMessage) {
+                        node.send([message, debugMessage]);
+                    } else {
+                        node.send(message);
+                    }
+
+                } else if (effectivePayloadFields.includes("full")) {
+
+                    message = {
+                        topic: "full",
+                        payload: selectedPayload,
+                        payload_field: "full",
+                        payload_fields: ["full"],
+                        device_type: deviceType,
+                        inverter_type: node.inverterType,
+                        inverter_profile: detection.profile_key,
+                        inverter_profile_label: detection.profile_label,
+                        manufacturer: detection.manufacturer,
+                        family: detection.family,
+                        phase_mode: detection.phase_mode,
+                        mppt_count: detection.mppt_count,
+                        detection_source: detection.detection_source,
+                        optimized_read: readResult.mode === "optimized",
+                        full_payload: envelope
+                    };
+
+                    if (debugMessage) {
+                        node.send([message, debugMessage]);
+                    } else {
+                        node.send(message);
+                    }
+
+                } else if (effectivePayloadFields.length === 1) {
+
+                    const singleField = effectivePayloadFields[0];
+
+                    message = {
+                        topic: getPayloadLabel(singleField),
+                        payload: getByPath(envelope, singleField),
+                        payload_field: singleField,
+                        payload_fields: effectivePayloadFields,
+                        device_type: deviceType,
+                        inverter_type: node.inverterType,
+                        inverter_profile: detection.profile_key,
+                        inverter_profile_label: detection.profile_label,
+                        manufacturer: detection.manufacturer,
+                        family: detection.family,
+                        phase_mode: detection.phase_mode,
+                        mppt_count: detection.mppt_count,
+                        detection_source: detection.detection_source,
+                        optimized_read: readResult.mode === "optimized",
+                        summary_fragment: summary
+                    };
+
+                    if (debugMessage) {
+                        node.send([message, debugMessage]);
+                    } else {
+                        node.send(message);
+                    }
+
+                } else {
+
+                    const primaryOutputCount = Math.max(1, effectivePayloadFields.length);
+                    const outputCount = primaryOutputCount + (debugMessage ? 1 : 0);
+                    const outputMessages = new Array(outputCount).fill(null);
+
+                    effectivePayloadFields.forEach(function (fieldPath, index) {
+                        outputMessages[index] = {
+                            topic: getPayloadLabel(fieldPath),
+                            payload: getByPath(envelope, fieldPath),
+                            payload_field: fieldPath,
+                            payload_fields: effectivePayloadFields,
+                            output_index: index,
+                            device_type: deviceType,
+                            inverter_type: node.inverterType,
+                            inverter_profile: detection.profile_key,
+                            inverter_profile_label: detection.profile_label,
+                            manufacturer: detection.manufacturer,
+                            family: detection.family,
+                            phase_mode: detection.phase_mode,
+                            mppt_count: detection.mppt_count,
+                            detection_source: detection.detection_source,
+                            optimized_read: readResult.mode === "optimized",
+                            summary_fragment: summary
+                        };
+                    });
+
+                    if (debugMessage) {
+                        outputMessages[primaryOutputCount] = debugMessage;
+                    }
+
+                    node.send(outputMessages);
+
+                }
+
+            } catch (e) {
+
+                node.status({
+                    fill: "red",
+                    shape: "ring",
+                    text: "error"
+                });
+
+                setNodeRuntimeState(node.id, {
+                    status: "error",
+                    node_id: node.id,
+                    ip: node.host,
+                    unit_id: node.unitId,
+                    payload_field: node.multiInverter
+                        ? (
+                            node.multiInverterUseSelectedFields
+                                ? (normalizePayloadFields(node.payloadFields).filter(function (field) { return field !== "full"; })[0] || "summary.ac.power_w")
+                                : "summary.ac.power_w"
+                        )
+                        : (
+                            node.influxDb
+                                ? (normalizePayloadFields(node.payloadFields)[0] || "full")
+                                : node.payloadField
+                        ),
+                    payload_fields: node.multiInverter
+                        ? (
+                            node.multiInverterUseSelectedFields
+                                ? (function () {
+                                    const selected = normalizePayloadFields(node.payloadFields).filter(function (field) {
+                                        return field !== "full";
+                                    });
+                                    return selected.length ? selected : ["summary.ac.power_w"];
+                                })()
+                                : ["summary.ac.power_w"]
+                        )
+                        : (
+                            node.influxDb
+                                ? normalizePayloadFields(node.payloadFields)
+                                : node.payloadFields
+                        ),
+                    error: e.message || String(e)
+                });
+
+                if (node.outputs > 1) {
+                    const errorOutputs = new Array(node.outputs).fill(null);
+                    errorOutputs[0] = {
+                        topic: "fronius/error",
+                        payload: {
+                            status: "error",
+                            ip: node.host,
+                            unit_id: node.unitId,
+                            inverter_type: node.inverterType,
+                            error: e.message || String(e),
+                            ts: new Date().toISOString()
+                        }
+                    };
+                    node.send(errorOutputs);
+                } else {
+                    node.send({
+                        topic: "fronius/error",
+                        payload: {
+                            status: "error",
+                            ip: node.host,
+                            unit_id: node.unitId,
+                            inverter_type: node.inverterType,
+                            error: e.message || String(e),
+                            ts: new Date().toISOString()
+                        }
+                    });
+                }
+
+                await resetConnection();
+
+            } finally {
+
+                busy = false;
+
+            }
+
+        }
+
+        async function pollLoop() {
+
+            if (closing) {
+                return;
+            }
+
+            await pollOnce();
+            scheduleNextPoll();
+
+        }
+
+        if (node.influxDb) {
+            registeredInfluxIdentityKey = getInfluxIdentityKey();
+            registerInfluxMeasurement(node.id, registeredInfluxIdentityKey);
+
+            if (hasInfluxMeasurementConflict()) {
+                node.status({
+                    fill: "red",
+                    shape: "ring",
+                    text: "inverter_id+measurement duplicat"
+                });
+                node.error("Fronius InfluxDB: combinatie duplicata Inverter ID + Measurement ('" + getEffectiveInverterId() + "' @ '" + getInfluxMeasurement() + "'). Configureaza un Inverter ID unic pentru acelasi measurement.");
+            }
+        }
+
+        if (node.pollInterval > 0) {
+            pollLoop();
+        }
+
+        node.on("input", function () {
+            pollOnce();
+        });
+
+        node.on("close", async function (done) {
+
+            closing = true;
+
+            try {
+
+                if (timer) {
+                    clearTimeout(timer);
+                }
+
+                if (registeredInfluxIdentityKey) {
+                    unregisterInfluxMeasurement(node.id, registeredInfluxIdentityKey);
+                    registeredInfluxIdentityKey = "";
+                }
+
+                clearNodeRuntimeState(node.id);
+                await closeClient(client);
+
+            } catch (e) {
+                // ignore
+            }
+
+            done();
+
+        });
+
+    
+        });
+    }
+
+    RED.nodes.registerType("fronius-read", FroniusReadNode);
+
+};