@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/fronius-read/fronius-read.html

@@ -0,0 +1,3944 @@
+<script type="text/javascript">
+
+
+    (function () {
+
+
+        const {
+
+            PAYLOAD_OPTION_GROUPS,
+
+            INVERTER_PROFILES,
+
+            buildMpptOptions,
+
+            buildAcOptions,
+
+            resolveProfile
+
+        } = (function () {
+
+
+            const AC_OPTIONS_COMMON = [
+
+                { value: "summary.ac.power_w", label: "Putere AC (W)" },
+
+                { value: "summary.ac.frequency_hz", label: "Frecventa (Hz)" },
+
+                { value: "summary.ac.apparent_power_va", label: "Putere aparenta (VA)" },
+
+                { value: "summary.ac.reactive_power_var", label: "Putere reactiva (var)" }
+
+            ];
+
+
+            const AC_OPTIONS_SINGLE_PHASE = [
+
+                { value: "summary.ac.current_total_a", label: "Curent total (A)" },
+
+                { value: "summary.ac.current_l1_a", label: "Curent L1 (A)" },
+
+                { value: "summary.ac.voltage_l1_v", label: "Tensiune L1 (V)" }
+
+            ];
+
+
+            const AC_OPTIONS_THREE_PHASE = [
+
+                { value: "summary.ac.current_total_a", label: "Curent total (A)" },
+
+                { value: "summary.ac.current_l1_a", label: "Curent L1 (A)" },
+
+                { value: "summary.ac.current_l2_a", label: "Curent L2 (A)" },
+
+                { value: "summary.ac.current_l3_a", label: "Curent L3 (A)" },
+
+                { value: "summary.ac.voltage_ll_ab_v", label: "Tensiune AB (V)" },
+
+                { value: "summary.ac.voltage_ll_bc_v", label: "Tensiune BC (V)" },
+
+                { value: "summary.ac.voltage_ll_ca_v", label: "Tensiune CA (V)" },
+
+                { value: "summary.ac.voltage_l1_v", label: "Tensiune L1 (V)" },
+
+                { value: "summary.ac.voltage_l2_v", label: "Tensiune L2 (V)" },
+
+                { value: "summary.ac.voltage_l3_v", label: "Tensiune L3 (V)" }
+
+            ];
+
+
+            const PAYLOAD_OPTION_GROUPS = {
+
+                meter: [
+
+                    { value: "summary.meter.model_id", label: "Model ID" },
+
+                    { value: "summary.meter.meter_model", label: "Model" },
+
+                    { value: "summary.meter.power_w", label: "Putere activa (W)" },
+
+                    { value: "summary.meter.power_l1_w", label: "Putere L1 (W)" },
+
+                    { value: "summary.meter.power_l2_w", label: "Putere L2 (W)" },
+
+                    { value: "summary.meter.power_l3_w", label: "Putere L3 (W)" },
+
+                    { value: "summary.meter.current_total_a", label: "Curent total (A)" },
+
+                    { value: "summary.meter.current_l1_a", label: "Curent L1 (A)" },
+
+                    { value: "summary.meter.current_l2_a", label: "Curent L2 (A)" },
+
+                    { value: "summary.meter.current_l3_a", label: "Curent L3 (A)" },
+
+                    { value: "summary.meter.voltage_ln_avg_v", label: "Tensiune L-N medie (V)" },
+
+                    { value: "summary.meter.voltage_l1_v", label: "Tensiune L1 (V)" },
+
+                    { value: "summary.meter.voltage_l2_v", label: "Tensiune L2 (V)" },
+
+                    { value: "summary.meter.voltage_l3_v", label: "Tensiune L3 (V)" },
+
+                    { value: "summary.meter.voltage_ll_avg_v", label: "Tensiune L-L medie (V)" },
+
+                    { value: "summary.meter.voltage_ll_ab_v", label: "Tensiune L1-L2 (V)" },
+
+                    { value: "summary.meter.voltage_ll_bc_v", label: "Tensiune L2-L3 (V)" },
+
+                    { value: "summary.meter.voltage_ll_ca_v", label: "Tensiune L3-L1 (V)" },
+
+                    { value: "summary.meter.frequency_hz", label: "Frecventa (Hz)" },
+
+                    { value: "summary.meter.apparent_power_va", label: "Putere aparenta (VA)" },
+
+                    { value: "summary.meter.apparent_power_l1_va", label: "Putere aparenta L1 (VA)" },
+
+                    { value: "summary.meter.apparent_power_l2_va", label: "Putere aparenta L2 (VA)" },
+
+                    { value: "summary.meter.apparent_power_l3_va", label: "Putere aparenta L3 (VA)" },
+
+                    { value: "summary.meter.reactive_power_var", label: "Putere reactiva (var)" },
+
+                    { value: "summary.meter.reactive_power_l1_var", label: "Putere reactiva L1 (var)" },
+
+                    { value: "summary.meter.reactive_power_l2_var", label: "Putere reactiva L2 (var)" },
+
+                    { value: "summary.meter.reactive_power_l3_var", label: "Putere reactiva L3 (var)" },
+
+                    { value: "summary.meter.power_factor", label: "Factor putere" },
+
+                    { value: "summary.meter.power_factor_l1", label: "Factor putere L1" },
+
+                    { value: "summary.meter.power_factor_l2", label: "Factor putere L2" },
+
+                    { value: "summary.meter.power_factor_l3", label: "Factor putere L3" },
+
+                    { value: "summary.meter.energy_import_wh", label: "Energie import (Wh)" },
+
+                    { value: "summary.meter.energy_import_l1_wh", label: "Energie import L1 (Wh)" },
+
+                    { value: "summary.meter.energy_import_l2_wh", label: "Energie import L2 (Wh)" },
+
+                    { value: "summary.meter.energy_import_l3_wh", label: "Energie import L3 (Wh)" },
+
+                    { value: "summary.meter.energy_export_wh", label: "Energie export (Wh)" },
+
+                    { value: "summary.meter.energy_export_l1_wh", label: "Energie export L1 (Wh)" },
+
+                    { value: "summary.meter.energy_export_l2_wh", label: "Energie export L2 (Wh)" },
+
+                    { value: "summary.meter.energy_export_l3_wh", label: "Energie export L3 (Wh)" },
+
+                    { value: "summary.meter.apparent_energy_import_vah", label: "Energie aparenta import (VAh)" },
+
+                    { value: "summary.meter.apparent_energy_export_vah", label: "Energie aparenta export (VAh)" },
+
+                    { value: "summary.meter.reactive_energy_import_q1_varh", label: "Energie reactiva import Q1 (varh)" },
+
+                    { value: "summary.meter.reactive_energy_import_q2_varh", label: "Energie reactiva import Q2 (varh)" },
+
+                    { value: "summary.meter.reactive_energy_export_q3_varh", label: "Energie reactiva export Q3 (varh)" },
+
+                    { value: "summary.meter.reactive_energy_export_q4_varh", label: "Energie reactiva export Q4 (varh)" },
+
+                    { value: "summary.meter.event_flags", label: "Event flags" }
+
+                ],
+
+                dcGeneral: [
+
+                    { value: "summary.dc.dc_total_power_w", label: "Putere DC totala (W)" },
+
+                    { value: "summary.dc.module_count", label: "Numar module/stringuri DC (brut)" },
+
+                    { value: "summary.dc.global_event", label: "Eveniment DC global" }
+
+                ],
+
+                device: [
+
+                    { value: "summary.common.manufacturer", label: "Producator" },
+
+                    { value: "summary.common.model", label: "Model" },
+
+                    { value: "summary.common.options", label: "Optiuni" },
+
+                    { value: "summary.common.version", label: "Versiune" },
+
+                    { value: "summary.common.serial", label: "Serie" },
+
+                    { value: "summary.common.device_address", label: "Adresa device" }
+
+                ]
+
+            };
+
+
+            const INVERTER_PROFILES = {
+
+                auto: {
+
+                    key: "auto",
+
+                    label: "Auto Detect",
+
+                    fallbackMpptCount: 4,
+
+                    fallbackPhaseMode: "unknown",
+
+                    includeAC: true,
+
+                    includeDCGeneral: true,
+
+                    includeDevice: true
+
+                },
+
+                fronius_verto: {
+
+                    key: "fronius_verto",
+
+                    label: "Fronius Verto",
+
+                    fallbackMpptCount: 4,
+
+                    fallbackPhaseMode: "three_phase",
+
+                    includeAC: true,
+
+                    includeDCGeneral: true,
+
+                    includeDevice: true
+
+                },
+
+                fronius_symo: {
+
+                    key: "fronius_symo",
+
+                    label: "Fronius Symo",
+
+                    fallbackMpptCount: 2,
+
+                    fallbackPhaseMode: "three_phase",
+
+                    includeAC: true,
+
+                    includeDCGeneral: true,
+
+                    includeDevice: true
+
+                },
+
+                fronius_primo: {
+
+                    key: "fronius_primo",
+
+                    label: "Fronius Primo",
+
+                    fallbackMpptCount: 2,
+
+                    fallbackPhaseMode: "single_phase",
+
+                    includeAC: true,
+
+                    includeDCGeneral: true,
+
+                    includeDevice: true
+
+                },
+
+                fronius_eco: {
+
+                    key: "fronius_eco",
+
+                    label: "Fronius Eco",
+
+                    fallbackMpptCount: 1,
+
+                    fallbackPhaseMode: "three_phase",
+
+                    includeAC: true,
+
+                    includeDCGeneral: true,
+
+                    includeDevice: true
+
+                },
+
+                fronius_tauro: {
+
+                    key: "fronius_tauro",
+
+                    label: "Fronius Tauro",
+
+                    fallbackMpptCount: 3,
+
+                    fallbackPhaseMode: "three_phase",
+
+                    includeAC: true,
+
+                    includeDCGeneral: true,
+
+                    includeDevice: true
+
+                },
+
+                fronius_tauro_eco: {
+
+                    key: "fronius_tauro_eco",
+
+                    label: "Fronius Tauro Eco",
+
+                    fallbackMpptCount: 1,
+
+                    fallbackPhaseMode: "three_phase",
+
+                    includeAC: true,
+
+                    includeDCGeneral: true,
+
+                    includeDevice: true
+
+                }
+
+            };
+
+
+            function buildMpptOptions(mpptIndex) {
+
+                return [
+
+                    { value: "summary.dc.mppts." + mpptIndex + ".dc_voltage_v", label: "Tensiune (V)" },
+
+                    { value: "summary.dc.mppts." + mpptIndex + ".dc_current_a", label: "Curent (A)" },
+
+                    { value: "summary.dc.mppts." + mpptIndex + ".dc_power_w", label: "Putere (W)" },
+
+                    { value: "summary.dc.mppts." + mpptIndex + ".dc_energy_wh", label: "Energie (Wh)" }
+
+                ];
+
+            }
+
+
+            function buildAcOptions(phaseMode) {
+
+                const common = AC_OPTIONS_COMMON.slice();
+
+
+                if (phaseMode === "single_phase") {
+
+                    return common.concat(AC_OPTIONS_SINGLE_PHASE);
+
+                }
+
+
+                if (phaseMode === "three_phase") {
+
+                    return common.concat(AC_OPTIONS_THREE_PHASE);
+
+                }
+
+
+                const merged = [];
+
+                const seen = new Set();
+
+
+                common
+
+                    .concat(AC_OPTIONS_SINGLE_PHASE)
+
+                    .concat(AC_OPTIONS_THREE_PHASE)
+
+                    .forEach(function (item) {
+
+                        if (!seen.has(item.value)) {
+
+                            seen.add(item.value);
+
+                            merged.push(item);
+
+                        }
+
+                    });
+
+
+                return merged;
+
+            }
+
+
+            function resolveProfile(profileKey, detectedMpptCount, detectedPhaseMode) {
+
+                const profile = INVERTER_PROFILES[profileKey] || INVERTER_PROFILES.auto;
+
+
+                const resolvedMpptCount =
+
+                    Number.isFinite(detectedMpptCount) && detectedMpptCount > 0
+
+                        ? detectedMpptCount
+
+                        : profile.fallbackMpptCount;
+
+
+                const resolvedPhaseMode =
+
+                    detectedPhaseMode && detectedPhaseMode !== "unknown"
+
+                        ? detectedPhaseMode
+
+                        : profile.fallbackPhaseMode;
+
+
+                return Object.assign({}, profile, {
+
+                    resolvedMpptCount: resolvedMpptCount,
+
+                    resolvedPhaseMode: resolvedPhaseMode
+
+                });
+
+            }
+
+
+            return {
+
+                PAYLOAD_OPTION_GROUPS: PAYLOAD_OPTION_GROUPS,
+
+                INVERTER_PROFILES: INVERTER_PROFILES,
+
+                buildMpptOptions: buildMpptOptions,
+
+                buildAcOptions: buildAcOptions,
+
+                resolveProfile: resolveProfile
+
+            };
+
+
+        })();
+
+
+        let detectedMpptCount = null;
+
+        let detectedProfileKey = "auto";
+
+        let detectedPhaseMode = "unknown";
+
+        let detectedDeviceType = "unknown";
+
+        let probeRequestId = 0;
+
+        let lastProbeKey = null;
+
+        let probeInFlight = false;
+
+        let lastGoodProbeInfo = null;
+
+        let payloadSelectionState = ["full"];
+
+        let payloadModeState = "full";
+
+        let multiInverterCustomPayloadEnabledState = false;
+
+        let influxCustomPayloadEnabledState = false;
+
+        let influxCustomPayloadWasSavedState = false;
+
+        let multiAdvancedUnlockedState = false;
+
+        let multiLongPressTimer = null;
+
+        let multiLongPressTriggered = false;
+
+        let multiLongPressStartSelector = null;
+
+        let suppressAdvancedResetOnce = false;
+
+        const MULTI_EXPERT_LONG_PRESS_MS = 5000;
+        const DEFAULT_INFLUX_PAYLOAD_FIELDS = [
+            "summary.ac.power_w",
+            "summary.ac.frequency_hz",
+            "summary.ac.apparent_power_va",
+            "summary.ac.reactive_power_var",
+            "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"
+        ];
+
+
+        function normalizeSelectedValues(value) {
+
+
+            if (Array.isArray(value)) {
+
+                const filtered = value
+
+                    .map(function (v) { return String(v || "").trim(); })
+
+                    .filter(Boolean);
+
+
+                return filtered.length ? filtered : ["full"];
+
+            }
+
+
+            if (typeof value === "string") {
+
+                const trimmed = value.trim();
+
+
+                if (!trimmed) {
+
+                    return ["full"];
+
+                }
+
+
+                if (trimmed[0] === "[") {
+
+                    try {
+
+                        const parsed = JSON.parse(trimmed);
+
+                        if (Array.isArray(parsed)) {
+
+                            return normalizeSelectedValues(parsed);
+
+                        }
+
+                    } catch (e) {
+
+                        // ignore
+
+                    }
+
+                }
+
+
+                return [trimmed];
+
+            }
+
+
+            return ["full"];
+
+        }
+
+
+        function dedupeSelectedValues(values) {
+
+            return Array.from(new Set(normalizeSelectedValues(values)));
+
+        }
+
+
+        function normalizePayloadMode(mode) {
+
+            return mode === "selected" ? "selected" : "full";
+
+        }
+
+
+        function inferPayloadModeFromSelection(values) {
+
+            const normalized = dedupeSelectedValues(values);
+
+            return normalized.includes("full") ? "full" : "selected";
+
+        }
+
+
+        function sanitizeSelectedValues(values, previousValues, allowEmpty) {
+
+
+            const normalized = dedupeSelectedValues(values);
+
+            const previous = dedupeSelectedValues(previousValues || []);
+
+
+            if (normalized.includes("full") && normalized.length > 1) {
+
+                if (!previous.includes("full")) {
+
+                    return normalized.filter(function (v) {
+
+                        return v !== "full";
+
+                    });
+
+                }
+
+                return ["full"];
+
+            }
+
+
+            return normalized.length ? normalized : (allowEmpty ? [] : ["full"]);
+
+        }
+
+
+        function applyExclusiveSelectionRule(selected, changedValue, checked) {
+
+            const unique = Array.from(new Set((selected || []).filter(Boolean)));
+
+
+            if (changedValue === "full") {
+
+                if (checked) {
+
+                    return ["full"];
+
+                }
+
+                return unique.length ? unique.filter(function (v) { return v !== "full"; }) : ["full"];
+
+            }
+
+
+            if (checked) {
+
+                return unique.filter(function (v) {
+
+                    return v !== "full";
+
+                });
+
+            }
+
+
+            const withoutEmpty = unique.filter(Boolean);
+
+            return withoutEmpty.length ? withoutEmpty : ["full"];
+
+        }
+
+
+        function getPayloadLabel(path) {
+
+
+            const labels = {
+
+                "full": "Toate valorile",
+
+
+                "summary.ac.power_w": "Putere AC (W)",
+
+                "summary.ac.frequency_hz": "Frecventa (Hz)",
+
+                "summary.ac.apparent_power_va": "Putere aparenta (VA)",
+
+                "summary.ac.reactive_power_var": "Putere reactiva (var)",
+
+                "summary.ac.current_total_a": "Curent total (A)",
+
+                "summary.ac.current_l1_a": "Curent L1 (A)",
+
+                "summary.ac.current_l2_a": "Curent L2 (A)",
+
+                "summary.ac.current_l3_a": "Curent L3 (A)",
+
+                "summary.ac.voltage_ll_ab_v": "Tensiune AB (V)",
+
+                "summary.ac.voltage_ll_bc_v": "Tensiune BC (V)",
+
+                "summary.ac.voltage_ll_ca_v": "Tensiune CA (V)",
+
+                "summary.ac.voltage_l1_v": "Tensiune L1 (V)",
+
+                "summary.ac.voltage_l2_v": "Tensiune L2 (V)",
+
+                "summary.ac.voltage_l3_v": "Tensiune L3 (V)",
+
+                "summary.meter.model_id": "Model ID",
+
+                "summary.meter.meter_model": "Model",
+
+                "summary.meter.power_w": "Putere activa (W)",
+
+                "summary.meter.power_l1_w": "Putere L1 (W)",
+
+                "summary.meter.power_l2_w": "Putere L2 (W)",
+
+                "summary.meter.power_l3_w": "Putere L3 (W)",
+
+                "summary.meter.current_total_a": "Curent total (A)",
+
+                "summary.meter.current_l1_a": "Curent L1 (A)",
+
+                "summary.meter.current_l2_a": "Curent L2 (A)",
+
+                "summary.meter.current_l3_a": "Curent L3 (A)",
+
+                "summary.meter.voltage_ln_avg_v": "Tensiune L-N medie (V)",
+
+                "summary.meter.voltage_l1_v": "Tensiune L1 (V)",
+
+                "summary.meter.voltage_l2_v": "Tensiune L2 (V)",
+
+                "summary.meter.voltage_l3_v": "Tensiune L3 (V)",
+
+                "summary.meter.voltage_ll_avg_v": "Tensiune L-L medie (V)",
+
+                "summary.meter.voltage_ll_ab_v": "Tensiune L1-L2 (V)",
+
+                "summary.meter.voltage_ll_bc_v": "Tensiune L2-L3 (V)",
+
+                "summary.meter.voltage_ll_ca_v": "Tensiune L3-L1 (V)",
+
+                "summary.meter.frequency_hz": "Frecventa (Hz)",
+
+                "summary.meter.apparent_power_va": "Putere aparenta (VA)",
+
+                "summary.meter.apparent_power_l1_va": "Putere aparenta L1 (VA)",
+
+                "summary.meter.apparent_power_l2_va": "Putere aparenta L2 (VA)",
+
+                "summary.meter.apparent_power_l3_va": "Putere aparenta L3 (VA)",
+
+                "summary.meter.reactive_power_var": "Putere reactiva (var)",
+
+                "summary.meter.reactive_power_l1_var": "Putere reactiva L1 (var)",
+
+                "summary.meter.reactive_power_l2_var": "Putere reactiva L2 (var)",
+
+                "summary.meter.reactive_power_l3_var": "Putere reactiva L3 (var)",
+
+                "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 (Wh)",
+
+                "summary.meter.energy_import_l1_wh": "Energie import L1 (Wh)",
+
+                "summary.meter.energy_import_l2_wh": "Energie import L2 (Wh)",
+
+                "summary.meter.energy_import_l3_wh": "Energie import L3 (Wh)",
+
+                "summary.meter.energy_export_wh": "Energie export (Wh)",
+
+                "summary.meter.energy_export_l1_wh": "Energie export L1 (Wh)",
+
+                "summary.meter.energy_export_l2_wh": "Energie export L2 (Wh)",
+
+                "summary.meter.energy_export_l3_wh": "Energie export L3 (Wh)",
+
+                "summary.meter.apparent_energy_import_vah": "Energie aparenta import (VAh)",
+
+                "summary.meter.apparent_energy_export_vah": "Energie aparenta export (VAh)",
+
+                "summary.meter.reactive_energy_import_q1_varh": "Energie reactiva import Q1 (varh)",
+
+                "summary.meter.reactive_energy_import_q2_varh": "Energie reactiva import Q2 (varh)",
+
+                "summary.meter.reactive_energy_export_q3_varh": "Energie reactiva export Q3 (varh)",
+
+                "summary.meter.reactive_energy_export_q4_varh": "Energie reactiva export Q4 (varh)",
+
+                "summary.meter.event_flags": "Event flags",
+
+
+                "summary.dc.dc_total_power_w": "Putere DC totala (W)",
+
+                "summary.dc.module_count": "Numar module/stringuri DC (brut)",
+
+                "summary.dc.global_event": "Eveniment DC global",
+
+
+                "summary.common.manufacturer": "Producator",
+
+                "summary.common.model": "Model",
+
+                "summary.common.options": "Optiuni",
+
+                "summary.common.version": "Versiune",
+
+                "summary.common.serial": "Serie",
+
+                "summary.common.device_address": "Adresa device"
+
+            };
+
+
+            const mpptMatch = path.match(/^summary\.dc\.mppts\.(\d+)\.(dc_voltage_v|dc_current_a|dc_power_w|dc_energy_wh)$/);
+
+            if (mpptMatch) {
+
+                const mpptIndex = Number(mpptMatch[1]) + 1;
+
+                const key = mpptMatch[2];
+
+                const suffixMap = {
+
+                    dc_voltage_v: "Tensiune (V)",
+
+                    dc_current_a: "Curent (A)",
+
+                    dc_power_w: "Putere (W)",
+
+                    dc_energy_wh: "Energie (Wh)"
+
+                };
+
+                return "MPPT" + mpptIndex + " " + suffixMap[key];
+
+            }
+
+
+            return labels[path] || path;
+
+        }
+
+
+        function hasValidDetection(profileKey, phaseMode, mpptCount) {
+
+            return (
+
+                profileKey &&
+
+                profileKey !== "auto" &&
+
+                phaseMode &&
+
+                phaseMode !== "unknown" &&
+
+                Number.isFinite(mpptCount) &&
+
+                mpptCount > 0
+
+            );
+
+        }
+
+
+        function computeOutputsCount(selectedValues, isMulti, isDebug) {
+
+
+            const base = isMulti
+
+                ? 1
+
+                : (function () {
+
+                    const normalized = dedupeSelectedValues(selectedValues);
+
+
+                    if (normalized.includes("full")) {
+
+                        return 1;
+
+                    }
+
+
+                    return Math.max(1, normalized.length);
+
+                })();
+
+
+            return base + (isDebug ? 1 : 0);
+
+        }
+
+
+        function isCompactIntegrationEnabled() {
+
+            return $("#node-input-multiInverter").is(":checked") ||
+                $("#node-input-controlExport").is(":checked") ||
+                $("#node-input-multiGrid").is(":checked");
+
+        }
+
+        function isInfluxIntegrationEnabled() {
+
+            return $("#node-input-influxDb").is(":checked");
+
+        }
+
+        function isScadaIntegrationEnabled() {
+
+            return $("#node-input-scadaAggregator").is(":checked");
+
+        }
+
+        function isSmartMeterDetected() {
+
+            return detectedDeviceType === "smart_meter";
+
+        }
+
+        function syncDetectedDeviceLabels() {
+
+            const isMeter = isSmartMeterDetected();
+
+            $("label[for='node-input-inverterId']").html(
+                '<i class="fa fa-id-badge"></i> ' + (isMeter ? "Meter ID" : "Inverter ID")
+            );
+
+            $("#node-input-inverterId").attr("placeholder", isMeter ? "meter1" : "inv1");
+            $("#node-input-influxMeasurement").attr(
+                "placeholder",
+                isMeter ? "Fronius Smart Meter" : "Fronius Inverter 1"
+            );
+
+        }
+
+        function enforceSmartMeterIntegrationAvailability() {
+
+            const blocked = isSmartMeterDetected();
+            const $multi = $("#node-input-multiInverter");
+            const $control = $("#node-input-controlExport");
+            const $multiGrid = $("#node-input-multiGrid");
+            const title = blocked
+                ? "Inactiv pentru Fronius Smart Meter IP. Foloseste payload normal, Multi-grid sau InfluxDB."
+                : "";
+
+            if (blocked) {
+                $multi.prop("checked", false);
+                $control.prop("checked", false);
+            }
+
+            $multi.prop("disabled", blocked).attr("title", title);
+            $control.prop("disabled", blocked).attr("title", title);
+            $multiGrid
+                .prop("disabled", !blocked)
+                .attr("title", blocked ? "" : "Disponibil doar pentru Fronius Smart Meter IP.");
+
+            if (detectedDeviceType === "inverter") {
+                $multiGrid.prop("checked", false);
+            }
+
+            $("#node-fronius-read-smart-meter-integration-note").toggle(blocked);
+            syncDetectedDeviceLabels();
+
+        }
+
+        function getDefaultCompactField() {
+
+            return "summary.ac.power_w";
+
+        }
+
+        function isSingleOutputIntegrationEnabled() {
+
+            return isCompactIntegrationEnabled() || isInfluxIntegrationEnabled() || isScadaIntegrationEnabled();
+
+        }
+
+
+        function updateOutputsPreview(selectedValues) {
+
+            const isFullMode = normalizePayloadMode($("#node-input-payloadMode").val()) === "full";
+
+            const values = isFullMode ? ["full"] : selectedValues;
+
+            const outputs = computeOutputsCount(
+
+                values,
+
+                isSingleOutputIntegrationEnabled(),
+
+                $("#node-input-debugMode").is(":checked")
+
+            );
+
+
+            $("#node-fronius-read-outputs-info").text(String(outputs));
+
+        }
+
+
+        function updatePayloadSummary(values) {
+
+
+            const normalized = sanitizeSelectedValues(values, []);
+
+
+            let text = "Toate valorile";
+
+
+            if (!normalized.includes("full")) {
+
+                if (normalized.length === 1) {
+
+                    text = getPayloadLabel(normalized[0]);
+
+                } else {
+
+                    text = normalized.length + " valori selectate";
+
+                }
+
+            }
+
+
+            $("#node-fronius-read-payload-summary").text(text);
+
+        }
+
+
+        function persistPayloadSelection(values, allowEmpty) {
+
+            payloadSelectionState = sanitizeSelectedValues(values, payloadSelectionState, !!allowEmpty);
+
+            $("#node-input-payloadFields").val(JSON.stringify(payloadSelectionState));
+
+            updatePayloadSummary(payloadSelectionState);
+
+            updateOutputsPreview(payloadSelectionState);
+
+        }
+
+
+        function getNonFullSelections(values) {
+
+            return dedupeSelectedValues(values).filter(function (value) {
+
+                return value !== "full";
+
+            });
+
+        }
+
+
+        function pickFirstSelectableField() {
+
+            const $first = $("#node-fronius-read-field-list-container .pr-field-checkbox").first();
+
+            return $first.length ? String($first.attr("data-value") || "").trim() : "";
+
+        }
+
+        function getAllSelectableFields() {
+
+            const values = [];
+
+            $("#node-fronius-read-field-list-container .pr-field-checkbox").each(function () {
+                const value = String($(this).attr("data-value") || "").trim();
+                if (value) {
+                    values.push(value);
+                }
+            });
+
+            return dedupeSelectedValues(values).filter(function (value) {
+                return value !== "full";
+            });
+
+        }
+
+        function getDefaultInfluxFields() {
+
+            const selectable = getAllSelectableFields();
+
+            if (!selectable.length) {
+                return detectedDeviceType === "smart_meter"
+                    ? DEFAULT_METER_INFLUX_PAYLOAD_FIELDS.slice()
+                    : DEFAULT_INFLUX_PAYLOAD_FIELDS.slice();
+            }
+
+            const selectableSet = new Set(selectable);
+            const defaultCandidates = detectedDeviceType === "smart_meter"
+                ? DEFAULT_METER_INFLUX_PAYLOAD_FIELDS
+                : DEFAULT_INFLUX_PAYLOAD_FIELDS;
+            const defaults = defaultCandidates.filter(function (field) {
+                return selectableSet.has(field);
+            });
+
+            if (defaults.length) {
+                return defaults;
+            }
+
+            return [selectable[0]];
+
+        }
+
+        function applyFieldCheckboxSelection(values) {
+
+            const selectedSet = new Set(dedupeSelectedValues(values));
+
+            $("#node-fronius-read-field-list-container .pr-field-checkbox").each(function () {
+                const value = String($(this).attr("data-value") || "").trim();
+                $(this).prop("checked", !!value && selectedSet.has(value));
+            });
+
+        }
+
+
+        function syncPayloadModeUi() {
+
+            const mode = normalizePayloadMode($("#node-input-payloadMode").val());
+
+            payloadModeState = mode;
+
+
+            const isSelectedMode = mode === "selected";
+
+            const compactMode = isCompactIntegrationEnabled();
+            const influxMode = isInfluxIntegrationEnabled();
+            const integrationMode = compactMode || influxMode;
+            const customSelectionEnabled = compactMode
+                ? multiInverterCustomPayloadEnabledState
+                : influxMode
+                    ? influxCustomPayloadEnabledState
+                    : true;
+
+            const canShowSelectionList = isSelectedMode && (!integrationMode || (multiAdvancedUnlockedState && customSelectionEnabled));
+            const showDefaultButton = canShowSelectionList && isInfluxIntegrationEnabled() && !!multiAdvancedUnlockedState;
+
+            $("#row-fronius-read-field-list").toggle(canShowSelectionList);
+            $("#node-fronius-read-default-values").toggle(showDefaultButton);
+
+
+            if (!isSelectedMode) {
+
+                persistPayloadSelection(["full"]);
+
+                return;
+
+            }
+
+
+            const selectedNonFull = getNonFullSelections(payloadSelectionState);
+
+            if (selectedNonFull.length > 0) {
+
+                persistPayloadSelection(selectedNonFull);
+
+                return;
+
+            }
+
+
+            const firstSelectable = pickFirstSelectableField();
+
+            if (firstSelectable) {
+
+                persistPayloadSelection([firstSelectable]);
+
+                return;
+
+            }
+
+
+            persistPayloadSelection(["full"]);
+
+        }
+
+
+        function setPayloadFieldSelectionEnabled(enabled) {
+
+            $("#node-fronius-read-field-list-container .pr-field-checkbox").prop("disabled", !enabled);
+
+            $("#node-fronius-read-select-all, #node-fronius-read-clear-all")
+
+                .toggleClass("disabled", !enabled)
+
+                .attr("aria-disabled", enabled ? "false" : "true");
+
+        }
+
+
+        function getPersistedPayloadSelection(nodeContext) {
+
+            const fromConfig = nodeContext && nodeContext.payloadFields !== undefined
+
+                ? nodeContext.payloadFields
+
+                : (nodeContext && nodeContext.payloadField ? [nodeContext.payloadField] : ["full"]);
+
+
+            return sanitizeSelectedValues(fromConfig, []);
+
+        }
+
+
+        function renderPayloadDropdown(profileKey, selectedValues, phaseMode, mpptCount, deviceType) {
+
+
+            const $container = $("#node-fronius-read-field-list-container");
+
+            const normalized = sanitizeSelectedValues(selectedValues, payloadSelectionState);
+
+
+            $container.empty();
+
+
+            function renderGroup(groupLabel, items) {
+
+                const $group = $('<div class="pr-field-group"></div>');
+
+                const $title = $('<p class="pr-field-group-title"></p>').text(groupLabel);
+
+                const $grid = $('<div class="pr-field-group-grid"></div>');
+
+
+                items.forEach(function (item) {
+
+                    const checkboxId = "fronius-field-" + item.value.replace(/[^a-zA-Z0-9_]/g, "_");
+
+                    const $checkbox = $('<input type="checkbox" class="pr-field-checkbox">')
+
+                        .attr("id", checkboxId)
+
+                        .attr("data-value", item.value)
+
+                        .prop("checked", normalized.includes(item.value));
+
+
+                    const $label = $('<label class="pr-field-item"></label>')
+
+                        .attr("for", checkboxId)
+
+                        .append($checkbox)
+
+                        .append($('<span></span>').text(item.label));
+
+
+                    $grid.append($label);
+
+                });
+
+
+                $group.append($title).append($grid);
+
+                $container.append($group);
+
+            }
+
+
+            if (deviceType === "smart_meter") {
+
+                renderGroup("Smart Meter", PAYLOAD_OPTION_GROUPS.meter);
+
+                renderGroup("Device", PAYLOAD_OPTION_GROUPS.device);
+
+                updatePayloadSummary(normalized);
+
+                persistPayloadSelection(normalized);
+
+                $container.find(".pr-field-checkbox").off(".froniusPayloadCheck").on("change.froniusPayloadCheck", function () {
+                    const selected = [];
+                    $container.find(".pr-field-checkbox:checked").each(function () {
+                        selected.push(String($(this).attr("data-value") || ""));
+                    });
+                    const sanitized = sanitizeSelectedValues(selected, payloadSelectionState);
+                    persistPayloadSelection(sanitized);
+                    $("#node-input-payloadMode").val(inferPayloadModeFromSelection(sanitized));
+                    syncPayloadModeUi();
+                });
+
+                return;
+
+            }
+
+            if (!hasValidDetection(profileKey, phaseMode, mpptCount)) {
+
+                updatePayloadSummary(normalized);
+
+                persistPayloadSelection(normalized);
+
+                $container.append($('<div class="fronius-multiselect-empty"></div>').text("Detectare in curs. Campurile apar dupa identificarea dispozitivului SunSpec."));
+
+                return;
+
+            }
+
+
+            const resolved = resolveProfile(profileKey, mpptCount, phaseMode);
+
+
+            if (resolved.includeAC) {
+
+                renderGroup("AC", buildAcOptions(resolved.resolvedPhaseMode));
+
+            }
+
+
+            if (resolved.includeDCGeneral) {
+
+                renderGroup("DC General", PAYLOAD_OPTION_GROUPS.dcGeneral);
+
+            }
+
+
+            for (let i = 0; i < resolved.resolvedMpptCount; i++) {
+
+                renderGroup("MPPT" + (i + 1), buildMpptOptions(i));
+
+            }
+
+
+            if (resolved.includeDevice) {
+
+                renderGroup("Device", PAYLOAD_OPTION_GROUPS.device);
+
+            }
+
+
+            updatePayloadSummary(normalized);
+
+            persistPayloadSelection(normalized);
+
+
+            $container.find(".pr-field-checkbox").off(".froniusPayloadCheck").on("change.froniusPayloadCheck", function () {
+
+                const selected = [];
+
+
+                $container.find(".pr-field-checkbox:checked").each(function () {
+
+                    selected.push($(this).attr("data-value"));
+
+                });
+
+
+                const sanitized = sanitizeSelectedValues(selected, payloadSelectionState);
+
+
+                $container.find(".pr-field-checkbox").each(function () {
+
+                    const value = $(this).attr("data-value");
+
+                    $(this).prop("checked", sanitized.includes(value));
+
+                });
+
+
+                persistPayloadSelection(sanitized);
+
+                $("#node-input-payloadMode").val(inferPayloadModeFromSelection(sanitized));
+
+                syncPayloadModeUi();
+
+            });
+
+
+            const compactMode = isCompactIntegrationEnabled();
+            const influxMode = isInfluxIntegrationEnabled();
+            const integrationMode = compactMode || influxMode;
+            const customSelectionEnabled = compactMode
+                ? multiInverterCustomPayloadEnabledState
+                : influxMode
+                    ? influxCustomPayloadEnabledState
+                    : true;
+
+            setPayloadFieldSelectionEnabled(!integrationMode || (customSelectionEnabled && multiAdvancedUnlockedState));
+
+        }
+
+
+        function buildPayloadSelect(profileKey, selectedValues, phaseMode, mpptCount, deviceType) {
+
+            renderPayloadDropdown(profileKey, selectedValues, phaseMode, mpptCount, deviceType || detectedDeviceType);
+
+        }
+
+
+        function setProbeInfo(message, color) {
+
+            const $el = $("#node-fronius-read-probe-info");
+
+            $el.text(message);
+
+            $el.css("color", color || "");
+
+        }
+
+
+        function getProbeKey() {
+
+            const host = ($("#node-input-host").val() || "").trim();
+
+            const port = ($("#node-input-port").val() || "").trim();
+
+            const unitId = ($("#node-input-unitId").val() || "").trim();
+
+            return [host, port, unitId].join("|");
+
+        }
+
+
+        function buildProbeMessage(data) {
+
+
+            if (data.device_type === "smart_meter") {
+
+                const meterLabel = data.meter_model || data.model || "";
+
+                return "Detectat: Fronius SmartMeter IP" + (meterLabel ? " (" + meterLabel + ")" : "");
+
+            }
+
+            const labelText =
+
+                data.model ||
+
+                data.inverter_profile_label ||
+
+                "Auto Detect";
+
+
+            const mpptText = Number.isFinite(data.mppt_count) && data.mppt_count > 0
+
+                ? ", " + data.mppt_count + " MPPT"
+
+                : "";
+
+
+            const phaseText =
+
+                data.phase_mode === "single_phase"
+
+                    ? ", monofazic"
+
+                    : data.phase_mode === "three_phase"
+
+                        ? ", trifazic"
+
+                        : "";
+
+
+            return "Detectat: " + labelText + mpptText + phaseText;
+
+        }
+
+
+        function applyProbeData(data, selectedPayloads, probeKey) {
+
+
+            detectedMpptCount = Number.isFinite(data.mppt_count) ? data.mppt_count : null;
+
+            detectedProfileKey = data.inverter_profile || "auto";
+
+            detectedPhaseMode = data.phase_mode || "unknown";
+
+            detectedDeviceType = data.device_type || "unknown";
+
+            enforceSmartMeterIntegrationAvailability();
+
+            lastProbeKey = probeKey;
+
+
+            buildPayloadSelect(
+
+                detectedProfileKey,
+
+                selectedPayloads,
+
+                detectedPhaseMode,
+
+                detectedMpptCount,
+
+                detectedDeviceType
+
+            );
+
+
+            if (detectedDeviceType === "smart_meter" || hasValidDetection(detectedProfileKey, detectedPhaseMode, detectedMpptCount)) {
+
+                const message = buildProbeMessage(data);
+
+                lastGoodProbeInfo = {
+
+                    message: message,
+
+                    color: "green"
+
+                };
+
+                setProbeInfo(message, "green");
+
+            } else {
+
+                setProbeInfo("Detectarea nu este inca disponibila. Payload ramane pe valoarea salvata sau pe 'Toate valorile'.", "#999");
+
+            }
+
+        }
+
+
+        function readCachedState(nodeId, callback) {
+
+
+            if (!nodeId) {
+
+                callback(null);
+
+                return;
+
+            }
+
+
+            $.getJSON("fronius-read/state/" + encodeURIComponent(nodeId))
+
+                .done(function (data) {
+
+
+                    if (data && data.ok && data.state && data.state.status === "ok") {
+
+                        callback(data.state);
+
+                        return;
+
+                    }
+
+
+                    callback(null);
+
+
+                })
+
+                .fail(function () {
+
+                    callback(null);
+
+                });
+
+        }
+
+
+        function runLiveProbe(force, selectedPayloadsOverride) {
+
+
+            const host = ($("#node-input-host").val() || "").trim();
+
+            const port = ($("#node-input-port").val() || "").trim();
+
+            const unitId = ($("#node-input-unitId").val() || "").trim();
+
+            const selectedPayloads = dedupeSelectedValues(
+
+                selectedPayloadsOverride || payloadSelectionState || ["full"]
+
+            );
+
+            const probeKey = getProbeKey();
+
+
+            if (!host || !port || !unitId) {
+
+                detectedMpptCount = null;
+
+                detectedProfileKey = "auto";
+
+                detectedPhaseMode = "unknown";
+
+                lastProbeKey = null;
+
+                buildPayloadSelect(detectedProfileKey, selectedPayloads, detectedPhaseMode, detectedMpptCount, detectedDeviceType);
+
+                setProbeInfo("Completeaza IP / Port / Unit ID pentru detectare automata SunSpec.", "#999");
+
+                return;
+
+            }
+
+
+            if (!force && probeKey === lastProbeKey) {
+
+                if (lastGoodProbeInfo) {
+
+                    setProbeInfo(lastGoodProbeInfo.message, lastGoodProbeInfo.color);
+
+                }
+
+                return;
+
+            }
+
+
+            if (probeInFlight) {
+
+                return;
+
+            }
+
+
+            probeInFlight = true;
+
+            const requestId = ++probeRequestId;
+
+
+            if (lastGoodProbeInfo) {
+
+                setProbeInfo(lastGoodProbeInfo.message, lastGoodProbeInfo.color);
+
+            } else {
+
+                setProbeInfo("Detectare Fronius in curs...", "#999");
+
+            }
+
+
+            $.getJSON("fronius-read/probe", {
+
+                host: host,
+
+                port: port,
+
+                unitId: unitId
+
+            })
+
+            .done(function (data) {
+
+
+                if (requestId !== probeRequestId) {
+
+                    return;
+
+                }
+
+
+                if (data && data.ok) {
+
+                    applyProbeData(data, selectedPayloads, probeKey);
+
+                    enforceMultiInverterPayload();
+
+                } else if (lastGoodProbeInfo) {
+
+                    setProbeInfo(lastGoodProbeInfo.message, lastGoodProbeInfo.color);
+
+                } else {
+
+                    detectedMpptCount = null;
+
+                    detectedProfileKey = "auto";
+
+                    detectedPhaseMode = "unknown";
+                    detectedDeviceType = "unknown";
+                    enforceSmartMeterIntegrationAvailability();
+
+                    buildPayloadSelect("auto", selectedPayloads, "unknown", null);
+
+                    setProbeInfo("Detectarea automata a esuat. Payload ramane pe valoarea salvata sau pe 'Toate valorile'.", "#c77d00");
+
+                }
+
+
+            })
+
+            .fail(function () {
+
+
+                if (requestId !== probeRequestId) {
+
+                    return;
+
+                }
+
+
+                if (lastGoodProbeInfo) {
+
+                    setProbeInfo(lastGoodProbeInfo.message, lastGoodProbeInfo.color);
+
+                } else {
+
+                    detectedMpptCount = null;
+
+                    detectedProfileKey = "auto";
+
+                    detectedPhaseMode = "unknown";
+                    detectedDeviceType = "unknown";
+                    enforceSmartMeterIntegrationAvailability();
+
+                    buildPayloadSelect("auto", selectedPayloads, "unknown", null);
+
+                    setProbeInfo("Detectarea automata a esuat. Payload ramane pe valoarea salvata sau pe 'Toate valorile'.", "#c77d00");
+
+                }
+
+
+            })
+
+            .always(function () {
+
+                if (requestId === probeRequestId) {
+
+                    probeInFlight = false;
+
+                }
+
+            });
+
+
+        }
+
+
+        function enforceMultiInverterPayload() {
+
+
+            const isMulti = $("#node-input-multiInverter").is(":checked");
+
+            const isControlExport = $("#node-input-controlExport").is(":checked");
+            const isMultiGrid = $("#node-input-multiGrid").is(":checked");
+            const isInflux = $("#node-input-influxDb").is(":checked");
+
+            const isCompact = isMulti || isControlExport || isMultiGrid;
+
+            const $note = $("#node-fronius-read-multi-note");
+
+            const $mode = $("#node-input-payloadMode");
+
+            const useCustomSelection = isCompact && multiInverterCustomPayloadEnabledState;
+
+
+            if (isInflux) {
+
+                const defaultInfluxFields = getDefaultInfluxFields();
+                let effectiveInfluxFields;
+                if (influxCustomPayloadEnabledState) {
+                    const selected = getNonFullSelections(payloadSelectionState);
+                    if (selected.length > 0) {
+                        effectiveInfluxFields = selected;
+                    } else {
+                        effectiveInfluxFields = defaultInfluxFields;
+                    }
+                    persistPayloadSelection(effectiveInfluxFields);
+                    setPayloadFieldSelectionEnabled(!!multiAdvancedUnlockedState);
+                    $note.find(".fronius-meta-info").text("In modul InfluxDB poti selecta ce valori sunt trimise din Selected payload.");
+                } else {
+                    effectiveInfluxFields = defaultInfluxFields;
+                    persistPayloadSelection(effectiveInfluxFields);
+                    setPayloadFieldSelectionEnabled(false);
+                    $note.find(".fronius-meta-info").text("In modul InfluxDB se trimit implicit valorile presetate.");
+                }
+                applyFieldCheckboxSelection(effectiveInfluxFields);
+
+                $mode.val("selected");
+                $mode.prop("disabled", true);
+                $note.show();
+
+            } else if (isCompact && !useCustomSelection) {
+
+                const defaultCompactFields = isMultiGrid
+                    ? DEFAULT_MULTI_GRID_PAYLOAD_FIELDS.slice()
+                    : [getDefaultCompactField()];
+                const defaultCompactField = defaultCompactFields[0];
+
+                persistPayloadSelection(defaultCompactFields);
+                applyFieldCheckboxSelection(defaultCompactFields);
+
+                $mode.val("selected");
+
+                $mode.prop("disabled", true);
+
+                setPayloadFieldSelectionEnabled(false);
+
+                $note.show();
+
+                $note.find(".fronius-meta-info").text(
+
+                    isMultiGrid
+                        ? "In modul Multi-grid se folosesc automat puterile totala si pe faze."
+                        : isControlExport && !isMulti
+
+                        ? (defaultCompactField === "summary.meter.power_w"
+                            ? "In modul control-export se foloseste automat Putere activa (W)."
+                            : "In modul control-export se foloseste automat Putere AC (W).")
+
+                        : "In modul multi-inverter se foloseste automat Putere AC (W)."
+
+                );
+
+            } else if (isCompact && useCustomSelection) {
+
+                const selected = getNonFullSelections(payloadSelectionState);
+
+                if (selected.length > 0) {
+
+                    persistPayloadSelection(selected);
+
+                } else {
+
+                    const fallbackFields = isMultiGrid
+                        ? DEFAULT_MULTI_GRID_PAYLOAD_FIELDS.slice()
+                        : [getDefaultCompactField()];
+                    persistPayloadSelection(fallbackFields);
+                    applyFieldCheckboxSelection(fallbackFields);
+
+                }
+
+                $mode.val("selected");
+
+                $mode.prop("disabled", true);
+
+                setPayloadFieldSelectionEnabled(!!multiAdvancedUnlockedState);
+
+                $note.show();
+
+                $note.find(".fronius-meta-info").text(
+
+                    "Selectia custom este activa pentru integrarea compacta."
+
+                );
+
+            } else {
+
+                $mode.prop("disabled", false);
+
+                setPayloadFieldSelectionEnabled(true);
+
+                $note.hide();
+
+                persistPayloadSelection(payloadSelectionState);
+
+            }
+
+        }
+
+
+        function syncMultiInverterExpertUi() {
+
+            // no visible expert controls in UI
+
+        }
+
+
+        function clearMultiLongPressTimer() {
+
+            if (multiLongPressTimer) {
+
+                clearTimeout(multiLongPressTimer);
+
+                multiLongPressTimer = null;
+
+            }
+
+        }
+
+
+        function unlockAdvancedSelection(selector) {
+
+            multiAdvancedUnlockedState = true;
+
+            if (selector === "#node-input-influxDb") {
+                influxCustomPayloadEnabledState = true;
+            } else {
+                multiInverterCustomPayloadEnabledState = true;
+            }
+
+            enforceMultiInverterPayload();
+
+            syncPayloadModeUi();
+
+        }
+
+
+        function setupMultiInverterLongPress() {
+
+            const $multi = $("#node-input-multiInverter");
+
+            const $controlExport = $("#node-input-controlExport");
+            const $multiGrid = $("#node-input-multiGrid");
+            const $influx = $("#node-input-influxDb");
+
+
+            function startLongPress(selector) {
+
+                if (!selector) {
+
+                    return;
+
+                }
+
+                multiLongPressTriggered = false;
+
+                multiLongPressStartSelector = selector;
+
+                clearMultiLongPressTimer();
+
+                multiLongPressTimer = setTimeout(function () {
+
+                    const $target = $(multiLongPressStartSelector);
+
+                    if ($target.length && $target.is(":checked")) {
+
+                        multiLongPressTriggered = true;
+
+                        unlockAdvancedSelection(multiLongPressStartSelector);
+
+                    }
+
+                }, MULTI_EXPERT_LONG_PRESS_MS);
+
+            }
+
+
+            function stopLongPress() {
+
+                clearMultiLongPressTimer();
+
+            }
+
+
+            $multi
+
+                .off(".froniusMultiLongPress")
+
+                .on("mousedown.froniusMultiLongPress touchstart.froniusMultiLongPress", function () {
+
+                    startLongPress("#node-input-multiInverter");
+
+                })
+
+                .on("mouseup.froniusMultiLongPress mouseleave.froniusMultiLongPress touchend.froniusMultiLongPress touchcancel.froniusMultiLongPress", function () {
+
+                    stopLongPress();
+
+                })
+
+                .on("click.froniusMultiLongPress", function (evt) {
+
+                    if (!multiLongPressTriggered) {
+
+                        return;
+
+                    }
+
+                    evt.preventDefault();
+
+                    evt.stopImmediatePropagation();
+
+                    suppressAdvancedResetOnce = true;
+
+                    $multi.prop("checked", true).trigger("change");
+
+                    multiLongPressTriggered = false;
+
+                });
+
+
+            $controlExport
+
+                .off(".froniusControlLongPress")
+
+                .on("mousedown.froniusControlLongPress touchstart.froniusControlLongPress", function () {
+
+                    startLongPress("#node-input-controlExport");
+
+                })
+
+                .on("mouseup.froniusControlLongPress mouseleave.froniusControlLongPress touchend.froniusControlLongPress touchcancel.froniusControlLongPress", function () {
+
+                    stopLongPress();
+
+                })
+
+                .on("click.froniusControlLongPress", function (evt) {
+
+                    if (!multiLongPressTriggered) {
+
+                        return;
+
+                    }
+
+                    evt.preventDefault();
+
+                    evt.stopImmediatePropagation();
+
+                    suppressAdvancedResetOnce = true;
+
+                    $controlExport.prop("checked", true).trigger("change");
+
+                    multiLongPressTriggered = false;
+
+                });
+
+            $influx
+                .off(".froniusInfluxLongPress")
+                .on("mousedown.froniusInfluxLongPress touchstart.froniusInfluxLongPress", function () {
+                    startLongPress("#node-input-influxDb");
+                })
+                .on("mouseup.froniusInfluxLongPress mouseleave.froniusInfluxLongPress touchend.froniusInfluxLongPress touchcancel.froniusInfluxLongPress", function () {
+                    stopLongPress();
+                })
+                .on("click.froniusInfluxLongPress", function (evt) {
+                    if (!multiLongPressTriggered) {
+                        return;
+                    }
+                    evt.preventDefault();
+                    evt.stopImmediatePropagation();
+                    suppressAdvancedResetOnce = true;
+                    $influx.prop("checked", true).trigger("change");
+                    multiLongPressTriggered = false;
+                });
+
+            $multiGrid
+                .off(".froniusMultiGridLongPress")
+                .on("mousedown.froniusMultiGridLongPress touchstart.froniusMultiGridLongPress", function () {
+                    startLongPress("#node-input-multiGrid");
+                })
+                .on("mouseup.froniusMultiGridLongPress mouseleave.froniusMultiGridLongPress touchend.froniusMultiGridLongPress touchcancel.froniusMultiGridLongPress", function () {
+                    stopLongPress();
+                })
+                .on("click.froniusMultiGridLongPress", function (evt) {
+                    if (!multiLongPressTriggered) {
+                        return;
+                    }
+                    evt.preventDefault();
+                    evt.stopImmediatePropagation();
+                    suppressAdvancedResetOnce = true;
+                    $multiGrid.prop("checked", true).trigger("change");
+                    multiLongPressTriggered = false;
+                });
+
+        }
+
+
+        function enforceIntegrationExclusivity(changed) {
+
+            const $multi = $("#node-input-multiInverter");
+
+            const $control = $("#node-input-controlExport");
+
+            const $influx = $("#node-input-influxDb");
+            const $multiGrid = $("#node-input-multiGrid");
+            const $scada = $("#node-input-scadaAggregator");
+
+            if (changed === "scada" && $scada.is(":checked")) {
+                $multi.prop("checked", false);
+                $control.prop("checked", false);
+                $multiGrid.prop("checked", false);
+                $influx.prop("checked", false);
+            }
+
+            if (changed !== "scada" && ($multi.is(":checked") || $control.is(":checked") || $multiGrid.is(":checked") || $influx.is(":checked"))) {
+                $scada.prop("checked", false);
+            }
+
+
+            if (changed === "multi" && $multi.is(":checked")) {
+
+                $control.prop("checked", false);
+
+            }
+
+            if (changed === "control" && $control.is(":checked")) {
+
+                $multi.prop("checked", false);
+
+            }
+
+            if (changed === "influx" && $influx.is(":checked")) {
+                // Pastreaza integrarea principala activa.
+            }
+
+            if ((changed === "multi" || changed === "control") && ($multi.is(":checked") || $control.is(":checked"))) {
+                $multiGrid.prop("checked", false);
+            }
+
+            if (changed === "multiGrid" && $multiGrid.is(":checked")) {
+                $multi.prop("checked", false);
+                $control.prop("checked", false);
+                // Pastreaza InfluxDB ca integrare secundara.
+            }
+
+        }
+
+
+        function toggleMultiInverterFields() {
+
+
+            if (isSingleOutputIntegrationEnabled()) {
+
+                $("#row-inverter-id").show();
+
+            } else {
+
+                $("#row-inverter-id").hide();
+
+            }
+
+
+            syncMultiInverterExpertUi();
+
+            $("#row-influx-measurement,#row-influx-node").toggle(isInfluxIntegrationEnabled());
+
+            enforceMultiInverterPayload();
+
+
+        }
+
+
+        RED.nodes.registerType("fronius-read", {
+
+
+            category: "Atelierul de Tehnologii",
+
+
+            color: "#f59f00",
+
+
+            defaults: {
+            license: { value: "", type: "atelier-license", required: true },
+
+                name: { value: "" },
+
+                host: { value: "", required: true },
+
+                port: { value: 502, required: true, validate: RED.validators.number() },
+
+                unitId: { value: 1, required: true, validate: RED.validators.number() },
+
+                pollInterval: {
+                    value: 5000,
+                    required: true,
+                    validate: function (value) {
+                        const text = String(value || "").trim().toLowerCase();
+                        if (text === "off") return true;
+                        const n = Number(text);
+                        return Number.isFinite(n) && n >= 0;
+                    }
+                },
+
+                inverterType: { value: "auto" },
+
+                payloadMode: { value: "full" },
+
+                payloadField: { value: "full" },
+
+                payloadFields: { value: ["full"] },
+
+                debugMode: { value: false },
+
+                multiInverter: { value: false },
+
+                controlExport: { value: false },
+
+                multiGrid: { value: false },
+
+                scadaAggregator: { value: false },
+
+                influxDb: { value: false },
+
+                influxMeasurement: {
+                    value: "",
+                    validate: function (v) {
+                        const influxChecked = $("#node-input-influxDb").length
+                            ? $("#node-input-influxDb").is(":checked")
+                            : !!this.influxDb;
+
+                        return !influxChecked || !!String(v || "").trim();
+                    }
+                },
+                influxNode: { value: "" },
+
+                multiInverterExpertMode: { value: false },
+
+                multiInverterUseSelectedFields: { value: false },
+
+                multiGridUseSelectedFields: { value: false },
+
+                inverterId: {
+
+                    value: "",
+
+                    validate: function (v) {
+
+                        const isMulti = $("#node-input-multiInverter").is(":checked") ||
+                            $("#node-input-controlExport").is(":checked") ||
+                            $("#node-input-multiGrid").is(":checked") ||
+                            $("#node-input-scadaAggregator").is(":checked") ||
+                            $("#node-input-influxDb").is(":checked");
+
+
+                        if (!isMulti) {
+
+                            return true;
+
+                        }
+
+
+                        return !!String(v || "").trim();
+
+                    }
+
+                }
+
+            },
+
+
+            inputs: 0,
+
+
+            outputs: 1,
+
+
+            icon: "font-awesome/fa-sun-o",
+
+
+            label: function () {
+
+                const baseLabel = this.name || this.host || "fronius-read";
+
+
+                if ((this.multiInverter || this.controlExport || this.multiGrid || this.scadaAggregator || this.influxDb) && this.inverterId) {
+
+                    const suffix = " [" + this.inverterId + "]";
+
+                    if (baseLabel.indexOf(suffix) !== -1) {
+
+                        return baseLabel;
+
+                    }
+
+                    return baseLabel + suffix;
+
+                }
+
+
+                return baseLabel;
+
+            },
+
+
+            oneditprepare: function () {
+
+
+                const node = this;
+                const influxSelect = $("#node-input-influxNode").empty().append($("<option></option>").val("").text("Selecteaza adt-influxdb"));
+                RED.nodes.eachNode(function (candidate) {
+                    if (candidate.type === "adt-influxdb") influxSelect.append($("<option></option>").val(candidate.id).text(candidate.name || "adt-influxdb"));
+                });
+                influxSelect.val(node.influxNode || "");
+                function syncInputs() {
+                    const text = String($("#node-input-pollInterval").val() || "").trim().toLowerCase();
+                    node.inputs = text === "off" || text === "0" ? 1 : 0;
+                }
+                $("#node-input-pollInterval").off(".froniusReadPoll").on("keyup.froniusReadPoll change.froniusReadPoll", syncInputs);
+                syncInputs();
+
+                const influxEnabledOnLoad = !!this.influxDb;
+                const compactIntegrationOnLoad = !!(this.multiInverter || this.controlExport || this.multiGrid);
+                const scadaEnabledOnLoad = !!this.scadaAggregator;
+                const compactEnabledOnLoad = !!(compactIntegrationOnLoad || influxEnabledOnLoad || scadaEnabledOnLoad);
+
+                let currentPayloadFields;
+
+                if (influxEnabledOnLoad && !compactIntegrationOnLoad) {
+                    const selectedInflux = getNonFullSelections(getPersistedPayloadSelection(this));
+                    currentPayloadFields = selectedInflux.length ? selectedInflux : DEFAULT_INFLUX_PAYLOAD_FIELDS.slice();
+                } else if (this.multiGrid) {
+                    const selectedMultiGrid = getNonFullSelections(getPersistedPayloadSelection(this));
+                    currentPayloadFields = this.multiGridUseSelectedFields && selectedMultiGrid.length
+                        ? selectedMultiGrid
+                        : DEFAULT_MULTI_GRID_PAYLOAD_FIELDS.slice();
+                } else if (compactEnabledOnLoad) {
+                    currentPayloadFields = (
+                        (this.multiInverterUseSelectedFields || this.multiInverterExpertMode)
+                            ? (function () {
+
+                                const selected = getNonFullSelections(getPersistedPayloadSelection(this));
+
+                                return selected.length ? selected : ["summary.ac.power_w"];
+
+                            }).call(this)
+
+                            : ["summary.ac.power_w"]
+                    );
+                } else {
+                    currentPayloadFields = getPersistedPayloadSelection(this);
+                }
+
+
+                payloadSelectionState = currentPayloadFields.slice();
+
+                payloadModeState = normalizePayloadMode(this.payloadMode || inferPayloadModeFromSelection(currentPayloadFields));
+
+                multiInverterCustomPayloadEnabledState = !!(
+                    compactIntegrationOnLoad &&
+                    (this.multiInverterUseSelectedFields || this.multiGridUseSelectedFields || this.multiInverterExpertMode)
+                );
+
+                influxCustomPayloadWasSavedState = !!(influxEnabledOnLoad && this.multiInverterUseSelectedFields);
+                influxCustomPayloadEnabledState = influxCustomPayloadWasSavedState;
+
+                // Advanced edit unlock is session-only: after each Done/Deploy editor starts locked.
+
+                multiAdvancedUnlockedState = false;
+
+                $("#node-input-payloadFields").val(JSON.stringify(payloadSelectionState));
+
+                $("#node-input-payloadMode").val(payloadModeState);
+
+
+                this.outputs = computeOutputsCount(
+
+                    payloadSelectionState,
+
+                    compactEnabledOnLoad || !!this.influxDb,
+
+                    !!this.debugMode
+
+                );
+
+
+                const nodeId = this.id;
+
+                const probeKey = getProbeKey();
+
+                const savedAutoName = this.host && this.inverterId
+                    ? this.host + " [" + this.inverterId + "]"
+                    : "";
+                let autoNameEnabled = !this.name || this.name === this.host || this.name === savedAutoName || this.name === "fronius-read";
+
+                function buildAutoName() {
+
+                    const host = ($("#node-input-host").val() || "").trim();
+
+                    const inverterId = String($("#node-input-inverterId").val() || "").trim();
+
+                    if (!isSingleOutputIntegrationEnabled() || !inverterId) {
+
+                        return host;
+
+                    }
+
+                    return host ? (host + " [" + inverterId + "]") : inverterId;
+
+                }
+
+
+                lastGoodProbeInfo = null;
+                detectedDeviceType = "unknown";
+                enforceSmartMeterIntegrationAvailability();
+
+                buildPayloadSelect("auto", currentPayloadFields, "unknown", null);
+
+                setProbeInfo("Detectarea nu este inca disponibila. Payload ramane pe valoarea salvata sau pe 'Toate valorile'.", "#999");
+
+
+                if (!$("#node-input-name").val().trim()) {
+
+                    const autoName = buildAutoName();
+
+                    if (autoName) {
+
+                        $("#node-input-name").val(autoName);
+
+                    }
+
+                }
+
+
+                $("#node-input-host")
+
+                    .off(".froniusAutoName")
+
+                    .on("input.froniusAutoName change.froniusAutoName", function () {
+
+                        autoNameEnabled = true;
+                        $("#node-input-name").val(buildAutoName());
+
+                    });
+
+
+                $("#node-input-inverterId")
+
+                    .off(".froniusAutoName")
+
+                    .on("input.froniusAutoName change.froniusAutoName", function () {
+
+                        if (autoNameEnabled) {
+                            $("#node-input-name").val(buildAutoName());
+                        }
+
+                    });
+
+                $("#node-input-name")
+                    .off(".froniusAutoName")
+                    .on("input.froniusAutoName", function () {
+                        const value = String($(this).val() || "").trim();
+                        autoNameEnabled = !value || value === buildAutoName();
+                    });
+
+
+                $("#node-input-payloadMode")
+
+                    .off(".froniusPayloadMode")
+
+                    .on("change.froniusPayloadMode", function () {
+
+                        syncPayloadModeUi();
+
+                    });
+
+
+                $("#node-fronius-read-select-all")
+
+                    .off(".froniusToolbar")
+
+                    .on("click.froniusToolbar", function (evt) {
+
+                        evt.preventDefault();
+
+                        if ($("#node-fronius-read-select-all").hasClass("disabled")) {
+
+                            return;
+
+                        }
+
+                        const selected = [];
+
+                        $("#node-fronius-read-field-list-container .pr-field-checkbox").each(function () {
+
+                            const value = String($(this).attr("data-value") || "").trim();
+
+                            if (value) {
+
+                                $(this).prop("checked", true);
+
+                                selected.push(value);
+
+                            }
+
+                        });
+
+                        if (selected.length > 0) {
+
+                            persistPayloadSelection(selected);
+                            applyFieldCheckboxSelection(selected);
+
+                        }
+
+                        $("#node-input-payloadMode").val("selected");
+
+                        syncPayloadModeUi();
+
+                    });
+
+
+                $("#node-fronius-read-clear-all")
+
+                    .off(".froniusToolbar")
+
+                    .on("click.froniusToolbar", function (evt) {
+
+                        evt.preventDefault();
+
+                        if ($("#node-fronius-read-clear-all").hasClass("disabled")) {
+
+                            return;
+
+                        }
+
+                        if (isInfluxIntegrationEnabled() && multiAdvancedUnlockedState) {
+                            $("#node-fronius-read-field-list-container .pr-field-checkbox").prop("checked", false);
+                            persistPayloadSelection([], true);
+                            $("#node-input-payloadMode").val("selected");
+                            return;
+                        }
+
+                        const firstSelectable = pickFirstSelectableField();
+
+                        if (firstSelectable) {
+
+                            persistPayloadSelection([firstSelectable]);
+
+                            $("#node-input-payloadMode").val("selected");
+
+                        } else {
+
+                            persistPayloadSelection(["full"]);
+
+                            $("#node-input-payloadMode").val("full");
+
+                        }
+
+                        syncPayloadModeUi();
+
+                    });
+
+                $("#node-fronius-read-default-values")
+
+                    .off(".froniusToolbar")
+
+                    .on("click.froniusToolbar", function (evt) {
+
+                        evt.preventDefault();
+
+                        if (!isInfluxIntegrationEnabled()) {
+                            return;
+                        }
+
+                        persistPayloadSelection(getDefaultInfluxFields());
+                        applyFieldCheckboxSelection(getDefaultInfluxFields());
+                        $("#node-input-payloadMode").val("selected");
+                        syncPayloadModeUi();
+
+                    });
+
+
+                $("#node-input-host, #node-input-port, #node-input-unitId")
+
+                    .off(".froniusProbe")
+
+                    .on("change.froniusProbe", function () {
+
+                        currentPayloadFields = payloadSelectionState.slice();
+
+                        lastProbeKey = null;
+                        detectedDeviceType = "unknown";
+                        enforceSmartMeterIntegrationAvailability();
+
+                        buildPayloadSelect("auto", currentPayloadFields, "unknown", null);
+
+                        runLiveProbe(true, currentPayloadFields);
+
+                    });
+
+
+                $("#node-input-multiInverter")
+
+                    .off(".froniusMulti")
+
+                    .on("change.froniusMulti", () => {
+
+                        enforceIntegrationExclusivity("multi");
+
+                        if (!suppressAdvancedResetOnce) {
+
+                            multiAdvancedUnlockedState = false;
+                            influxCustomPayloadEnabledState = false;
+
+                        }
+
+                        suppressAdvancedResetOnce = false;
+
+                        toggleMultiInverterFields();
+
+                        this.outputs = computeOutputsCount(
+
+                            payloadSelectionState,
+
+                            isSingleOutputIntegrationEnabled(),
+
+                            $("#node-input-debugMode").is(":checked")
+
+                        );
+
+                        $("#node-input-inverterId").trigger("change");
+
+                    });
+
+
+                $("#node-input-controlExport")
+
+                    .off(".froniusControlExport")
+
+                    .on("change.froniusControlExport", () => {
+
+                        enforceIntegrationExclusivity("control");
+
+                        if (!suppressAdvancedResetOnce) {
+
+                            multiAdvancedUnlockedState = false;
+                            influxCustomPayloadEnabledState = false;
+
+                        }
+
+                        suppressAdvancedResetOnce = false;
+
+                        toggleMultiInverterFields();
+
+                        this.outputs = computeOutputsCount(
+
+                            payloadSelectionState,
+
+                            isSingleOutputIntegrationEnabled(),
+
+                            $("#node-input-debugMode").is(":checked")
+
+                        );
+
+                        $("#node-input-inverterId").trigger("change");
+
+                    });
+
+                $("#node-input-multiGrid")
+                    .off(".froniusMultiGrid")
+                    .on("change.froniusMultiGrid", () => {
+
+                        enforceIntegrationExclusivity("multiGrid");
+
+                        if (!suppressAdvancedResetOnce) {
+                            multiAdvancedUnlockedState = false;
+                            multiInverterCustomPayloadEnabledState = false;
+                            influxCustomPayloadEnabledState = false;
+                        }
+
+                        suppressAdvancedResetOnce = false;
+                        toggleMultiInverterFields();
+
+                        this.outputs = computeOutputsCount(
+                            payloadSelectionState,
+                            isSingleOutputIntegrationEnabled(),
+                            $("#node-input-debugMode").is(":checked")
+                        );
+
+                        $("#node-input-inverterId").trigger("change");
+                    });
+
+                $("#node-input-scadaAggregator")
+                    .off(".froniusScada")
+                    .on("change.froniusScada", () => {
+                        enforceIntegrationExclusivity("scada");
+                        toggleMultiInverterFields();
+                        this.outputs = computeOutputsCount(
+                            payloadSelectionState,
+                            isSingleOutputIntegrationEnabled(),
+                            $("#node-input-debugMode").is(":checked")
+                        );
+                        $("#node-input-inverterId").trigger("change");
+                    });
+
+                $("#node-input-influxDb")
+                    .off(".froniusInflux")
+                    .on("change.froniusInflux", () => {
+
+                        enforceIntegrationExclusivity("influx");
+                        if (!suppressAdvancedResetOnce) {
+                            multiAdvancedUnlockedState = false;
+                            influxCustomPayloadEnabledState = false;
+                        }
+                        suppressAdvancedResetOnce = false;
+                        toggleMultiInverterFields();
+
+                        this.outputs = computeOutputsCount(
+                            payloadSelectionState,
+                            isSingleOutputIntegrationEnabled(),
+                            $("#node-input-debugMode").is(":checked")
+                        );
+
+                        $("#node-input-inverterId").trigger("change");
+                    });
+
+
+                if ($("#node-input-multiInverter").is(":checked") && $("#node-input-controlExport").is(":checked")) {
+
+                    enforceIntegrationExclusivity("multi");
+
+                }
+
+                if ($("#node-input-influxDb").is(":checked")) {
+                    enforceIntegrationExclusivity("influx");
+                }
+
+                if ($("#node-input-multiGrid").is(":checked")) {
+                    enforceIntegrationExclusivity("multiGrid");
+                }
+
+
+                $("#node-input-debugMode")
+
+                    .off(".froniusDebug")
+
+                    .on("change.froniusDebug", () => {
+
+                        updateOutputsPreview(payloadSelectionState);
+
+                        this.outputs = computeOutputsCount(
+
+                            payloadSelectionState,
+
+                            isSingleOutputIntegrationEnabled(),
+
+                            $("#node-input-debugMode").is(":checked")
+
+                        );
+
+                    });
+
+
+                toggleMultiInverterFields();
+
+                setupMultiInverterLongPress();
+
+                syncPayloadModeUi();
+
+
+                readCachedState(nodeId, function (state) {
+
+
+                    if (state) {
+
+                        applyProbeData({
+
+                            inverter_profile: state.inverter_profile,
+
+                            inverter_profile_label: state.inverter_profile_label,
+
+                            model: state.summary && state.summary.common ? state.summary.common.model : null,
+
+                            device_type: state.device_type,
+
+                            meter_model: state.summary && state.summary.meter ? state.summary.meter.meter_model : null,
+
+                            phase_mode: state.phase_mode,
+
+                            mppt_count: state.mppt_count
+
+                        }, currentPayloadFields, probeKey);
+
+                        enforceMultiInverterPayload();
+
+                        syncPayloadModeUi();
+
+                    } else {
+
+                        runLiveProbe(true, currentPayloadFields);
+
+                        syncPayloadModeUi();
+
+                    }
+
+
+                });
+
+
+            },
+
+
+            oneditsave: function () {
+
+
+                this.inverterType = "auto";
+                this.influxDb = $("#node-input-influxDb").is(":checked");
+                this.multiGrid = $("#node-input-multiGrid").is(":checked");
+                this.scadaAggregator = $("#node-input-scadaAggregator").is(":checked");
+                if (this.scadaAggregator) {
+                    $("#node-input-multiInverter,#node-input-controlExport,#node-input-multiGrid,#node-input-influxDb").prop("checked", false);
+                    this.multiInverter = false;
+                    this.controlExport = false;
+                    this.multiGrid = false;
+                    this.influxDb = false;
+                    this.payloadMode = "full";
+                    this.payloadFields = ["full"];
+                    this.payloadField = "full";
+                    this.outputs = computeOutputsCount(["full"], true, $("#node-input-debugMode").is(":checked"));
+                }
+                if (isSmartMeterDetected()) {
+                    $("#node-input-multiInverter").prop("checked", false);
+                    $("#node-input-controlExport").prop("checked", false);
+                } else {
+                    $("#node-input-multiGrid").prop("checked", false);
+                    this.multiGrid = false;
+                }
+                this.influxMeasurement = String($("#node-input-influxMeasurement").val() || "").trim();
+                const pollText = String($("#node-input-pollInterval").val() || "").trim().toLowerCase();
+                this.inputs = pollText === "off" || pollText === "0" ? 1 : 0;
+
+
+                if (!$("#node-input-name").val().trim()) {
+
+                    const host = ($("#node-input-host").val() || "").trim();
+
+                    const inverterId = String($("#node-input-inverterId").val() || "").trim();
+
+                    if (isSingleOutputIntegrationEnabled() && inverterId) {
+
+                        $("#node-input-name").val(host ? (host + " [" + inverterId + "]") : inverterId);
+
+                    } else {
+
+                        $("#node-input-name").val(host);
+
+                    }
+
+                }
+
+
+                if (!this.scadaAggregator && (isCompactIntegrationEnabled() || this.influxDb)) {
+
+                    const selected = getNonFullSelections(payloadSelectionState);
+                    const compactIntegrationActive = isCompactIntegrationEnabled();
+                    const useCompactCustomSelection = !!multiInverterCustomPayloadEnabledState;
+                    const useInfluxCustomSelection = !!(influxCustomPayloadEnabledState || influxCustomPayloadWasSavedState);
+
+                    this.multiInverterExpertMode = false;
+
+                    this.payloadMode = "selected";
+                    this.multiInverterUseSelectedFields = compactIntegrationActive ? useCompactCustomSelection : useInfluxCustomSelection;
+                    this.multiGridUseSelectedFields = this.multiGrid && useCompactCustomSelection;
+
+                    if (this.influxDb && !compactIntegrationActive) {
+                        const defaultInfluxFields = getDefaultInfluxFields();
+                        const effectiveInflux = useInfluxCustomSelection
+                            ? (selected.length ? selected : defaultInfluxFields)
+                            : defaultInfluxFields;
+
+                        this.payloadFields = effectiveInflux.slice();
+                        this.payloadField = effectiveInflux[0];
+                    } else {
+                        const defaultCompactFields = this.multiGrid
+                            ? DEFAULT_MULTI_GRID_PAYLOAD_FIELDS.slice()
+                            : [getDefaultCompactField()];
+                        const effectiveCompact = selected.length ? selected : defaultCompactFields;
+                        if (useCompactCustomSelection) {
+                            this.payloadFields = effectiveCompact.slice();
+                            this.payloadField = effectiveCompact[0];
+                        } else {
+                            this.payloadFields = defaultCompactFields.slice();
+                            this.payloadField = defaultCompactFields[0];
+                        }
+
+                    }
+
+
+                    this.outputs = computeOutputsCount(
+
+                        this.payloadFields,
+
+                        true,
+
+                        $("#node-input-debugMode").is(":checked")
+
+                    );
+
+                } else if (!this.scadaAggregator) {
+
+                    this.multiInverterExpertMode = false;
+
+                    this.multiInverterUseSelectedFields = false;
+                    this.multiGridUseSelectedFields = false;
+
+                    const mode = normalizePayloadMode($("#node-input-payloadMode").val());
+
+                    this.payloadMode = mode;
+
+
+                    if (mode === "full") {
+
+                        this.payloadFields = ["full"];
+
+                        this.payloadField = "full";
+
+                        this.outputs = computeOutputsCount(["full"], this.influxDb, $("#node-input-debugMode").is(":checked"));
+
+                    } else {
+
+                        const selected = sanitizeSelectedValues(
+
+                        payloadSelectionState,
+
+                        this.payloadFields || this.payloadField || "full"
+
+                        );
+
+                        const nonFull = getNonFullSelections(selected);
+
+
+                        if (nonFull.length > 0) {
+
+                            this.payloadFields = nonFull.slice();
+
+                            this.payloadField = nonFull[0];
+
+                            this.outputs = computeOutputsCount(nonFull, this.influxDb, $("#node-input-debugMode").is(":checked"));
+
+                        } else {
+
+                            this.payloadFields = ["full"];
+
+                            this.payloadField = "full";
+
+                            this.outputs = computeOutputsCount(["full"], this.influxDb, $("#node-input-debugMode").is(":checked"));
+
+                            this.payloadMode = "full";
+
+                        }
+
+                    }
+
+                }
+
+
+                $("#node-input-payloadFields").val(JSON.stringify(this.payloadFields));
+
+
+                $("#node-input-host, #node-input-port, #node-input-unitId").off(".froniusProbe");
+
+                $("#node-input-multiInverter").off(".froniusMulti");
+
+                $("#node-input-host").off(".froniusAutoName");
+
+                $("#node-input-inverterId").off(".froniusAutoName");
+                $("#node-input-name").off(".froniusAutoName");
+
+                $("#node-input-payloadMode").off(".froniusPayloadMode");
+
+                $("#node-fronius-read-select-all").off(".froniusToolbar");
+
+                $("#node-fronius-read-clear-all").off(".froniusToolbar");
+                $("#node-fronius-read-default-values").off(".froniusToolbar");
+
+                $("#node-input-debugMode").off(".froniusDebug");
+
+                $("#node-input-multiInverter").off(".froniusMultiLongPress");
+
+                $("#node-input-controlExport").off(".froniusControlLongPress");
+
+                $("#node-input-controlExport").off(".froniusControlExport");
+                $("#node-input-multiGrid").off(".froniusMultiGrid");
+                $("#node-input-scadaAggregator").off(".froniusScada");
+                $("#node-input-multiGrid").off(".froniusMultiGridLongPress");
+                $("#node-input-influxDb").off(".froniusInflux");
+                $("#node-input-influxDb").off(".froniusInfluxLongPress");
+
+                clearMultiLongPressTimer();
+
+
+            },
+
+
+            oneditcancel: function () {
+
+
+                $("#node-input-host, #node-input-port, #node-input-unitId").off(".froniusProbe");
+
+                $("#node-input-multiInverter").off(".froniusMulti");
+
+                $("#node-input-host").off(".froniusAutoName");
+
+                $("#node-input-inverterId").off(".froniusAutoName");
+                $("#node-input-name").off(".froniusAutoName");
+
+                $("#node-input-payloadMode").off(".froniusPayloadMode");
+
+                $("#node-fronius-read-select-all").off(".froniusToolbar");
+
+                $("#node-fronius-read-clear-all").off(".froniusToolbar");
+                $("#node-fronius-read-default-values").off(".froniusToolbar");
+
+                $("#node-input-debugMode").off(".froniusDebug");
+
+                $("#node-input-multiInverter").off(".froniusMultiLongPress");
+
+                $("#node-input-controlExport").off(".froniusControlLongPress");
+
+                $("#node-input-controlExport").off(".froniusControlExport");
+                $("#node-input-multiGrid").off(".froniusMultiGrid");
+                $("#node-input-multiGrid").off(".froniusMultiGridLongPress");
+                $("#node-input-influxDb").off(".froniusInflux");
+                $("#node-input-influxDb").off(".froniusInfluxLongPress");
+
+                clearMultiLongPressTimer();
+
+
+            }
+
+
+        });
+
+
+    })();
+
+
+</script>
+
+
+
+<script type="text/html" data-template-name="fronius-read">
+    <div class="form-row"><label for="node-input-license"><i class="fa fa-key"></i> License</label><input type="text" id="node-input-license"></div>
+
+    <div class="fronius-read-editor">
+
+        <div class="pr-section">
+
+            <div class="pr-section-title"><i class="fa fa-plug"></i> Connection</div>
+
+            <p class="pr-section-note">Configuratia de citire SunSpec (Modbus TCP) pentru invertor Fronius sau Fronius Smart Meter IP.</p>
+
+
+            <div class="pr-grid pr-grid-2">
+
+                <div class="form-row">
+
+                    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+
+                    <input type="text" id="node-input-name" placeholder="192.168.0.101">
+
+                </div>
+
+
+                <div class="form-row">
+
+                    <label for="node-input-host"><i class="fa fa-globe"></i> IP</label>
+
+                    <input type="text" id="node-input-host" placeholder="192.168.0.xxx">
+
+                </div>
+
+
+                <div class="form-row">
+
+                    <label for="node-input-port"><i class="fa fa-plug"></i> Port</label>
+
+                    <input type="text" id="node-input-port" placeholder="502">
+
+                </div>
+
+
+                <div class="form-row">
+
+                    <label for="node-input-unitId"><i class="fa fa-hashtag"></i> Unit ID</label>
+
+                    <input type="text" id="node-input-unitId" placeholder="1">
+
+                </div>
+
+
+                <div class="form-row">
+
+                    <label for="node-input-pollInterval"><i class="fa fa-clock-o"></i> Poll</label>
+
+                    <input type="text" id="node-input-pollInterval" placeholder="5000 sau off">
+
+                </div>
+
+
+                <div class="form-row" id="row-inverter-id">
+
+                    <label for="node-input-inverterId"><i class="fa fa-id-badge"></i> Inverter ID</label>
+
+                    <input type="text" id="node-input-inverterId" placeholder="inv1">
+
+                </div>
+
+
+                <div class="form-row pr-span-2 fronius-probe-row">
+
+                    <label><i class="fa fa-search"></i> Detectare</label>
+
+                    <div id="node-fronius-read-probe-info" class="fronius-probe-info">-</div>
+
+                </div>
+
+            </div>
+
+        </div>
+
+
+        <div class="pr-section">
+
+            <div class="pr-section-title"><i class="fa fa-filter"></i> Payload</div>
+
+            <p class="pr-section-note">Alege payload complet sau selecteaza campurile care trebuie emise pe iesiri.</p>
+
+
+            <input type="hidden" id="node-input-inverterType">
+
+            <input type="hidden" id="node-input-payloadFields">
+
+
+            <div class="form-row">
+
+                <label for="node-input-payloadMode"><i class="fa fa-list"></i> Payload mode</label>
+
+                <select id="node-input-payloadMode">
+
+                    <option value="full">Full payload</option>
+
+                    <option value="selected">Selected payload</option>
+
+                </select>
+
+            </div>
+
+
+            <div class="form-row pr-checkbox-row">
+
+                <label for="node-input-multiInverter"><i class="fa fa-sitemap"></i> Multi-inverter</label>
+
+                <input type="checkbox" id="node-input-multiInverter">
+
+                <span class="pr-inline-note">Fixeaza automat payload-ul pe Putere AC (W) pentru integrare in <code>multi-inverter</code>.</span>
+
+            </div>
+
+
+            <div class="form-row pr-checkbox-row">
+
+                <label for="node-input-controlExport"><i class="fa fa-exchange"></i> Control-export</label>
+
+                <input type="checkbox" id="node-input-controlExport">
+
+                <span class="pr-inline-note">Fixeaza automat payload-ul pe Putere AC (W) pentru integrare directa in <code>control-export</code>.</span>
+
+            </div>
+
+            <div class="form-row fronius-meta-row" id="node-fronius-read-smart-meter-integration-note" style="display:none;">
+
+                <label></label>
+
+                <div class="fronius-meta-info">Smart Meter detectat: functiile Multi-inverter si Control-export sunt inactive; Multi-grid este disponibil.</div>
+
+            </div>
+
+            <div class="form-row pr-checkbox-row">
+
+                <label for="node-input-multiGrid"><i class="fa fa-sitemap"></i> Multi-grid</label>
+
+                <input type="checkbox" id="node-input-multiGrid" disabled>
+
+                <span class="pr-inline-note">Trimite un payload compact cu puterile Smart Meter-ului pentru nodul <code>multi-grid</code>.</span>
+
+            </div>
+
+            <div class="form-row pr-checkbox-row">
+
+                <label for="node-input-scadaAggregator"><i class="fa fa-object-group"></i> SCADA aggregator</label>
+
+                <input type="checkbox" id="node-input-scadaAggregator">
+
+                <span class="pr-inline-note">Emite P, Q, U și f normalizate, cu <code>msg.scadaSource</code> și <code>msg.scadaGroup</code>, direct pentru <code>scada-aggregator</code>.</span>
+
+            </div>
+
+            <div class="form-row pr-checkbox-row">
+
+                <label for="node-input-influxDb"><i class="fa fa-database"></i> InfluxDB</label>
+
+                <input type="checkbox" id="node-input-influxDb">
+
+                <span class="pr-inline-note">Grupeaza valorile in <code>msg.influx</code> pentru nodul <code>adt-influxdb</code>.</span>
+
+            </div>
+
+            <div class="form-row" id="row-influx-measurement" style="display:none;">
+
+                <label for="node-input-influxMeasurement"><i class="fa fa-line-chart"></i> Measurement</label>
+
+                <input type="text" id="node-input-influxMeasurement" placeholder="Fronius Inverter 1">
+
+            </div>
+            <div class="form-row" id="row-influx-node" style="display:none;">
+                <label for="node-input-influxNode"><i class="fa fa-plug"></i> Nod InfluxDB</label>
+                <select id="node-input-influxNode"></select>
+            </div>
+
+
+            <div class="form-row pr-checkbox-row">
+
+                <label for="node-input-debugMode"><i class="fa fa-bug"></i> Debug mode</label>
+
+                <input type="checkbox" id="node-input-debugMode">
+
+                <span class="pr-inline-note">Adauga o iesire suplimentara care livreaza mesajul raw citit la fiecare poll.</span>
+
+            </div>
+
+
+            <div class="form-row fronius-meta-row" id="node-fronius-read-multi-note" style="display:none;">
+
+                <label></label>
+
+                <div class="fronius-meta-info">In modul multi-inverter se foloseste automat Putere AC (W).</div>
+
+            </div>
+
+
+            <div id="row-fronius-read-field-list" style="display:none;">
+
+                <div class="pr-toolbar">
+
+                    <a href="#" class="button" id="node-fronius-read-select-all"><i class="fa fa-check-square-o"></i> Select all</a>
+
+                    <a href="#" class="button" id="node-fronius-read-clear-all"><i class="fa fa-square-o"></i> Clear all</a>
+
+                    <a href="#" class="button" id="node-fronius-read-default-values" style="display:none;"><i class="fa fa-undo"></i> Default values</a>
+
+                </div>
+
+
+                <div id="node-fronius-read-field-list-container" class="pr-field-list"></div>
+
+                <div id="node-fronius-read-payload-summary" style="display:none;"></div>
+
+            </div>
+
+
+            <div class="form-row fronius-meta-row">
+
+                <label></label>
+
+                <div class="fronius-meta-info">Iesiri active: <span id="node-fronius-read-outputs-info">1</span></div>
+
+            </div>
+
+        </div>
+
+    </div>
+
+
+</script>
+
+
+<script type="text/html" data-help-name="fronius-read">
+
+
+    <p>
+
+        Nodul <b>fronius-read</b> citeste date dintr-un invertor Fronius sau Fronius Smart Meter IP folosind protocolul <b>SunSpec (Modbus TCP)</b>.
+
+        Este gandit pentru citire periodica, selectie clara de payload si integrare directa cu nodurile de control din pachet.
+
+    </p>
+
+
+    <h3>Cerinte</h3>
+
+    <ul>
+
+        <li>Invertorul trebuie sa fie accesibil in retea prin IP.</li>
+
+        <li>Modbus TCP / SunSpec trebuie sa fie activ pe invertor.</li>
+
+        <li>Portul folosit este, de obicei, <code>502</code>.</li>
+
+    </ul>
+
+
+    <h3>Conexiune</h3>
+
+    <ul>
+
+        <li><b>Name</b> - numele afisat in flow. Daca este gol, nodul foloseste automat IP-ul.</li>
+
+        <li><b>IP</b> - adresa invertorului Fronius, de exemplu <code>192.168.0.101</code>.</li>
+
+        <li><b>Port</b> - portul Modbus TCP; valoarea uzuala este <code>502</code>.</li>
+
+        <li><b>Unit ID</b> - adresa Modbus a invertorului; in cele mai multe instalatii este <code>1</code>.</li>
+
+        <li><b>Poll</b> - intervalul de citire in milisecunde. Valoarea <code>off</code> sau <code>0</code> opreste poll-ul si activeaza intrarea pentru trigger manual.</li>
+
+    </ul>
+
+
+    <h3>Detectare automata</h3>
+
+    <p>
+
+        La deschiderea editorului si in timpul rularii, nodul incearca sa identifice dispozitivul prin SunSpec. Pentru smart meter, valorile sunt expuse in <code>summary.meter.*</code>.
+
+        Detectarea este folosita ca sa afiseze doar campurile relevante pentru echipamentul gasit.
+
+    </p>
+
+    <ul>
+
+        <li><b>Model invertor</b> - de exemplu Fronius Verto, Symo, Primo, Eco sau Tauro.</li>
+
+        <li><b>Numar MPPT</b> - cate trackere DC sunt disponibile pentru selectie.</li>
+
+        <li><b>Tip faza</b> - monofazic sau trifazic, pentru afisarea tensiunilor si curentilor corecti.</li>
+
+    </ul>
+
+
+    <p>
+
+        Daca detectarea nu este inca disponibila, nodul pastreaza selectia salvata sau foloseste payload complet.
+
+    </p>
+
+
+    <h3>Payload</h3>
+
+    <ul>
+
+        <li><b>Full payload</b> - trimite obiectul complet cu status, detectare, sumar SunSpec si modele raw atunci cand sunt citite.</li>
+
+        <li><b>Selected payload</b> - permite alegerea unuia sau mai multor campuri. Pentru mai multe campuri, nodul creeaza cate o iesire principala pentru fiecare valoare selectata.</li>
+
+        <li><b>Select all</b> - selecteaza toate campurile disponibile dupa detectare.</li>
+
+        <li><b>Clear all</b> - deselecteaza campurile selectate; daca nu exista campuri disponibile, revine la payload complet.</li>
+
+    </ul>
+
+
+    <h3>Campuri disponibile</h3>
+
+    <ul>
+
+        <li><b>AC</b> - putere activa, frecventa, putere aparenta, putere reactiva, curenti si tensiuni pe faze.</li>
+
+        <li><b>DC General</b> - putere DC totala, numar brut de module/stringuri si eveniment DC global.</li>
+
+        <li><b>MPPT</b> - tensiune, curent, putere si energie pentru fiecare MPPT detectat.</li>
+
+        <li><b>Device</b> - producator, model, optiuni, versiune, serie si adresa device.</li>
+
+    </ul>
+
+
+    <h3>Iesiri</h3>
+
+    <ul>
+
+        <li>In <b>Full payload</b>, nodul are o iesire principala cu tot obiectul citit.</li>
+
+        <li>In <b>Selected payload</b> cu un singur camp, nodul are o iesire principala cu valoarea selectata.</li>
+
+        <li>In <b>Selected payload</b> cu mai multe campuri, fiecare camp primeste propria iesire, in ordinea selectiei.</li>
+
+        <li>Daca <b>Debug mode</b> este activ, se adauga o iesire suplimentara la final, cu mesajul raw.</li>
+
+    </ul>
+
+
+    <h3>Structura mesajului</h3>
+
+    <ul>
+
+        <li><code>msg.topic</code> contine numele campului selectat sau <code>full</code>.</li>
+
+        <li><code>msg.payload</code> contine valoarea efectiva sau obiectul complet, in functie de modul de payload.</li>
+
+        <li><code>msg.payload_field</code> contine calea interna a campului, de exemplu <code>summary.ac.power_w</code>.</li>
+
+        <li><code>msg.payload_fields</code> contine lista campurilor folosite de nod.</li>
+
+        <li><code>msg.inverter_profile</code>, <code>msg.phase_mode</code> si <code>msg.mppt_count</code> descriu detectarea curenta.</li>
+
+    </ul>
+
+
+    <h3>Multi-inverter</h3>
+
+    <p>
+
+        Cand optiunea <b>Multi-inverter</b> este activata, nodul pregateste automat mesajul pentru nodul <code>multi-inverter</code>.
+
+        Acest mod se foloseste atunci cand ai doua sau mai multe invertoare si vrei ca limita de productie sa fie impartita intre ele in functie de puterea curenta.
+
+    </p>
+
+    <ul>
+
+        <li>Payload-ul este fixat automat pe <b>Putere AC (W)</b>.</li>
+
+        <li>Nodul ramane cu o singura iesire principala, ca telemetrie compacta pentru un singur invertor.</li>
+
+        <li><b>Inverter ID</b> devine obligatoriu si trebuie sa fie identic cu ID-ul configurat in lista de invertoare din <code>multi-inverter</code>.</li>
+
+        <li><code>msg.topic</code> si <code>msg.inverter_id</code> primesc valoarea din <b>Inverter ID</b>.</li>
+
+        <li><code>msg.payload.power_w</code> contine puterea activa AC in W.</li>
+
+        <li><code>msg.payload_field</code> este <code>summary.ac.power_w</code>, iar <code>msg.payload_fields</code> confirma lista campurilor trimise.</li>
+
+        <li>Mesajul mai include informatii de detectare, cum ar fi <code>msg.inverter_profile</code>, <code>msg.phase_mode</code> si <code>msg.mppt_count</code>.</li>
+
+    </ul>
+
+    <p>
+
+        Pentru fiecare invertor fizic se foloseste cate un nod <code>fronius-read</code>, fiecare cu propriul IP si propriul <b>Inverter ID</b>.
+
+        Toate iesirile acestor noduri pot intra in acelasi <code>multi-inverter</code>.
+
+        Daca ID-ul din mesaj nu exista in configuratia <code>multi-inverter</code>, sau daca <code>msg.topic</code> si <code>msg.inverter_id</code> difera,
+
+        <code>multi-inverter</code> trateaza mesajul ca invalid pentru protectie.
+
+    </p>
+
+    <p>
+
+        Flux recomandat:
+
+    </p>
+
+<pre>
+
+fronius-read inv1 -> multi-inverter -> fronius-write inv1 / inv2 / ...
+
+fronius-read inv2 -> multi-inverter -> fronius-write inv1 / inv2 / ...
+
+fronius-read inv3 -> multi-inverter -> fronius-write inv1 / inv2 / ...
+
+</pre>
+
+    <h3>Multi-grid pentru Smart Meter</h3>
+
+    <p>
+        Cand este detectat un <b>Fronius Smart Meter IP</b>, optiunea <b>Multi-grid</b> devine disponibila.
+        Nodul trimite un mesaj compact compatibil direct cu nodul <code>multi-grid</code>.
+    </p>
+
+    <ul>
+        <li>Implicit sunt trimise <code>power_w</code>, <code>power_l1_w</code>, <code>power_l2_w</code> si <code>power_l3_w</code>.</li>
+        <li><b>Meter ID</b> este transmis in <code>msg.topic</code> si <code>msg.meter_id</code>.</li>
+        <li>Multi-grid este indisponibil pentru invertoare si este exclusiv cu Multi-inverter, Control-export si InfluxDB.</li>
+    </ul>
+
+
+    <h3>Control-export</h3>
+
+    <p>
+
+        Cand optiunea <b>Control-export</b> este activata, nodul trimite acelasi format compact bazat pe <b>Putere AC (W)</b>,
+
+        potrivit pentru scenariile in care <code>control-export</code> trebuie sa cunoasca productia PV curenta a invertorului.
+
+    </p>
+
+    <ul>
+
+        <li><b>Multi-inverter</b>, <b>Control-export</b> si <b>InfluxDB</b> sunt exclusive; activarea uneia dezactiveaza celelalte.</li>
+
+        <li><b>Inverter ID</b> ramane obligatoriu si este trimis in <code>msg.topic</code> si <code>msg.inverter_id</code>.</li>
+
+        <li><code>msg.payload.power_w</code> reprezinta productia AC curenta a invertorului.</li>
+
+        <li>Mesajul nu este o limita de export; este telemetrie PV. Limita este calculata ulterior de <code>control-export</code>.</li>
+
+        <li>In <code>control-export</code>, aceasta telemetrie este utila impreuna cu optiunea de plafonare dupa productia PV disponibila.</li>
+
+        <li>Pentru un singur invertor, <b>Inverter ID</b> trebuie sa corespunda sursei PV pe care o asteapta <code>control-export</code>.</li>
+
+    </ul>
+
+    <p>
+
+        Intrarea principala a nodului <code>control-export</code> ramane masurarea din retea, de exemplu contorul de la punctul de cuplare.
+
+        Mesajul din <code>fronius-read</code> completeaza controlul cu productia PV curenta, astfel incat limita calculata sa nu ceara mai mult decat poate produce invertorul.
+
+    </p>
+
+    <p>
+
+        Flux recomandat pentru control direct:
+
+    </p>
+
+<pre>
+
+contor retea -> control-export -> fronius-write
+
+fronius-read cu Control-export activ -> control-export
+
+</pre>
+
+
+    <h3>InfluxDB</h3>
+
+    <p>
+
+        Cand optiunea <b>InfluxDB</b> este activa, nodul emite un singur mesaj agregat pe ciclu de citire, cu
+        <code>msg.influx.measurement</code>, <code>msg.influx.tags</code>, <code>msg.influx.fields</code> si
+        <code>msg.influx.timestamp</code>, compatibil direct cu nodul <code>adt-influxdb</code>.
+
+    </p>
+
+    <ul>
+
+        <li><b>Inverter ID</b> devine obligatoriu si este folosit in tag-ul <code>inverter_id</code>.</li>
+
+        <li>Protectia anti-duplicare blocheaza combinatiile duplicate <code>measurement + inverter_id</code>.</li>
+
+        <li>Implicit, Influx foloseste setul presetat: <code>summary.ac.power_w</code>, <code>summary.dc.dc_total_power_w</code>, <code>summary.ac.voltage_l1_v</code>, <code>summary.ac.voltage_l2_v</code>, <code>summary.ac.voltage_l3_v</code>.</li>
+
+        <li>Valorile trimise in <code>msg.influx.fields</code> sunt cele selectate in <b>Selected payload</b>.</li>
+
+    </ul>
+
+    <h3>SCADA aggregator</h3>
+
+    <p>Cu <b>SCADA aggregator</b> activ, nodul emite un singur mesaj normalizat pentru fiecare citire. Pentru un invertor, mesajul are <code>msg.scadaGroup = "pv_inverter"</code>; pentru un Fronius Smart Meter, <code>msg.scadaGroup = "grid_meter"</code>. ID-ul stabil este preluat din <b>Inverter ID</b> / <b>Meter ID</b> și este transmis în <code>msg.scadaSource</code>; acesta trebuie să fie unic în întregul <code>scada-aggregator</code>.</p>
+
+<pre>
+msg.scadaSource: "inv_01"
+msg.scadaGroup: "pv_inverter"
+msg.payload: { p, q, f, u_l1n, u_l2n, u_l3n, u_ln_avg, u_l12, u_l23, u_l31, u_ll_avg }
+</pre>
+
+    <p><code>p</code> este în W, <code>q</code> în VAr, <code>f</code> în Hz, iar tensiunile sunt în V. Acest mod este exclusiv față de Multi-inverter, Control-export, Multi-grid și InfluxDB.</p>
+
+
+    <h3>Debug mode</h3>
+
+    <p>
+
+        <b>Debug mode</b> adauga ultima iesire a nodului. Aceasta emite <code>msg.topic = "fronius/raw"</code> si include modelele SunSpec brute,
+
+        sumarul citit, profilul detectat si lista campurilor folosite. Iesirea este utila pentru diagnostic si validarea maparii SunSpec.
+
+    </p>
+
+
+    <h3>Erori</h3>
+
+    <p>
+
+        Daca citirea esueaza, nodul seteaza status rosu si trimite un mesaj cu <code>msg.topic = "fronius/error"</code>.
+
+        Payload-ul contine IP-ul, Unit ID-ul, mesajul de eroare si timestamp-ul.
+
+    </p>
+
+
+    <h3>Exemplu multi-inverter</h3>
+
+<pre>
+
+msg.topic: "inv1"
+
+msg.payload: {
+
+  power_w: 1040
+
+}
+
+msg.inverter_id: "inv1"
+
+</pre>
+
+    <h3>Referinta completa parametri</h3>
+
+    <ul>
+
+        <li><code>host</code>, <code>port</code>, <code>unitId</code>: conexiunea Modbus TCP catre Fronius.</li>
+
+        <li><code>pollInterval</code>: intervalul de citire periodica in milisecunde; <code>off</code> sau <code>0</code> activeaza citirea doar la trigger pe intrare.</li>
+
+        <li><code>inverterType</code>: profilul detectat sau selectat pentru maparea SunSpec.</li>
+
+        <li><code>payloadMode</code>: <code>full</code> sau <code>selected</code>.</li>
+
+        <li><code>payloadField</code>: campul unic folosit de configuratii vechi.</li>
+
+        <li><code>payloadFields</code>: lista campurilor selectate in modul curent.</li>
+
+        <li><code>debugMode</code>: adauga iesire raw pentru diagnostic.</li>
+
+        <li><code>multiInverter</code>: pregateste telemetrie compacta pentru <code>multi-inverter</code>.</li>
+
+        <li><code>controlExport</code>: trimite productie PV compacta pentru <code>control-export</code>.</li>
+
+        <li><code>multiGrid</code>: trimite format compact de meter catre <code>multi-grid</code>, cand dispozitivul detectat este Smart Meter.</li>
+
+        <li><code>scadaAggregator</code>: emite telemetrie P/Q/U/f normalizată pentru <code>scada-aggregator</code>.</li>
+
+        <li><code>influxDb</code>: emite <code>msg.influx</code> pentru <code>adt-influxdb</code>.</li>
+
+        <li><code>influxMeasurement</code>: measurement-ul folosit in InfluxDB.</li>
+
+        <li><code>multiInverterUseSelectedFields</code>: foloseste lista selectata pentru presetul multi-inverter.</li>
+
+        <li><code>multiGridUseSelectedFields</code>: permite selectie custom pentru presetul multi-grid.</li>
+
+        <li><code>inverterId</code>: ID stabil emis in <code>msg.topic</code>, <code>msg.inverter_id</code> si tag-uri Influx.</li>
+
+    </ul>
+
+
+</script>
+
+
+<style>
+
+    .fronius-read-editor {
+
+        --pr-border: #d7dde5;
+
+        --pr-muted: #667085;
+
+        --pr-surface: #f8fafc;
+
+    }
+
+
+    .fronius-read-editor .pr-section {
+
+        margin: 0 0 18px;
+
+        padding: 14px 16px 16px;
+
+        border: 1px solid var(--pr-border);
+
+        border-radius: 10px;
+
+        background: var(--pr-surface);
+
+    }
+
+
+    .fronius-read-editor .pr-section-title {
+
+        display: flex;
+
+        align-items: center;
+
+        gap: 8px;
+
+        margin: 0 0 4px;
+
+        font-size: 15px;
+
+        font-weight: 600;
+
+        color: #243447;
+
+    }
+
+
+    .fronius-read-editor .pr-section-note {
+
+        margin: 0 0 14px;
+
+        color: var(--pr-muted);
+
+        font-size: 12px;
+
+        line-height: 1.45;
+
+    }
+
+
+    .fronius-read-editor .pr-grid {
+
+        display: grid;
+
+        grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+
+        gap: 12px 16px;
+
+    }
+
+
+    .fronius-read-editor .pr-grid-2 {
+
+        grid-template-columns: repeat(2, minmax(320px, 1fr));
+
+    }
+
+
+    .fronius-read-editor .pr-span-2 {
+
+        grid-column: 1 / -1;
+
+    }
+
+
+    .fronius-read-editor .form-row {
+
+        margin-bottom: 12px;
+
+    }
+
+
+    .fronius-read-editor .pr-grid .form-row,
+
+    .fronius-read-editor .form-row:last-child {
+
+        margin-bottom: 0;
+
+    }
+
+
+    .fronius-read-editor .form-row > label {
+
+        width: 150px;
+
+        font-weight: 600;
+
+    }
+
+
+    .fronius-read-editor .form-row > input[type="text"],
+
+    .fronius-read-editor .form-row > input[type="number"],
+
+    .fronius-read-editor .form-row > select {
+
+        width: calc(100% - 160px);
+
+    }
+
+
+    .fronius-read-editor .pr-grid-2 .form-row > label {
+
+        width: 130px;
+
+    }
+
+
+    .fronius-read-editor .pr-grid-2 .form-row > input[type="text"],
+
+    .fronius-read-editor .pr-grid-2 .form-row > input[type="number"],
+
+    .fronius-read-editor .pr-grid-2 .form-row > select {
+
+        width: calc(100% - 140px);
+
+    }
+
+
+    .fronius-read-editor .pr-inline-control {
+
+        width: calc(100% - 160px);
+
+        display: inline-block;
+
+        position: relative;
+
+    }
+
+
+    .fronius-read-editor .pr-toolbar {
+
+        display: flex;
+
+        flex-wrap: wrap;
+
+        gap: 8px;
+
+        margin-bottom: 10px;
+
+    }
+
+
+    .fronius-read-editor .pr-field-list {
+
+        max-height: 320px;
+
+        overflow: auto;
+
+        padding: 12px;
+
+        border: 1px solid var(--pr-border);
+
+        border-radius: 10px;
+
+        background: #fff;
+
+    }
+
+
+    .fronius-read-editor .pr-field-group {
+
+        margin-bottom: 14px;
+
+    }
+
+
+    .fronius-read-editor .pr-field-group:last-child {
+
+        margin-bottom: 0;
+
+    }
+
+
+    .fronius-read-editor .pr-field-group-title {
+
+        margin: 0 0 8px;
+
+        font-size: 12px;
+
+        font-weight: 700;
+
+        text-transform: uppercase;
+
+        letter-spacing: 0.03em;
+
+        color: #344054;
+
+    }
+
+
+    .fronius-read-editor .pr-field-group-grid {
+
+        display: grid;
+
+        grid-template-columns: repeat(auto-fit, minmax(230px, 1fr));
+
+        gap: 8px 16px;
+
+    }
+
+
+    .fronius-read-editor .pr-field-item {
+
+        display: flex;
+
+        align-items: center;
+
+        gap: 8px;
+
+        margin: 0;
+
+        line-height: 1.35;
+
+        font-weight: 400;
+
+        cursor: pointer;
+
+    }
+
+
+    .fronius-read-editor .pr-field-item > input[type="checkbox"] {
+
+        width: auto;
+
+        margin: 0;
+
+        flex: 0 0 auto;
+
+    }
+
+
+    .fronius-read-editor .button.disabled {
+
+        pointer-events: none;
+
+        opacity: 0.5;
+
+    }
+
+
+    .fronius-read-editor .pr-checkbox-row > input[type="checkbox"] {
+
+        display: inline-block;
+
+        width: auto;
+
+        vertical-align: top;
+
+    }
+
+
+    .fronius-read-editor .pr-inline-note {
+
+        margin-left: 8px;
+
+        color: var(--pr-muted);
+
+        line-height: 1.4;
+
+    }
+
+
+    .fronius-probe-row {
+
+        margin-top: 4px;
+
+    }
+
+
+    .fronius-probe-info,
+
+    .fronius-meta-info {
+
+        color: var(--pr-muted);
+
+        line-height: 1.45;
+
+        padding-top: 2px;
+
+    }
+
+
+    .fronius-meta-row {
+
+        margin-top: 0;
+
+        margin-bottom: 8px;
+
+    }
+
+
+    .fronius-multiselect-empty {
+
+        padding: 8px 12px;
+
+        color: #999;
+
+        font-style: italic;
+
+    }
+
+
+    @media (max-width: 1100px) {
+
+        .fronius-read-editor .pr-grid-2 {
+
+            grid-template-columns: 1fr;
+
+        }
+
+    }
+
+</style>
+