@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/multi-inverter/multi-inverter.html

@@ -0,0 +1,2674 @@
+<script type="text/javascript">
+
+
+(function() {
+
+
+    const EXPERT_LONG_PRESS_MS = 5000;
+
+    const COMPACT_ROW_THRESHOLD = 6;
+
+
+    let expertLongPressTimer = null;
+
+    let expertLongPressTriggered = false;
+
+    let expertModeUnlockedState = false;
+
+
+
+    function normalizeDebugMode(mode) {
+
+        if (mode === "off" || mode === "normal" || mode === "verbose") {
+
+            return mode;
+
+        }
+
+
+        if (mode === "errors_only" || mode === "state_changes") {
+
+            return "normal";
+
+        }
+
+
+        if (mode === "always") {
+
+            return "verbose";
+
+        }
+
+
+        return "off";
+
+    }
+
+
+
+    function computeOutputsCount(rowCount, debugMode) {
+
+        const base = 1;
+
+        const debugExtra = normalizeDebugMode(debugMode) === "off" ? 0 : 1;
+
+        return base + debugExtra;
+
+    }
+
+
+
+    function updateOutputCount(node) {
+
+        const debugMode = $("#node-input-debugMode").val();
+
+        const outputs = computeOutputsCount(1, debugMode);
+
+
+        node.outputs = outputs;
+
+        $("#node-multi-inverter-outputs-info").text(String(outputs));
+
+    }
+
+
+
+    function toggleRampValueVisibility() {
+
+
+        const rampType = $("#node-input-rampType").val();
+        const rampFromGlobal = $("#node-input-rampFromGlobal").is(":checked");
+        const rampEnabled = rampFromGlobal || rampType !== "none";
+
+        $("#node-row-rampType").toggle(!rampFromGlobal);
+        $("#node-row-rampGlobalType").toggle(rampFromGlobal);
+        $("#node-row-rampGlobalUpValue").toggle(rampFromGlobal);
+        $("#node-row-rampGlobalDownValue").toggle(rampFromGlobal);
+        $("#node-row-rampUpValue").toggle(rampEnabled && !rampFromGlobal);
+        $("#node-row-rampDownValue").toggle(rampEnabled && !rampFromGlobal);
+
+        if (rampFromGlobal) {
+
+            return;
+
+        }
+
+
+        if (rampType === "none") {
+
+            return;
+
+        }
+
+
+        let label = "Ramp Value";
+
+        if (rampType === "time") label = "Ramp Time (s)";
+
+        if (rampType === "gradient_pct") label = "Ramp Gradient (%/s)";
+
+        if (rampType === "gradient_w" || rampType === "gradient_vars" || rampType === "gradient_var") {
+
+            label = "Ramp Gradient (W/s & VAR/s)";
+
+        }
+
+
+        $("#node-label-rampUpValue").text(label.replace("Ramp ", "Ramp Up "));
+        $("#node-label-rampDownValue").text(label.replace("Ramp ", "Ramp Down "));
+
+
+    }
+
+
+
+    function toggleAdvancedRows() {
+
+        $("#mi-advanced-section").toggle(!!expertModeUnlockedState);
+
+
+    }
+
+
+    function updateCompactRows() {
+
+        const rowCount = $("#node-input-inverters-container .inverter-row").length;
+
+        $(".mi-inverters-container").toggleClass("mi-compact", rowCount >= COMPACT_ROW_THRESHOLD);
+
+    }
+
+
+
+    function toggleMissingSiteLimitRows() {
+
+
+        const behavior = $("#node-input-missingSiteLimitBehavior").val();
+
+        $("#node-row-missingSiteLimitValue").toggle(behavior === "fixed_value");
+
+
+    }
+
+
+
+    function toggleStaleTelemetryRows() {
+
+
+        const behavior = $("#node-input-staleTelemetryBehavior").val();
+
+        $("#node-row-staleTelemetryFixedValue").toggle(behavior === "fixed_value");
+
+
+    }
+
+
+
+    function normalizeTopics(text) {
+
+
+        return String(text || "")
+
+            .split(",")
+
+            .map(function (s) { return s.trim(); })
+
+            .filter(Boolean)
+
+            .filter(function (v, i, arr) { return arr.indexOf(v) === i; })
+
+            .join(",");
+
+
+    }
+
+
+
+    function clearExpertLongPressTimer() {
+
+        if (expertLongPressTimer) {
+
+            clearTimeout(expertLongPressTimer);
+
+            expertLongPressTimer = null;
+
+        }
+
+    }
+
+
+
+    function unlockExpertMode() {
+
+        expertModeUnlockedState = true;
+
+        toggleAdvancedRows();
+
+
+        if (RED && RED.notify) {
+
+            RED.notify("Setarile suplimentare au fost activate.", "success");
+
+        }
+
+
+    }
+
+
+
+    function validateRows() {
+
+
+        const rows = $("#node-input-inverters-container .inverter-row");
+
+        const seen = new Set();
+
+        const errors = [];
+
+
+        rows.each(function(index) {
+
+
+            const row = $(this);
+
+            const idInput = row.find(".inv-id");
+
+            const minInput = row.find(".inv-minw");
+
+            const maxInput = row.find(".inv-maxw");
+            const nominalInput = row.find(".inv-nominalw");
+
+            const enabled = row.find(".inv-enabled").is(":checked");
+
+
+            const id = String(idInput.val() || "").trim();
+
+            const minW = Number(minInput.val() || 0);
+
+            const maxW = Number(maxInput.val() || 0);
+            const nominalW = Number(nominalInput.val() || maxW || 0);
+
+
+            row.removeClass("mi-row-invalid");
+
+            idInput.removeClass("mi-invalid");
+
+            minInput.removeClass("mi-invalid");
+
+            maxInput.removeClass("mi-invalid");
+            nominalInput.removeClass("mi-invalid");
+
+
+            if (!enabled) {
+
+                return;
+
+            }
+
+
+            if (!id) {
+
+                errors.push("Rand " + (index + 1) + ": ID gol");
+
+                row.addClass("mi-row-invalid");
+
+                idInput.addClass("mi-invalid");
+
+            } else if (seen.has(id)) {
+
+                errors.push("ID duplicat: " + id);
+
+                row.addClass("mi-row-invalid");
+
+                idInput.addClass("mi-invalid");
+
+            } else {
+
+                seen.add(id);
+
+            }
+
+
+            if (!Number.isFinite(minW) || minW < 0) {
+
+                errors.push("Rand " + (index + 1) + ": Min W invalid");
+
+                row.addClass("mi-row-invalid");
+
+                minInput.addClass("mi-invalid");
+
+            }
+
+
+            if (!Number.isFinite(maxW) || maxW <= 0) {
+
+                errors.push("Rand " + (index + 1) + ": Max W trebuie sa fie > 0");
+
+                row.addClass("mi-row-invalid");
+
+                maxInput.addClass("mi-invalid");
+
+            }
+
+
+            if (Number.isFinite(minW) && Number.isFinite(maxW) && minW > maxW) {
+
+                errors.push("Rand " + (index + 1) + ": Min W > Max W");
+
+                row.addClass("mi-row-invalid");
+
+                minInput.addClass("mi-invalid");
+
+                maxInput.addClass("mi-invalid");
+
+            }
+
+
+            if (!Number.isFinite(nominalW) || nominalW <= 0) {
+
+                errors.push("Rand " + (index + 1) + ": Nominal W trebuie sa fie > 0");
+
+                row.addClass("mi-row-invalid");
+
+                nominalInput.addClass("mi-invalid");
+
+            }
+
+
+            if (Number.isFinite(nominalW) && Number.isFinite(maxW) && nominalW < maxW) {
+
+                errors.push("Rand " + (index + 1) + ": Nominal W trebuie sa fie >= Max W");
+
+                row.addClass("mi-row-invalid");
+
+                nominalInput.addClass("mi-invalid");
+
+                maxInput.addClass("mi-invalid");
+
+            }
+
+
+        });
+
+
+        if (errors.length) {
+
+            $("#node-multi-inverter-validation")
+
+                .text(errors[0])
+
+                .show();
+
+        } else {
+
+            $("#node-multi-inverter-validation").hide().text("");
+
+        }
+
+
+        return errors;
+
+
+    }
+
+
+
+    function validateAdvancedInputs() {
+
+        const topics = String($("#node-input-siteLimitTopics").val() || "").trim();
+
+        if (!topics) {
+
+            $("#node-multi-inverter-validation")
+
+                .text("Site Limit Topics nu poate fi gol.")
+
+                .show();
+
+            return false;
+
+        }
+
+        return true;
+
+    }
+
+
+
+    function rowTemplate(index, inv) {
+
+        const safe = inv || {};
+
+
+        return (
+
+            '<div class="form-row inverter-row mi-row">' +
+
+                '<div class="mi-col-index">' + (index + 1) + '</div>' +
+
+                '<input type="text" class="inv-id mi-col-id" placeholder="inv' + (index + 1) + '" value="' + String(safe.id || "") + '">' +
+
+                '<input type="number" class="inv-minw mi-col-min" placeholder="0" value="' + Number(safe.minW || 0) + '">' +
+
+                '<input type="number" class="inv-maxw mi-col-max" placeholder="10000" value="' + Number(safe.maxW || 10000) + '">' +
+
+                '<input type="number" class="inv-nominalw mi-col-nominal" placeholder="10000" value="' + Number(safe.nominalPowerW || safe.nominalW || safe.maxW || 10000) + '">' +
+
+                '<label class="mi-col-enabled mi-enabled-toggle">' +
+
+                    '<input type="checkbox" class="inv-enabled" ' + (safe.enabled !== false ? "checked" : "") + '>' +
+
+                '</label>' +
+
+                '<button type="button" class="button button-small mi-row-remove" title="Remove">Remove</button>' +
+
+            '</div>'
+
+        );
+
+    }
+
+
+
+    function rebuildRowIndexes() {
+
+        $("#node-input-inverters-container .inverter-row").each(function(index) {
+
+            const row = $(this);
+
+            row.find(".mi-col-index").text(String(index + 1));
+
+            const idInput = row.find(".inv-id");
+
+            if (!String(idInput.attr("placeholder") || "").trim()) {
+
+                idInput.attr("placeholder", "inv" + (index + 1));
+
+            }
+
+        });
+
+    }
+
+
+
+    RED.nodes.registerType("multi-inverter", {
+
+
+        category: "Atelierul de Tehnologii",
+
+
+        color: "#FFD580",
+
+
+        defaults: {
+            license: { value: "", type: "atelier-license", required: true },
+
+
+            name: { value: "" },
+
+
+            strategy: { value: "current_power" },
+
+
+            siteLimitTopics: { value: "site-limit,control-export,control-reactive" },
+
+
+            telemetryTimeoutMs: {
+
+                value: 6000,
+
+                validate: function(v) {
+
+                    return Number(v) >= 0;
+
+                }
+
+            },
+
+            maxFutureTimestampMs: {
+                value: 2000,
+                validate: function(v) {
+                    return Number(v) >= 0;
+                }
+            },
+
+
+            siteLimitTimeoutMs: {
+
+                value: 8000,
+
+                validate: function(v) {
+
+                    return Number(v) >= 0;
+
+                }
+
+            },
+
+
+            missingSiteLimitBehavior: { value: "set_zero" },
+
+
+            missingSiteLimitValueW: {
+
+                value: 0,
+
+                validate: function(v) {
+
+                    return Number(v) >= 0;
+
+                }
+
+            },
+
+
+            staleTelemetryBehavior: { value: "set_inverter_min" },
+
+
+            staleTelemetryFixedValueW: {
+
+                value: 0,
+
+                validate: function(v) {
+
+                    return Number(v) >= 0;
+
+                }
+
+            },
+
+
+            waitForFreshTelemetryOnStartup: { value: true },
+
+
+            recalculateOnTelemetry: { value: true },
+
+            telemetryFilterAlpha: {
+                value: 0.35,
+                validate: function(v) {
+                    const n = Number(v);
+                    return Number.isFinite(n) && n >= 0.05 && n <= 1;
+                }
+            },
+
+
+            rampType: { value: "none" },
+
+
+            rampFromGlobal: { value: false },
+
+
+            rampTypeGlobalVar: { value: "scada_ramp_type" },
+
+
+            rampUpGlobalVar: { value: "scada_ramp_up_value" },
+
+
+            rampDownGlobalVar: { value: "scada_ramp_down_value" },
+
+
+            rampValue: {
+
+                value: 0,
+
+                validate: function(v) {
+
+                    return Number(v) >= 0;
+
+                }
+
+            },
+
+            rampUpValue: {
+                value: 0,
+                validate: function(v) {
+                    return Number(v) >= 0;
+                }
+            },
+
+            rampDownValue: {
+                value: 0,
+                validate: function(v) {
+                    return Number(v) >= 0;
+                }
+            },
+
+
+            allocationSmoothingAlpha: {
+
+                value: 0.35,
+
+                validate: function(v) {
+
+                    const n = Number(v);
+
+                    return Number.isFinite(n) && n > 0 && n <= 1;
+
+                }
+
+            },
+
+            allocationDeadbandW: {
+                value: 300,
+                validate: function(v) {
+                    return Number(v) >= 0;
+                }
+            },
+
+
+            telemetryRecalcDebounceMs: {
+
+                value: 350,
+
+                validate: function(v) {
+
+                    return Number(v) >= 0;
+
+                }
+
+            },
+
+
+            debugMode: { value: "off" },
+
+            publishTotalPvGlobal: { value: true },
+
+            totalPvGlobalVar: { value: "total_pv" },
+
+            influxDb: { value: false },
+            influxMeasurement: { value: "multi_inverter" },
+            influxNode: { value: "" },
+
+
+            inverters: {
+
+                value: [
+
+                    { id: "inv1", minW: 0, maxW: 10000, nominalPowerW: 10000, enabled: true }
+
+                ],
+
+                validate: function(v) {
+
+
+                    const arr = Array.isArray(v) ? v : [];
+
+                    const seen = new Set();
+
+
+                    for (let i = 0; i < arr.length; i += 1) {
+
+                        const inv = arr[i] || {};
+
+
+                        if (inv.enabled === false) {
+
+                            continue;
+
+                        }
+
+
+                        const id = String(inv.id || "").trim();
+
+                        const minW = Number(inv.minW || 0);
+
+                        const maxW = Number(inv.maxW || 0);
+                        const nominalW = Number(inv.nominalPowerW || inv.nominalW || maxW || 0);
+
+
+                        if (!id) return false;
+
+                        if (!Number.isFinite(minW) || minW < 0) return false;
+
+                        if (!Number.isFinite(maxW) || maxW <= 0) return false;
+                        if (!Number.isFinite(nominalW) || nominalW <= 0) return false;
+
+                        if (minW > maxW) return false;
+                        if (nominalW < maxW) return false;
+
+                        if (seen.has(id)) return false;
+
+
+                        seen.add(id);
+
+                    }
+
+
+                    return arr.length > 0;
+
+                }
+
+            }
+
+
+        },
+
+
+        inputs: 1,
+
+
+        outputs: 1,
+
+
+        icon: "bridge.svg",
+
+
+        label: function() {
+
+            return this.name || "multi-inverter";
+
+        },
+
+
+        paletteLabel: "multi-inverter",
+
+
+
+        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 toggleInfluxRows() {
+                $("#node-row-influxMeasurement,#node-row-influxNode").toggle($("#node-input-influxDb").is(":checked"));
+            }
+            $("#node-input-influxDb").off(".miInflux").on("change.miInflux", toggleInfluxRows);
+            toggleInfluxRows();
+
+            const container = $("#node-input-inverters-container");
+
+
+
+            function bindRowEvents() {
+
+                container.find(".inv-id, .inv-enabled, .inv-minw, .inv-maxw, .inv-nominalw")
+
+                    .off(".miRows")
+
+                    .on("input.miRows change.miRows", function() {
+
+                        validateRows();
+
+                        updateOutputCount(node);
+
+                    });
+
+
+                container.find(".mi-row-remove")
+
+                    .off(".miRows")
+
+                    .on("click.miRows", function(evt) {
+
+                        evt.preventDefault();
+
+
+                        const rows = container.find(".inverter-row");
+
+                        if (rows.length <= 1) {
+
+                            return;
+
+                        }
+
+
+                        $(this).closest(".inverter-row").remove();
+
+                        rebuildRowIndexes();
+
+                        validateRows();
+
+                        updateOutputCount(node);
+
+                        updateCompactRows();
+
+                    });
+
+            }
+
+
+
+            function renderRows(inverters) {
+
+                const list = Array.isArray(inverters) && inverters.length
+
+                    ? inverters
+
+                    : [{ id: "inv1", minW: 0, maxW: 10000, nominalPowerW: 10000, enabled: true }];
+
+
+                container.empty();
+
+
+                list.forEach(function(inv, index) {
+
+                    container.append($(rowTemplate(index, inv)));
+
+                });
+
+
+                bindRowEvents();
+
+                rebuildRowIndexes();
+
+                validateRows();
+
+                updateOutputCount(node);
+
+                updateCompactRows();
+
+            }
+
+
+
+            function startExpertLongPress(evt) {
+
+                if (evt && evt.preventDefault) {
+
+                    evt.preventDefault();
+
+                }
+
+                expertLongPressTriggered = false;
+
+                clearExpertLongPressTimer();
+
+
+                expertLongPressTimer = setTimeout(function() {
+
+                    expertLongPressTriggered = true;
+
+                    unlockExpertMode();
+
+                }, EXPERT_LONG_PRESS_MS);
+
+            }
+
+
+
+            function stopExpertLongPress() {
+
+                clearExpertLongPressTimer();
+
+            }
+
+
+
+            renderRows(node.inverters);
+
+
+            const normalizedDebug = normalizeDebugMode(node.debugMode);
+
+            $("#node-input-debugMode").val(normalizedDebug);
+
+
+            expertModeUnlockedState = false;
+
+
+            toggleAdvancedRows();
+
+            $("#node-row-totalPvGlobalVar").toggle($("#node-input-publishTotalPvGlobal").is(":checked"));
+
+            toggleRampValueVisibility();
+
+            toggleMissingSiteLimitRows();
+
+            toggleStaleTelemetryRows();
+
+            updateOutputCount(node);
+
+            updateCompactRows();
+
+
+            $("#node-input-siteLimitTopics")
+
+                .off(".miEditor")
+
+                .on("blur.miEditor", function() {
+
+                    $(this).val(normalizeTopics($(this).val()));
+
+                    validateAdvancedInputs();
+
+                });
+
+
+            $("#node-input-debugMode")
+
+                .off(".miEditor")
+
+                .on("change.miEditor", function() {
+
+                    updateOutputCount(node);
+
+                });
+
+
+            $("#node-input-totalPvGlobalVar")
+
+                .off(".miEditor")
+
+                .on("blur.miEditor", function() {
+
+                    const key = String($(this).val() || "").trim();
+
+                    $(this).val(key || "total_pv");
+
+                });
+
+
+            $("#node-input-publishTotalPvGlobal")
+
+                .off(".miEditor")
+
+                .on("change.miEditor", function() {
+
+                    $("#node-row-totalPvGlobalVar").toggle($("#node-input-publishTotalPvGlobal").is(":checked"));
+
+                });
+
+
+            $("#node-input-rampType")
+
+                .off(".miEditor")
+
+                .on("change.miEditor", function() {
+
+                    toggleRampValueVisibility();
+
+                });
+
+
+            $("#node-input-rampFromGlobal")
+
+                .off(".miEditor")
+
+                .on("change.miEditor", function() {
+
+                    toggleRampValueVisibility();
+
+                });
+
+
+            $("#node-input-rampTypeGlobalVar, #node-input-rampUpGlobalVar, #node-input-rampDownGlobalVar")
+
+                .off(".miEditor")
+
+                .on("blur.miEditor", function() {
+
+                    let fallback = "scada_ramp_type";
+                    if (this.id === "node-input-rampUpGlobalVar") fallback = "scada_ramp_up_value";
+                    if (this.id === "node-input-rampDownGlobalVar") fallback = "scada_ramp_down_value";
+
+                    const key = String($(this).val() || "").trim();
+
+                    $(this).val(key || fallback);
+
+                });
+
+
+            $("#node-input-missingSiteLimitBehavior")
+
+                .off(".miEditor")
+
+                .on("change.miEditor", function() {
+
+                    toggleMissingSiteLimitRows();
+
+                });
+
+
+            $("#node-input-staleTelemetryBehavior")
+
+                .off(".miEditor")
+
+                .on("change.miEditor", function() {
+
+                    toggleStaleTelemetryRows();
+
+                });
+
+
+            $("#node-mi-add-inverter")
+
+                .off(".miLongPress")
+
+                .on("pointerdown.miLongPress", function(evt) {
+
+                    startExpertLongPress(evt);
+
+                })
+
+                .on("pointerup.miLongPress pointercancel.miLongPress", function() {
+
+                    stopExpertLongPress();
+
+                })
+
+                .on("click.miLongPress", function(evt) {
+
+                    if (!expertLongPressTriggered) {
+
+                        return;
+
+                    }
+
+                    evt.preventDefault();
+
+                    evt.stopImmediatePropagation();
+
+                    expertLongPressTriggered = false;
+
+                });
+
+
+            $("#node-mi-add-inverter")
+
+                .off(".miEditor")
+
+                .on("click.miEditor", function(evt) {
+
+                    if (expertLongPressTriggered) {
+
+                        expertLongPressTriggered = false;
+
+                        evt.preventDefault();
+
+                        evt.stopImmediatePropagation();
+
+                        return;
+
+                    }
+
+
+                    evt.preventDefault();
+
+
+                    const rows = container.find(".inverter-row");
+
+                    const index = rows.length;
+
+                    const defaultInv = {
+
+                        id: "inv" + (index + 1),
+
+                        minW: 0,
+
+                        maxW: 10000,
+
+                        nominalPowerW: 10000,
+
+                        enabled: true
+
+                    };
+
+
+                    container.append($(rowTemplate(index, defaultInv)));
+
+                    bindRowEvents();
+
+                    rebuildRowIndexes();
+
+                    validateRows();
+
+                    updateOutputCount(node);
+
+                    updateCompactRows();
+
+                });
+
+
+        },
+
+
+
+        oneditsave: function() {
+
+
+            const errors = validateRows();
+
+            if (errors.length > 0) {
+
+                RED.notify("Configuratia multi-inverter are erori. Corecteaza randurile marcate.", "error");
+
+            }
+
+            validateAdvancedInputs();
+
+
+            const inverters = [];
+
+
+            $("#node-input-inverters-container .inverter-row").each(function(index) {
+
+                const row = $(this);
+
+                inverters.push({
+
+                    id: String(row.find(".inv-id").val() || "").trim() || ("inv" + (index + 1)),
+
+                    minW: Number(row.find(".inv-minw").val() || 0),
+
+                    maxW: Number(row.find(".inv-maxw").val() || 0),
+
+                    nominalPowerW: Number(row.find(".inv-nominalw").val() || row.find(".inv-maxw").val() || 0),
+
+                    enabled: row.find(".inv-enabled").is(":checked")
+
+                });
+
+            });
+
+
+            this.inverters = inverters;
+
+            this.strategy = $("#node-input-strategy").val() || "current_power";
+
+            this.siteLimitTopics = normalizeTopics($("#node-input-siteLimitTopics").val());
+
+            this.rampType = $("#node-input-rampType").val() || "none";
+
+            this.rampValue = Number($("#node-input-rampValue").val() || 0);
+
+            this.rampFromGlobal = $("#node-input-rampFromGlobal").is(":checked");
+
+            this.rampTypeGlobalVar = String($("#node-input-rampTypeGlobalVar").val() || "").trim() || "scada_ramp_type";
+
+            this.rampUpGlobalVar = String($("#node-input-rampUpGlobalVar").val() || "").trim() || "scada_ramp_up_value";
+
+            this.rampDownGlobalVar = String($("#node-input-rampDownGlobalVar").val() || "").trim() || "scada_ramp_down_value";
+
+            this.rampUpValue = Number($("#node-input-rampUpValue").val() || 0);
+
+            this.rampDownValue = Number($("#node-input-rampDownValue").val() || 0);
+
+            this.debugMode = normalizeDebugMode($("#node-input-debugMode").val());
+
+            this.publishTotalPvGlobal = $("#node-input-publishTotalPvGlobal").is(":checked");
+
+            this.totalPvGlobalVar = String($("#node-input-totalPvGlobalVar").val() || "").trim() || "total_pv";
+
+
+            this.telemetryTimeoutMs = Number($("#node-input-telemetryTimeoutMs").val() || 6000);
+
+            this.siteLimitTimeoutMs = Number($("#node-input-siteLimitTimeoutMs").val() || 8000);
+
+            this.missingSiteLimitBehavior = $("#node-input-missingSiteLimitBehavior").val() || "set_zero";
+
+            this.missingSiteLimitValueW = Number($("#node-input-missingSiteLimitValueW").val() || 0);
+
+            this.staleTelemetryBehavior = $("#node-input-staleTelemetryBehavior").val() || "set_inverter_min";
+
+            this.staleTelemetryFixedValueW = Number($("#node-input-staleTelemetryFixedValueW").val() || 0);
+
+            this.waitForFreshTelemetryOnStartup = $("#node-input-waitForFreshTelemetryOnStartup").is(":checked");
+
+            this.recalculateOnTelemetry = $("#node-input-recalculateOnTelemetry").is(":checked");
+
+            this.allocationSmoothingAlpha = Number($("#node-input-allocationSmoothingAlpha").val() || 0.35);
+
+            this.telemetryFilterAlpha = Number($("#node-input-telemetryFilterAlpha").val() || 0.35);
+
+            this.telemetryRecalcDebounceMs = Number($("#node-input-telemetryRecalcDebounceMs").val() || 350);
+
+
+            this.outputs = computeOutputsCount(inverters.length, this.debugMode);
+
+
+            $("#node-input-siteLimitTopics, #node-input-debugMode, #node-input-publishTotalPvGlobal, #node-input-totalPvGlobalVar, #node-input-rampType, #node-input-rampFromGlobal, #node-input-rampTypeGlobalVar, #node-input-rampUpGlobalVar, #node-input-rampDownGlobalVar, #node-input-missingSiteLimitBehavior, #node-input-staleTelemetryBehavior, #node-mi-add-inverter").off(".miEditor");
+
+            $("#node-mi-add-inverter").off(".miLongPress");
+
+            $("#node-input-inverters-container .inv-id, #node-input-inverters-container .inv-enabled, #node-input-inverters-container .inv-minw, #node-input-inverters-container .inv-maxw, #node-input-inverters-container .inv-nominalw, #node-input-inverters-container .mi-row-remove").off(".miRows");
+
+            clearExpertLongPressTimer();
+
+            expertModeUnlockedState = false;
+
+
+        },
+
+
+
+        oneditcancel: function() {
+
+            $("#node-input-siteLimitTopics, #node-input-debugMode, #node-input-publishTotalPvGlobal, #node-input-totalPvGlobalVar, #node-input-rampType, #node-input-rampFromGlobal, #node-input-rampTypeGlobalVar, #node-input-rampUpGlobalVar, #node-input-rampDownGlobalVar, #node-input-missingSiteLimitBehavior, #node-input-staleTelemetryBehavior, #node-mi-add-inverter").off(".miEditor");
+
+            $("#node-mi-add-inverter").off(".miLongPress");
+
+            $("#node-input-inverters-container .inv-id, #node-input-inverters-container .inv-enabled, #node-input-inverters-container .inv-minw, #node-input-inverters-container .inv-maxw, #node-input-inverters-container .inv-nominalw, #node-input-inverters-container .mi-row-remove").off(".miRows");
+
+            clearExpertLongPressTimer();
+
+            expertModeUnlockedState = false;
+
+        }
+
+
+    });
+
+
+})();
+
+
+</script>
+
+
+
+<script type="text/html" data-template-name="multi-inverter">
+    <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="multi-inverter-editor">
+
+
+        <div class="pr-section">
+
+            <div class="pr-section-title"><i class="fa fa-sliders"></i> General</div>
+
+            <p class="pr-section-note">Distribuie limita de site catre invertoare pe baza telemetriei curente.</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="multi-inverter">
+
+                </div>
+
+
+                <div class="form-row">
+
+                    <label for="node-input-strategy"><i class="fa fa-sitemap"></i> Allocation Strategy</label>
+
+                    <select id="node-input-strategy">
+
+                        <option value="current_power">Current power</option>
+
+                        <option value="max_power">Max power</option>
+
+                        <option value="equal">Equal share</option>
+
+                        <option value="headroom">Headroom</option>
+
+                    </select>
+
+                </div>
+
+
+                <div class="form-row">
+
+                    <label></label>
+
+                    <div class="fronius-meta-info">Iesiri: <span id="node-multi-inverter-outputs-info">1</span></div>
+
+                </div>
+
+            </div>
+
+        </div>
+
+
+        <div class="pr-section">
+
+            <div class="pr-section-title"><i class="fa fa-tachometer"></i> Ramp</div>
+
+            <p class="pr-section-note">Setari implicite de rampa propagate spre nodurile de write.</p>
+
+
+            <div class="pr-grid pr-grid-2">
+
+                <div class="form-row pr-checkbox-row pr-span-2 mi-ramp-global-toggle">
+
+                    <label for="node-input-rampFromGlobal"><i class="fa fa-globe"></i> Read Ramp From Global</label>
+
+                    <input type="checkbox" id="node-input-rampFromGlobal">
+
+                </div>
+
+
+                <div class="form-row" id="node-row-rampType">
+
+                    <label for="node-input-rampType"><i class="fa fa-sliders"></i> Ramp Type</label>
+
+                    <select id="node-input-rampType">
+
+                        <option value="none">No ramp</option>
+
+                        <option value="time">Ramp Time (s)</option>
+
+                        <option value="gradient_pct">Ramp Gradient (%/s)</option>
+
+                        <option value="gradient_w">Ramp Gradient (W/s & VAR/s)</option>
+
+                    </select>
+
+                </div>
+
+
+                <div class="form-row" id="node-row-rampGlobalType">
+
+                    <label for="node-input-rampTypeGlobalVar"><i class="fa fa-key"></i> Ramp Type Variable</label>
+
+                    <input type="text" id="node-input-rampTypeGlobalVar" placeholder="scada_ramp_type">
+
+                </div>
+
+
+                <div class="form-row" id="node-row-rampGlobalUpValue">
+
+                    <label for="node-input-rampUpGlobalVar"><i class="fa fa-key"></i> Ramp Up Variable</label>
+
+                    <input type="text" id="node-input-rampUpGlobalVar" placeholder="scada_ramp_up_value">
+
+                </div>
+
+
+                <div class="form-row" id="node-row-rampGlobalDownValue">
+
+                    <label for="node-input-rampDownGlobalVar"><i class="fa fa-key"></i> Ramp Down Variable</label>
+
+                    <input type="text" id="node-input-rampDownGlobalVar" placeholder="scada_ramp_down_value">
+
+                </div>
+
+
+                <input type="hidden" id="node-input-rampValue">
+
+                <div class="form-row" id="node-row-rampUpValue">
+
+                    <label for="node-input-rampUpValue"><i class="fa fa-level-up"></i> <span id="node-label-rampUpValue">Ramp Up Value</span></label>
+
+                    <input type="number" id="node-input-rampUpValue" min="0" placeholder="0 = no ramp on up">
+
+                </div>
+
+
+                <div class="form-row" id="node-row-rampDownValue">
+
+                    <label for="node-input-rampDownValue"><i class="fa fa-level-down"></i> <span id="node-label-rampDownValue">Ramp Down Value</span></label>
+
+                    <input type="number" id="node-input-rampDownValue" min="0" placeholder="0 = no ramp on down">
+
+                </div>
+
+            </div>
+
+        </div>
+
+
+        <div class="pr-section">
+
+            <div class="pr-section-title"><i class="fa fa-plug"></i> Inverters</div>
+
+            <p class="pr-section-note">Configureaza invertoarele active. Foloseste Add/Remove pentru randuri.</p>
+
+
+            <div class="pr-toolbar">
+
+                <button type="button" class="button" id="node-mi-add-inverter"><i class="fa fa-plus"></i> Add inverter</button>
+
+            </div>
+
+
+            <div class="mi-inverters-container">
+
+                <div class="mi-row mi-row-header">
+
+                    <div class="mi-col-index">#</div>
+
+                    <div class="mi-col-id">ID</div>
+
+                    <div class="mi-col-min">Min W&VAR</div>
+
+                    <div class="mi-col-max">Max W&VAR</div>
+
+                    <div class="mi-col-nominal">Nominal W</div>
+
+                    <div class="mi-col-enabled">Enabled</div>
+
+                    <div class="mi-col-actions">Actions</div>
+
+                </div>
+
+                <div id="node-input-inverters-container"></div>
+
+            </div>
+
+
+            <div class="form-row" id="node-multi-inverter-validation" style="display:none;"></div>
+
+        </div>
+
+
+        <div class="pr-section" id="mi-advanced-section" style="display:none;">
+
+            <div class="pr-section-title"><i class="fa fa-flask"></i> Additional Parameters</div>
+
+            <p class="pr-section-note">Timeout-uri, fail-safe si smoothing pentru scenarii speciale.</p>
+
+
+            <div class="pr-grid pr-grid-2">
+
+                <div class="form-row pr-span-2">
+
+                    <label for="node-input-siteLimitTopics"><i class="fa fa-sign-in"></i> Site Limit Topics</label>
+
+                    <input type="text" id="node-input-siteLimitTopics" placeholder="site-limit,control-export,control-reactive">
+
+                </div>
+
+
+                <div class="form-row pr-checkbox-row pr-span-2">
+
+                    <label for="node-input-publishTotalPvGlobal"><i class="fa fa-line-chart"></i> Publish Total PV Global</label>
+
+                    <input type="checkbox" id="node-input-publishTotalPvGlobal">
+
+                </div>
+
+
+                <div class="form-row pr-span-2" id="node-row-totalPvGlobalVar">
+
+                    <label for="node-input-totalPvGlobalVar"><i class="fa fa-globe"></i> Total PV Global Variable</label>
+
+                    <input type="text" id="node-input-totalPvGlobalVar" placeholder="total_pv">
+
+                </div>
+
+                <div class="form-row pr-checkbox-row pr-span-2">
+                    <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">Trimite intern alocarile si totalurile catre InfluxDB fara a modifica iesirea principala.</span>
+                </div>
+                <div class="form-row" id="node-row-influxMeasurement">
+                    <label for="node-input-influxMeasurement"><i class="fa fa-line-chart"></i> Measurement</label>
+                    <input type="text" id="node-input-influxMeasurement" placeholder="multi_inverter">
+                </div>
+                <div class="form-row" id="node-row-influxNode">
+                    <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">
+
+                    <label for="node-input-debugMode"><i class="fa fa-bug"></i> Debug</label>
+
+                    <select id="node-input-debugMode">
+
+                        <option value="off">Off</option>
+
+                        <option value="normal">Normal</option>
+
+                        <option value="verbose">Verbose</option>
+
+                    </select>
+
+                </div>
+
+
+                <div class="form-row">
+
+                    <label for="node-input-telemetryTimeoutMs"><i class="fa fa-clock-o"></i> Telemetry Timeout (ms)</label>
+
+                    <input type="number" id="node-input-telemetryTimeoutMs" min="0" placeholder="6000">
+
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-maxFutureTimestampMs"><i class="fa fa-clock-o"></i> Max Future Timestamp (ms)</label>
+                    <input type="number" id="node-input-maxFutureTimestampMs" min="0" placeholder="2000">
+                </div>
+
+
+                <div class="form-row">
+
+                    <label for="node-input-siteLimitTimeoutMs"><i class="fa fa-hourglass-half"></i> Site Limit Timeout (ms)</label>
+
+                    <input type="number" id="node-input-siteLimitTimeoutMs" min="0" placeholder="8000">
+
+                </div>
+
+
+                <div class="form-row">
+
+                    <label for="node-input-missingSiteLimitBehavior"><i class="fa fa-shield"></i> Missing Site Limit</label>
+
+                    <select id="node-input-missingSiteLimitBehavior">
+
+                        <option value="set_zero">Set zero</option>
+
+                        <option value="set_inverter_min">Set inverter min</option>
+
+                        <option value="fixed_value">Fixed value</option>
+
+                    </select>
+
+                </div>
+
+
+                <div class="form-row" id="node-row-missingSiteLimitValue">
+
+                    <label for="node-input-missingSiteLimitValueW"><i class="fa fa-bolt"></i> Missing Limit Value (W&VAR)</label>
+
+                    <input type="number" id="node-input-missingSiteLimitValueW" min="0" placeholder="0">
+
+                </div>
+
+
+                <div class="form-row">
+
+                    <label for="node-input-staleTelemetryBehavior"><i class="fa fa-unlink"></i> Missing Inverter Power</label>
+
+                    <select id="node-input-staleTelemetryBehavior">
+
+                        <option value="set_zero">Set zero</option>
+
+                        <option value="set_inverter_min">Set inverter min</option>
+
+                        <option value="fixed_value">Fixed value</option>
+
+                    </select>
+
+                </div>
+
+
+                <div class="form-row" id="node-row-staleTelemetryFixedValue">
+
+                    <label for="node-input-staleTelemetryFixedValueW"><i class="fa fa-bolt"></i> Missing Power Value (W&VAR)</label>
+
+                    <input type="number" id="node-input-staleTelemetryFixedValueW" min="0" placeholder="0">
+
+                </div>
+
+
+                <div class="form-row">
+
+                    <label for="node-input-telemetryFilterAlpha"><i class="fa fa-signal"></i> Telemetry Filter Alpha</label>
+
+                    <input type="text" id="node-input-telemetryFilterAlpha" placeholder="0.35">
+
+                </div>
+
+                <div class="form-row">
+
+                    <label for="node-input-allocationSmoothingAlpha"><i class="fa fa-filter"></i> Allocation Smoothing</label>
+
+                    <input type="text" id="node-input-allocationSmoothingAlpha" placeholder="0.35">
+
+                </div>
+
+                <div class="form-row">
+
+                    <label for="node-input-allocationDeadbandW"><i class="fa fa-arrows-h"></i> Allocation Deadband (W&VAR)</label>
+
+                    <input type="number" id="node-input-allocationDeadbandW" min="0" placeholder="300">
+
+                </div>
+
+                <div class="form-row">
+
+                    <label for="node-input-telemetryRecalcDebounceMs"><i class="fa fa-tachometer"></i> Telemetry Debounce (ms)</label>
+
+                    <input type="number" id="node-input-telemetryRecalcDebounceMs" min="0" placeholder="350">
+
+                </div>
+
+            </div>
+
+
+            <div class="form-row pr-checkbox-row">
+
+                <label for="node-input-waitForFreshTelemetryOnStartup"><i class="fa fa-hourglass-start"></i> Startup Wait</label>
+
+                <input type="checkbox" id="node-input-waitForFreshTelemetryOnStartup">
+
+                    <span class="pr-inline-note">Asteapta cel putin un invertor cu telemetrie fresh inainte de prima comanda operationala.</span>
+
+            </div>
+
+
+            <div class="form-row pr-checkbox-row">
+
+                <label for="node-input-recalculateOnTelemetry"><i class="fa fa-refresh"></i> Recalc On Telemetry</label>
+
+                <input type="checkbox" id="node-input-recalculateOnTelemetry">
+
+                <span class="pr-inline-note">Recalculeaza alocarea la update de telemetrie.</span>
+
+            </div>
+
+        </div>
+
+
+    </div>
+
+</script>
+
+
+
+<script type="text/html" data-help-name="multi-inverter">
+
+    <p>
+
+        Nodul <b>multi-inverter</b> imparte o limita totala de site catre mai multe invertoare.
+
+        Limita poate veni de la <code>control-export</code>, <code>control-reactive</code> sau de la orice nod
+
+        care trimite un payload cu <code>site_limit_w</code> sau <code>site_limit_var</code>.
+
+    </p>
+
+
+    <pre>control-export -> multi-inverter -> fronius-write inv1 / inv2 / inv3</pre>
+
+
+    <p>
+
+        Nodul primeste doua tipuri de mesaje: limita de site si telemetrie de invertor. Limita de site spune
+
+        cat are voie sa produca tot sistemul, iar telemetria spune cat produce fiecare invertor in momentul curent.
+
+        Pe baza acestor informatii, nodul calculeaza o limita separata pentru fiecare invertor.
+
+    </p>
+
+
+    <h3>Ce face nodul</h3>
+
+    <ul>
+
+        <li>primeste limita totala activa sau reactiva pentru site</li>
+
+        <li>primeste telemetrie de putere pentru fiecare invertor configurat</li>
+
+        <li>verifica ID-urile de invertor si intra in failsafe daca exista conflicte</li>
+
+        <li>imparte limita totala folosind strategia aleasa</li>
+
+        <li>respecta <code>Min W&amp;VAR</code> si <code>Max W&amp;VAR</code> pentru fiecare invertor</li>
+
+        <li>trimite rampa configurata catre nodurile de write</li>
+
+        <li>poate publica productia PV totala intr-o variabila globala</li>
+
+        <li>poate emite diagnostic pe o iesire suplimentara cand debug este activ</li>
+
+    </ul>
+
+
+    <h3>Input: limita de site</h3>
+
+    <p>
+
+        Un mesaj este tratat ca limita de site doar daca topicul este in lista <b>Site Limit Topics</b>
+
+        sau este unul dintre topicurile implicite: <code>site-limit</code>, <code>control-export</code>,
+
+        <code>control-reactive</code>.
+
+    </p>
+
+
+    <p>
+
+        Pentru control activ se foloseste <code>payload.site_limit_w</code>:
+
+    </p>
+
+
+    <pre>{
+
+  "topic": "site-limit",
+
+  "payload": {
+
+    "site_limit_w": 9000
+
+  }
+
+}</pre>
+
+
+    <p>
+
+        Pentru control reactiv se foloseste <code>payload.site_limit_var</code> sau <code>payload.limit_var</code>:
+
+    </p>
+
+
+    <pre>{
+
+  "topic": "control-reactive",
+
+  "payload": {
+
+    "site_limit_var": 3000
+
+  }
+
+}</pre>
+
+
+    <p>
+
+        Cand intra o limita activa, iesirea foloseste <code>limit_w</code>. Cand intra o limita reactiva,
+
+        iesirea foloseste <code>limit_var</code>. Semnul valorii reactive se pastreaza la iesire.
+
+    </p>
+
+
+    <h3>Input: telemetrie invertor</h3>
+
+    <p>
+
+        Telemetria de invertor trebuie sa contina un ID valid si o valoare numerica de putere.
+
+        ID-ul poate veni din <code>payload.inverter_id</code>, <code>payload.id</code>, <code>msg.inverter_id</code>,
+
+        <code>msg.id</code> sau <code>msg.topic</code>.
+
+    </p>
+
+
+    <pre>{
+
+  "topic": "inv1",
+
+  "payload": {
+
+    "inverter_id": "inv1",
+
+    "power_w": 3200
+
+  }
+
+}</pre>
+
+
+    <p>
+
+        Pentru putere activa, nodul cauta:
+
+        <code>power_w</code>, <code>active_power_w</code>, <code>p_w</code>,
+
+        <code>ac_active_power_w</code> sau <code>summary.ac.power_w</code>.
+
+    </p>
+
+
+    <p>
+
+        Pentru putere reactiva, nodul cauta:
+
+        <code>power_var</code>, <code>reactive_power_var</code>, <code>ac_reactive_power_var</code>,
+
+        <code>q_var</code>, <code>var</code>, <code>vars</code>, <code>limit_var</code>,
+
+        <code>site_limit_var</code> sau <code>summary.ac.reactive_power_var</code>.
+
+    </p>
+
+
+    <h3>Validare ID</h3>
+
+    <p>
+
+        ID-ul din telemetrie trebuie sa corespunda exact cu ID-ul configurat in lista de invertoare.
+
+        Daca sunt trimise mai multe surse de ID in acelasi mesaj, ele trebuie sa fie identice.
+
+    </p>
+
+
+    <ul>
+
+        <li>daca lipseste ID-ul, nodul emite failsafe</li>
+
+        <li>daca <code>topic</code> difera de <code>inverter_id</code>, nodul emite failsafe</li>
+
+        <li>daca ID-ul nu exista in lista configurata, nodul emite failsafe</li>
+
+        <li>daca acelasi ID apare din doua surse diferite cu valori diferite, nodul emite failsafe</li>
+
+    </ul>
+
+
+    <p>
+
+        Failsafe inseamna ca nodul trimite limite zero pentru invertoarele valide, ca sa evite comenzi ambigue.
+
+    </p>
+
+
+    <h3>Configurare invertoare</h3>
+
+    <p>
+
+        Fiecare rand din lista de invertoare are:
+
+    </p>
+
+
+    <ul>
+
+        <li><b>ID</b> - identificatorul folosit in telemetrie si in iesirea catre nodul de write.</li>
+
+        <li><b>Min W&amp;VAR</b> - limita minima permisa pentru acel invertor.</li>
+
+        <li><b>Max W&amp;VAR</b> - limita maxima permisa pentru acel invertor.</li>
+
+        <li><b>Enabled</b> - daca este debifat, invertorul ramane in lista, dar primeste limita 0.</li>
+
+    </ul>
+
+
+    <p>
+
+        ID-urile active trebuie sa fie unice. Un rand activ fara ID, cu <code>Max</code> invalid sau cu
+
+        <code>Min</code> mai mare decat <code>Max</code> face configuratia invalida.
+
+    </p>
+
+
+    <h3>Allocation Strategy</h3>
+
+    <p>
+
+        Strategia decide cum este impartita limita totala intre invertoarele active.
+
+    </p>
+
+
+    <ul>
+
+        <li><b>Current power</b> imparte proportional cu puterea curenta masurata. Daca lipseste telemetria fresh, foloseste automat <b>Max power</b>.</li>
+
+        <li><b>Max power</b> imparte proportional cu puterea maxima configurata pentru fiecare invertor.</li>
+
+        <li><b>Equal share</b> imparte limita in mod egal intre invertoarele active.</li>
+
+        <li><b>Headroom</b> imparte proportional cu spatiul ramas pana la <code>Max</code>, adica <code>Max - putere curenta</code>.</li>
+
+    </ul>
+
+
+    <p>
+
+        Dupa impartire, fiecare limita este taiata intre minimul si maximul invertorului. Daca limita de site
+
+        este mai mare decat capacitatea totala disponibila, campul <code>clipped</code> devine <code>true</code>.
+
+    </p>
+
+
+    <h3>Ramp</h3>
+
+    <p>
+
+        Setarea de rampa este propagata in payload-ul fiecarei limite. Nodul nu aplica local rampa;
+
+        doar transmite instructiunea catre nodurile de write.
+
+    </p>
+
+
+    <ul>
+
+        <li><b>No ramp</b> nu trimite campul <code>ramp</code>.</li>
+
+        <li><b>Ramp Time (s)</b> trimite durata de aplicare a comenzii.</li>
+
+        <li><b>Ramp Gradient (%/s)</b> trimite gradient procentual.</li>
+
+        <li><b>Ramp Gradient (W/s &amp; VAR/s)</b> trimite gradient absolut pentru putere activa sau reactiva.</li>
+
+    </ul>
+
+    <h3>Comenzi SCADA globale</h3>
+
+    <p>Cu <b>Ramp From Global</b> activ, nodul citește <code>scada_ramp_type</code>, <code>scada_ramp_up_value</code> și <code>scada_ramp_down_value</code>, publicate de <code>scada-server</code>. Valorile sunt direcționale și trebuie să fie pozitive: Up pentru creșterea limitei, Down pentru scăderea ei.</p>
+
+    <ul>
+        <li><code>scada_ramp_type = 0</code>: fără rampă; <code>1</code>: timp fix în secunde; <code>2</code>: gradient în %/s; <code>3</code>: gradient în W/s pentru P sau VAr/s pentru Q.</li>
+        <li>Pentru tipul <code>2</code>, fiecare valoare de rampă trebuie să fie în domeniul <code>0…100 %/s</code>.</li>
+        <li>O comandă Q procentuală, dacă este folosită de un nod de control din aval, are domeniul <code>-100…+100 %</code>; un setpoint Q în VAr rămâne semnat și este limitat de puterea reactivă nominală a echipamentului.</li>
+    </ul>
+
+
+    <h3>Telemetrie si timeout</h3>
+
+    <p>
+
+        <b>Telemetry Timeout (ms)</b> decide cat timp este considerata valida telemetria unui invertor.
+
+        Daca valoarea este <code>0</code>, telemetria este considerata mereu fresh.
+
+    </p>
+
+
+    <p>
+
+        Pentru timestamp, nodul cauta <code>msg.timestamp</code>, <code>msg.ts</code>, <code>msg.time</code>
+
+        sau variantele echivalente din <code>msg.payload</code>. Daca lipseste timestamp-ul, se foloseste timpul curent.
+
+    </p>
+
+
+    <h3>Site Limit Timeout</h3>
+
+    <p>
+
+        <b>Site Limit Timeout (ms)</b> decide cat timp este valida ultima limita de site primita.
+
+        Daca limita lipseste sau expira, nodul foloseste politica <b>Missing Site Limit</b>.
+
+    </p>
+
+
+    <ul>
+
+        <li><b>Set zero</b> trimite 0 catre fiecare invertor activ.</li>
+
+        <li><b>Set inverter min</b> trimite minimul configurat pentru fiecare invertor activ.</li>
+
+        <li><b>Fixed value</b> trimite valoarea configurata la <b>Missing Limit Value</b>, taiata la maximul fiecarui invertor.</li>
+
+    </ul>
+
+
+    <h3>Missing Inverter Power</h3>
+
+    <p>
+
+        Daca un invertor nu are telemetrie fresh, nodul aplica politica <b>Missing Inverter Power</b>
+
+        pentru acel invertor.
+
+    </p>
+
+
+    <ul>
+
+        <li><b>Set zero</b> trimite 0 catre invertorul fara telemetrie.</li>
+
+        <li><b>Set inverter min</b> trimite minimul configurat pentru acel invertor.</li>
+
+        <li><b>Fixed value</b> trimite valoarea configurata la <b>Missing Power Value</b>, taiata la maximul invertorului.</li>
+
+    </ul>
+
+
+    <h3>Startup Wait</h3>
+
+    <p>
+
+        Cand <b>Startup Wait</b> este activ, nodul asteapta pana primeste telemetrie fresh de la cel putin un invertor activ
+
+        inainte de prima alocare operationala. Daca alte invertoare sunt stale, ele sunt tratate prin politica <b>Missing Inverter Power</b>.
+
+    </p>
+
+
+    <h3>Recalc On Telemetry</h3>
+
+    <p>
+
+        Cand <b>Recalc On Telemetry</b> este activ, nodul recalculeaza alocarea si la update-uri de telemetrie,
+
+        nu doar cand primeste o limita noua de site. <b>Telemetry Debounce</b> grupeaza update-urile foarte dese.
+
+    </p>
+
+
+    <h3>Allocation Smoothing</h3>
+
+    <p>
+
+        <b>Allocation Smoothing</b> reduce salturile intre alocari consecutive. Valoarea este intre
+
+        <code>0.01</code> si <code>1</code>. Valoarea <code>1</code> inseamna fara smoothing, iar valori mai mici
+
+        fac tranzitia mai lenta.
+
+    </p>
+
+
+    <h3>Total PV Global</h3>
+
+    <p>
+
+        Cand <b>Publish Total PV Global</b> este activ, nodul aduna puterea activa fresh a invertoarelor valide
+
+        si scrie totalul in variabila globala configurata, implicit <code>total_pv</code>.
+
+    </p>
+
+
+    <p>
+
+        Aceasta valoare poate fi folosita de <code>control-export</code> pentru <b>Dynamic PV Cap</b>.
+
+    </p>
+
+
+    <h3>Iesiri</h3>
+
+    <p>
+
+        Prima iesire trimite mesajul agregat pentru toate invertoarele. Daca debug este activ, apare o iesire
+
+        suplimentara cu diagnostic. Numarul de iesiri afisat in editor se actualizeaza in functie de debug.
+
+    </p>
+
+
+    <h3>Exemplu Output</h3>
+
+    <pre>{
+
+  "topic": "multi-inverter/limits",
+
+  "payload": {
+
+    "limits": [
+
+      {
+
+        "id": "inv1",
+
+        "enabled": true,
+
+        "min_w": 0,
+
+        "max_w": 5000,
+
+        "current_power_w": 3200,
+
+        "current_power_fresh": true,
+
+        "limit_w": 2500,
+
+        "ramp": { "type": "gradient_w", "value": 500 }
+
+      },
+
+      {
+
+        "id": "inv2",
+
+        "enabled": true,
+
+        "min_w": 0,
+
+        "max_w": 5000,
+
+        "current_power_w": 1800,
+
+        "current_power_fresh": true,
+
+        "limit_w": 2500,
+
+        "ramp": { "type": "gradient_w", "value": 500 }
+
+      }
+
+    ],
+
+    "site_limit_w": 5000,
+
+    "site_limit_var": null,
+
+    "control_mode": "active",
+
+    "allocation_strategy": "current_power",
+
+    "effective_strategy": "current_power",
+
+    "stale_inputs": [],
+
+    "fresh_power_map": {
+
+      "inv1": 3200,
+
+      "inv2": 1800
+
+    },
+
+    "total_fresh_power_w": 5000,
+
+    "available_capacity_w": 10000,
+
+    "unallocated_w": 0,
+
+    "clipped": false,
+
+    "active_inverters": ["inv1", "inv2"],
+
+    "ramp": { "type": "gradient_w", "value": 500 },
+
+    "timestamp_ms": 1776692400000
+
+  }
+
+}</pre>
+
+
+    <h3>Output catre fronius-write</h3>
+
+    <p>
+
+        Nodul <code>fronius-write</code> in modul Multi-inverter cauta limita pentru propriul
+
+        <b>Inverter ID</b> in <code>payload.limits</code>. ID-ul configurat in <code>fronius-write</code>
+
+        trebuie sa fie identic cu ID-ul din lista <code>multi-inverter</code>.
+
+    </p>
+
+
+    <h3>Debug</h3>
+
+    <p>
+
+        Debug <b>Normal</b> trimite diagnostic la schimbari de stare sau cand motivul nu este alocare normala.
+
+        Debug <b>Verbose</b> trimite diagnostic la fiecare calcul.
+
+    </p>
+
+
+    <p>
+
+        Mesajul de diagnostic are topic <code>multi-inverter/diagnostic</code> si include starea configuratiei,
+
+        strategia efectiva, invertoarele stale, alocarile calculate, capacitatea disponibila si motivul deciziei.
+
+    </p>
+
+
+    <h3>Status in editor</h3>
+
+    <ul>
+
+        <li><b>verde</b> inseamna alocare normala.</li>
+
+        <li><b>galben</b> inseamna telemetrie lipsa, startup wait sau site limit lipsa.</li>
+
+        <li><b>rosu</b> inseamna configuratie invalida, ID conflict sau failsafe.</li>
+
+    </ul>
+
+
+    <h3>Recomandari practice</h3>
+
+    <ul>
+
+        <li>Foloseste aceleasi ID-uri in <code>fronius-read</code>, <code>multi-inverter</code> si <code>fronius-write</code>.</li>
+
+        <li>Pentru sisteme similare, <b>Max power</b> sau <b>Equal share</b> sunt cele mai usor de verificat.</li>
+
+        <li>Pentru sisteme cu invertoare diferite, <b>Max power</b> imparte mai corect dupa capacitate.</li>
+
+        <li>Pentru limitare dinamica dupa productie reala, foloseste <b>Current power</b> si telemetrie fresh.</li>
+
+        <li>In modul <b>Current power</b>, ponderile folosesc puterea filtrata prin <b>Telemetry Filter Alpha</b>; campul <code>current_power_w</code> ramane masurarea bruta, iar <code>allocation_power_w</code> arata valoarea folosita la impartire.</li>
+
+        <li>Comenzile noi de site-limit sunt aplicate imediat; Allocation Smoothing este folosit doar la redistribuirea produsa de telemetrie.</li>
+
+        <li>Pentru control-export/reactive closed-loop rapid, foloseste No ramp sau o rampa suficient de rapida. O rampa lenta introduce intarziere si poate produce supracorectie.</li>
+
+        <li>Pastreaza <b>Startup Wait</b> activ daca vrei sa eviti o comanda initiala fara niciun invertor cu telemetrie fresh.</li>
+
+        <li>Activeaza debug temporar cand verifici alocarea sau ID-urile, apoi revino la <b>Off</b>.</li>
+
+    </ul>
+
+    <h3>Referinta completa parametri</h3>
+    <ul>
+        <li><code>strategy</code>: strategia de alocare intre invertoare.</li>
+        <li><code>siteLimitTopics</code>: topic-urile tratate ca limita de site.</li>
+        <li><code>telemetryTimeoutMs</code>: vechimea maxima a telemetriei de invertor.</li>
+        <li><code>maxFutureTimestampMs</code>: toleranta pentru timestamp-uri din viitor.</li>
+        <li><code>siteLimitTimeoutMs</code>: vechimea maxima a ultimei limite de site.</li>
+        <li><code>missingSiteLimitBehavior</code> si <code>missingSiteLimitValueW</code>: fallback cand limita de site lipseste.</li>
+        <li><code>staleTelemetryBehavior</code> si <code>staleTelemetryFixedValueW</code>: fallback pentru invertor fara telemetrie fresh.</li>
+        <li><code>waitForFreshTelemetryOnStartup</code>: asteapta telemetrie fresh dupa deploy.</li>
+        <li><code>recalculateOnTelemetry</code>: recalculeaza si la update-uri de telemetrie, nu doar la limita noua.</li>
+        <li><code>telemetryFilterAlpha</code>: filtreaza numai ponderile strategiei Current power; valori mai mici reduc redistribuirile rapide fara a modifica totalul PV publicat.</li>
+        <li><code>rampType</code> si <code>rampValue</code>: rampa de baza trimisa catre write.</li>
+        <li><code>rampFromGlobal</code>, <code>rampTypeGlobalVar</code>, <code>rampUpGlobalVar</code>, <code>rampDownGlobalVar</code>: citesc tipul si valorile directionale din context global.</li>
+        <li><code>rampUpValue</code> si <code>rampDownValue</code>: suprascriu rampa de baza pentru crestere sau scadere de limita.</li>
+        <li><code>allocationSmoothingAlpha</code>: filtrare a alocarii pentru a reduce salturile.</li>
+        <li><code>allocationDeadbandW</code>: pastreaza ultima limita emisa daca schimbarea este mai mica decat pragul.</li>
+        <li><code>telemetryRecalcDebounceMs</code>: grupeaza recalcularile declansate de telemetrie rapida.</li>
+        <li><code>debugMode</code>: nivelul iesirii de diagnostic.</li>
+        <li><code>publishTotalPvGlobal</code> si <code>totalPvGlobalVar</code>: publica totalul PV fresh in context global.</li>
+        <li><code>inverters</code>: lista de invertoare, cu ID, min, max si enabled.</li>
+        <li><code>inverters-container</code>: zona editorului in care sunt randate randurile din lista <code>inverters</code>.</li>
+    </ul>
+
+    <h3>Model recomandat pentru control stabil de grid set point</h3>
+    <pre>{
+  "telemetryTimeoutMs": 6000,
+  "siteLimitTimeoutMs": 8000,
+  "telemetryFilterAlpha": 0.35,
+  "allocationSmoothingAlpha": 0.35,
+  "allocationDeadbandW": 300,
+  "telemetryRecalcDebounceMs": 350,
+  "rampType": "none"
+}</pre>
+    <p>Acest model tolereaza jitter-ul normal de comunicatie, filtreaza ponderile Current power si reduce retrimiterile foarte mici, lasand <code>control-export</code> sa fie regulatorul principal. Timeouturile nu schimba politicile de siguranta: dupa expirare se aplica in continuare fallback-ul configurat.</p>
+
+
+</script>
+
+
+
+<style>
+
+    .multi-inverter-editor {
+
+        --pr-border: #d7dde5;
+
+        --pr-muted: #667085;
+
+        --pr-surface: #f8fafc;
+
+        --mi-invalid: #d9534f;
+
+    }
+
+
+    .multi-inverter-editor .pr-section {
+
+        margin: 0 0 18px;
+
+        padding: 14px 16px 16px;
+
+        border: 1px solid var(--pr-border);
+
+        border-radius: 10px;
+
+        background: var(--pr-surface);
+
+    }
+
+
+    .multi-inverter-editor .pr-section-title {
+
+        display: flex;
+
+        align-items: center;
+
+        gap: 8px;
+
+        margin: 0 0 4px;
+
+        font-size: 15px;
+
+        font-weight: 600;
+
+        color: #243447;
+
+    }
+
+
+    .multi-inverter-editor .pr-section-note {
+
+        margin: 0 0 14px;
+
+        color: var(--pr-muted);
+
+        font-size: 12px;
+
+        line-height: 1.45;
+
+    }
+
+
+    .multi-inverter-editor .pr-grid {
+
+        display: grid;
+
+        grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+
+        gap: 12px 16px;
+
+    }
+
+
+    .multi-inverter-editor .pr-grid-2 {
+
+        grid-template-columns: repeat(2, minmax(320px, 1fr));
+
+    }
+
+
+    .multi-inverter-editor .pr-span-2 {
+
+        grid-column: 1 / -1;
+
+    }
+
+
+    .multi-inverter-editor .form-row {
+
+        margin-bottom: 12px;
+
+    }
+
+
+    .multi-inverter-editor .pr-grid .form-row,
+
+    .multi-inverter-editor .form-row:last-child {
+
+        margin-bottom: 0;
+
+    }
+
+
+    .multi-inverter-editor .form-row > label {
+
+        width: 150px;
+
+        font-weight: 600;
+
+    }
+
+
+    .multi-inverter-editor .form-row > input[type="text"],
+
+    .multi-inverter-editor .form-row > input[type="number"],
+
+    .multi-inverter-editor .form-row > select {
+
+        width: calc(100% - 160px);
+
+    }
+
+
+    .multi-inverter-editor .pr-checkbox-row > input[type="checkbox"] {
+
+        display: inline-block;
+
+        width: auto;
+
+        vertical-align: top;
+
+    }
+
+
+    .multi-inverter-editor .pr-inline-note {
+
+        margin-left: 8px;
+
+        color: var(--pr-muted);
+
+        line-height: 1.4;
+
+    }
+
+
+    .multi-inverter-editor .fronius-meta-info {
+
+        color: var(--pr-muted);
+
+        line-height: 1.45;
+
+        padding-top: 2px;
+
+    }
+
+
+    .multi-inverter-editor .pr-toolbar {
+
+        display: flex;
+
+        flex-wrap: wrap;
+
+        gap: 8px;
+
+        margin-bottom: 10px;
+
+        align-items: center;
+
+    }
+
+
+    .multi-inverter-editor #node-mi-add-inverter {
+
+        user-select: none;
+
+        -webkit-user-select: none;
+
+        -webkit-touch-callout: none;
+
+    }
+
+
+    .multi-inverter-editor .mi-inverters-container {
+
+        border: 1px solid var(--pr-border);
+
+        border-radius: 10px;
+
+        background: #fff;
+
+        padding: 10px;
+
+    }
+
+
+    .multi-inverter-editor .mi-row {
+
+        display: grid;
+
+        grid-template-columns: 32px 1.2fr 0.9fr 0.9fr 0.9fr 92px 80px;
+
+        gap: 8px;
+
+        align-items: center;
+
+        margin-bottom: 8px;
+
+    }
+
+
+    .multi-inverter-editor .mi-inverters-container.mi-compact .mi-row {
+
+        gap: 6px;
+
+        margin-bottom: 6px;
+
+    }
+
+
+    .multi-inverter-editor .mi-inverters-container.mi-compact .mi-row > input[type="text"],
+
+    .multi-inverter-editor .mi-inverters-container.mi-compact .mi-row > input[type="number"] {
+
+        height: 30px;
+
+        padding: 3px 6px;
+
+        font-size: 12px;
+
+    }
+
+
+    .multi-inverter-editor .mi-inverters-container.mi-compact .mi-row-remove {
+
+        min-width: 64px;
+
+        padding: 3px 6px;
+
+    }
+
+
+    .multi-inverter-editor #node-input-inverters-container {
+
+        margin-top: 8px;
+
+    }
+
+
+    .multi-inverter-editor .mi-row:last-child {
+
+        margin-bottom: 0;
+
+    }
+
+
+    .multi-inverter-editor .mi-row-header {
+
+        margin-bottom: 6px;
+
+        padding-bottom: 8px;
+
+        border-bottom: 1px solid var(--pr-border);
+
+        font-size: 12px;
+
+        font-weight: 700;
+
+        color: #344054;
+
+    }
+
+
+    .multi-inverter-editor .mi-col-index {
+
+        text-align: center;
+
+        color: #667085;
+
+        font-weight: 600;
+
+    }
+
+
+    .multi-inverter-editor .mi-col-enabled,
+
+    .multi-inverter-editor .mi-col-actions {
+
+        text-align: center;
+
+    }
+
+
+    .multi-inverter-editor .mi-enabled-toggle {
+
+        display: flex;
+
+        align-items: center;
+
+        justify-content: center;
+
+        margin: 0;
+
+        font-weight: 400;
+
+        width: 100%;
+
+        height: 100%;
+
+        justify-self: center;
+
+        align-self: center;
+
+    }
+
+
+    .multi-inverter-editor .mi-enabled-toggle > input[type="checkbox"] {
+
+        display: block;
+
+        width: auto;
+
+        margin: 0 auto;
+
+        flex: 0 0 auto;
+
+    }
+
+
+    .multi-inverter-editor .mi-ramp-global-toggle {
+
+        padding-bottom: 10px;
+
+        border-bottom: 1px solid var(--pr-border);
+
+    }
+
+
+    .multi-inverter-editor #node-row-rampGlobalType > label,
+
+    .multi-inverter-editor #node-row-rampGlobalUpValue > label,
+
+    .multi-inverter-editor #node-row-rampGlobalDownValue > label {
+
+        width: 165px;
+
+    }
+
+
+    .multi-inverter-editor #node-row-rampGlobalType > input,
+
+    .multi-inverter-editor #node-row-rampGlobalUpValue > input,
+
+    .multi-inverter-editor #node-row-rampGlobalDownValue > input {
+
+        width: calc(100% - 175px);
+
+    }
+
+
+    .multi-inverter-editor .mi-row-remove {
+
+        min-width: 72px;
+
+    }
+
+
+    .multi-inverter-editor .mi-row > input[type="text"],
+
+    .multi-inverter-editor .mi-row > input[type="number"] {
+
+        width: 100%;
+
+        min-width: 0;
+
+    }
+
+
+    .multi-inverter-editor #node-multi-inverter-validation {
+
+        color: var(--mi-invalid);
+
+        font-weight: 600;
+
+    }
+
+
+    .multi-inverter-editor .mi-invalid {
+
+        border-color: var(--mi-invalid) !important;
+
+    }
+
+
+    .multi-inverter-editor .mi-row-invalid {
+
+        background: rgba(217, 83, 79, 0.06);
+
+        border-radius: 8px;
+
+        padding: 6px;
+
+    }
+
+
+    @media (max-width: 1100px) {
+
+        .multi-inverter-editor .pr-grid-2 {
+
+            grid-template-columns: 1fr;
+
+        }
+
+
+        .multi-inverter-editor .mi-row {
+
+            grid-template-columns: 32px 1fr;
+
+        }
+
+
+        .multi-inverter-editor .mi-row-header {
+
+            display: none;
+
+        }
+
+
+        .multi-inverter-editor .mi-row-remove {
+
+            justify-self: start;
+
+        }
+
+    }
+
+</style>