@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/control-export/control-export.html

@@ -0,0 +1,3644 @@
+<script type="text/javascript">
+
+
+    const controlExportDefinition = {
+
+
+        category: 'Atelierul de Tehnologii',
+
+
+        color: '#2a9d8f',
+
+
+        defaults: {
+            license: { value: "", type: "atelier-license", required: true },
+
+
+            name: { value: "" },
+
+
+            mode: { value: "zero_feed_in" },
+
+            zeroFeedInMode: { value: "relative" },
+
+            requireAllPhases: { value: true },
+
+            tuningPreset: { value: "normal" },
+
+
+            gridSetPoint: { value: 0, validate: RED.validators.number() },
+
+
+            nominalPower: { value: 1000, validate: RED.validators.number() },
+
+            nominalPowerFromGlobal: { value: false },
+
+            nominalPowerGlobalVar: {
+
+                value: "nominal_power",
+
+                validate: function(v) {
+
+                    const useGlobal = $("#node-input-nominalPowerFromGlobal").is(":checked");
+
+                    return !useGlobal || String(v || "").trim().length > 0;
+
+                }
+
+            },
+
+
+            signConvention: { value: "positive_import" },
+
+
+            deadband: { value: 180, validate: RED.validators.number() },
+
+
+            minLimit: { value: 0, validate: RED.validators.number() },
+
+
+            maxLimit: { value: 1000, validate: RED.validators.number() },
+
+            maxLimitFromGlobal: { value: false },
+
+            maxLimitGlobalVar: {
+
+                value: "max_limit",
+
+                validate: function(v) {
+
+                    const useGlobal = $("#node-input-maxLimitFromGlobal").is(":checked");
+
+                    return !useGlobal || String(v || "").trim().length > 0;
+
+                }
+
+            },
+
+
+            outputTopic: { value: "site-limit" },
+
+
+            smoothingAlpha: {
+
+                value: 0.15,
+
+                validate: function(v) {
+
+                    const n = Number(v);
+
+                    return Number.isFinite(n) && n >= 0 && n <= 1;
+
+                }
+
+            },
+
+
+            filterTauMs: { value: 2800, validate: RED.validators.number() },
+
+
+            kp: { value: 0.22, validate: RED.validators.number() },
+
+
+            ki: { value: 0.01, validate: RED.validators.number() },
+
+
+            controlPeriodMs: { value: 800, validate: RED.validators.number() },
+
+            exportThresholdW: { value: 60, validate: RED.validators.number() },
+
+
+            recoverThresholdW: { value: 25, validate: RED.validators.number() },
+
+
+            recoveryDelayMs: { value: 3000, validate: RED.validators.number() },
+
+            transientIgnoreMs: { value: 1200, validate: RED.validators.number() },
+
+            maxStepUpW: { value: 500, validate: RED.validators.number() },
+
+            maxStepDownW: { value: 1500, validate: RED.validators.number() },
+
+            adaptiveGains: { value: true },
+
+            adaptiveErrorBandW: { value: 4000, validate: RED.validators.number() },
+
+            adaptiveMinScale: { value: 0.2, validate: RED.validators.number() },
+
+
+            maxStepW: { value: 0, validate: RED.validators.number() },
+
+
+            staleTimeoutMs: { value: 5000, validate: RED.validators.number() },
+
+            maxFutureTimestampMs: { value: 2000, validate: RED.validators.number() },
+
+            fastSetpointMaxTelemetryAgeMs: { value: 600, validate: RED.validators.number() },
+
+            outputHeartbeatMs: { value: 2000, validate: RED.validators.number() },
+
+
+            safeLimitOnStale: { value: 0, validate: RED.validators.number() },
+
+            debugLevel: { value: "off" },
+
+            startLimitMode: { value: "last_limit" },
+
+            useGlobalPvCap: { value: false },
+
+            globalPvTotalVar: { value: "total_pv" },
+
+            globalPvCapOffsetW: {
+
+                value: 500,
+
+                validate: function(v) {
+
+                    return Number(v) >= 0;
+
+                }
+
+            },
+            pvCapOnlyBlocksIncrease: { value: true },
+            pvCapHoldMs: { value: 10000, validate: RED.validators.number() },
+            pvCapReleaseWPerSec: { value: 1000, validate: RED.validators.number() },
+            feedForwardEnabled: { value: true },
+            feedForwardGain: {
+                value: 0.85,
+                validate: function(v) {
+                    const n = Number(v);
+                    return Number.isFinite(n) && n >= 0 && n <= 1.5;
+                }
+            },
+
+            failSecureEnabled: { value: false },
+
+            failSecureTimeSec: {
+
+                value: 10,
+
+                validate: function(v) {
+
+                    return Number(v) >= 1;
+
+                }
+
+            },
+
+            a3TestsEnabled: { value: false },
+
+            a3ModbusHost: { value: "0.0.0.0" },
+
+            a3ModbusPort: { value: 1502, validate: RED.validators.number() },
+
+            a3ModbusUnitId: { value: 1, validate: RED.validators.number() },
+
+            a3RampType: { value: "none" },
+
+            a3RampValue: { value: 0, validate: RED.validators.number() }
+
+
+        },
+
+
+        inputs: 1,
+
+
+        outputs: 1,
+
+
+        icon: "font-awesome/fa-exchange",
+
+
+        label: function () {
+
+            return this.name || "control-export";
+
+        },
+
+
+        oneditprepare: function () {
+
+
+            const tuningPresets = {
+
+                normal: {
+
+                    deadband: 180,
+
+                    filterTauMs: 2800,
+
+                    kp: 0.22,
+
+                    ki: 0.01,
+
+                    controlPeriodMs: 800,
+
+                    exportThresholdW: 60,
+
+                    recoverThresholdW: 25,
+
+                    recoveryDelayMs: 3000,
+
+                    transientIgnoreMs: 1200,
+
+                    maxStepUpW: 500,
+
+                    maxStepDownW: 1500,
+
+                    adaptiveGains: true,
+
+                    adaptiveErrorBandW: 4000,
+
+                    adaptiveMinScale: 0.2
+
+                },
+
+                stable_grid: {
+
+                    deadband: 150,
+
+                    filterTauMs: 1500,
+
+                    kp: 0.24,
+
+                    ki: 0.008,
+
+                    controlPeriodMs: 1000,
+
+                    exportThresholdW: 100,
+
+                    recoverThresholdW: 40,
+
+                    recoveryDelayMs: 2000,
+
+                    transientIgnoreMs: 800,
+
+                    maxStepUpW: 1000,
+
+                    maxStepDownW: 1800,
+
+                    adaptiveGains: true,
+
+                    adaptiveErrorBandW: 5000,
+
+                    adaptiveMinScale: 0.45
+
+                }
+
+            };
+
+            const tuningFieldSelector = "#node-input-deadband, #node-input-filterTauMs, #node-input-kp, #node-input-ki, #node-input-recoveryDelayMs, #node-input-transientIgnoreMs, #node-input-maxStepUpW, #node-input-maxStepDownW, #node-input-adaptiveErrorBandW, #node-input-adaptiveMinScale";
+
+            const validationFieldSelector = "#node-input-minLimit, #node-input-maxLimit, #node-input-exportThresholdW, #node-input-recoverThresholdW, #node-input-ki, #node-input-deadband, #node-input-staleTimeoutMs, #node-input-controlPeriodMs, #node-input-filterTauMs, #node-input-kp, #node-input-transientIgnoreMs, #node-input-maxStepUpW, #node-input-maxStepDownW, #node-input-adaptiveErrorBandW, #node-input-adaptiveMinScale, #node-input-outputHeartbeatMs";
+
+            let applyingPreset = false;
+
+            let editorReady = false;
+
+            let customDefaultsSeeded = false;
+
+
+            function applyPreset(presetKey) {
+
+                const preset = tuningPresets[presetKey];
+
+                if (!preset) return;
+
+
+                applyingPreset = true;
+
+                $("#node-input-deadband").val(preset.deadband);
+
+                $("#node-input-filterTauMs").val(preset.filterTauMs);
+
+                $("#node-input-kp").val(preset.kp);
+
+                $("#node-input-ki").val(preset.ki);
+
+                $("#node-input-controlPeriodMs").val(preset.controlPeriodMs);
+
+                $("#node-input-exportThresholdW").val(preset.exportThresholdW);
+
+                $("#node-input-recoverThresholdW").val(preset.recoverThresholdW);
+
+                $("#node-input-recoveryDelayMs").val(preset.recoveryDelayMs);
+
+                $("#node-input-transientIgnoreMs").val(preset.transientIgnoreMs);
+
+                $("#node-input-maxStepUpW").val(preset.maxStepUpW);
+
+                $("#node-input-maxStepDownW").val(preset.maxStepDownW);
+
+                $("#node-input-adaptiveGains").prop("checked", !!preset.adaptiveGains);
+
+                $("#node-input-adaptiveErrorBandW").val(preset.adaptiveErrorBandW);
+
+                $("#node-input-adaptiveMinScale").val(preset.adaptiveMinScale);
+
+                applyingPreset = false;
+
+                const adaptiveEnabled = $("#node-input-adaptiveGains").is(":checked");
+
+                $("#row-adaptive-error-band, #row-adaptive-min-scale").toggle(adaptiveEnabled);
+
+                showValidation();
+
+            }
+
+
+            function markCustomPreset() {
+
+                if (!editorReady) return;
+
+                if (applyingPreset) return;
+
+                if ($("#node-input-tuningPreset").val() !== "custom") {
+
+                    $("#node-input-tuningPreset").val("custom");
+
+                    toggleFields();
+
+                }
+
+            }
+
+
+            function showValidation() {
+
+                const minLimit = Number($("#node-input-minLimit").val() || 0);
+
+                const maxLimit = Number($("#node-input-maxLimit").val() || 0);
+
+                const exportThreshold = Number($("#node-input-exportThresholdW").val() || 0);
+
+                const recoverThreshold = Number($("#node-input-recoverThresholdW").val() || 0);
+
+                const ki = Number($("#node-input-ki").val() || 0);
+
+                const kp = Number($("#node-input-kp").val() || 0);
+
+                const deadband = Number($("#node-input-deadband").val() || 0);
+
+                const staleTimeoutMs = Number($("#node-input-staleTimeoutMs").val() || 0);
+
+                const controlPeriodMs = Number($("#node-input-controlPeriodMs").val() || 0);
+
+                const filterTauMs = Number($("#node-input-filterTauMs").val() || 0);
+
+                const transientIgnoreMs = Number($("#node-input-transientIgnoreMs").val() || 0);
+
+                const outputHeartbeatMs = Number($("#node-input-outputHeartbeatMs").val() || 0);
+
+                const maxStepUpW = Number($("#node-input-maxStepUpW").val() || 0);
+
+                const maxStepDownW = Number($("#node-input-maxStepDownW").val() || 0);
+
+                const adaptiveErrorBandW = Number($("#node-input-adaptiveErrorBandW").val() || 0);
+
+                const adaptiveMinScale = Number($("#node-input-adaptiveMinScale").val() || 0);
+
+                const failSecureTimeSec = Number($("#node-input-failSecureTimeSec").val() || 0);
+
+                const failSecureEnabled = $("#node-input-failSecureEnabled").is(":checked");
+                const a3Enabled = $("#node-input-a3TestsEnabled").is(":checked");
+                const a3Port = Number($("#node-input-a3ModbusPort").val() || 0);
+                const a3UnitId = Number($("#node-input-a3ModbusUnitId").val() || 0);
+                const a3RampValue = Number($("#node-input-a3RampValue").val() || 0);
+
+                const mode = $("#node-input-mode").val();
+
+                const pvCapSupported = mode !== "nominal_power";
+
+                const useGlobalPvCap = pvCapSupported && $("#node-input-useGlobalPvCap").is(":checked");
+                const feedForwardEnabled = pvCapSupported && $("#node-input-feedForwardEnabled").is(":checked");
+
+                const globalPvTotalVar = String($("#node-input-globalPvTotalVar").val() || "").trim();
+
+                const globalPvCapOffsetW = Number($("#node-input-globalPvCapOffsetW").val() || 0);
+                const pvCapHoldMs = Number($("#node-input-pvCapHoldMs").val() || 0);
+                const pvCapReleaseWPerSec = Number($("#node-input-pvCapReleaseWPerSec").val() || 0);
+                const feedForwardGain = Number($("#node-input-feedForwardGain").val() || 0);
+
+                const nominalPowerFromGlobal = $("#node-input-nominalPowerFromGlobal").is(":checked");
+                const maxLimitFromGlobal = $("#node-input-maxLimitFromGlobal").is(":checked");
+                const maxLimitGlobalVar = String($("#node-input-maxLimitGlobalVar").val() || "").trim();
+
+                const nominalPowerGlobalVar = String($("#node-input-nominalPowerGlobalVar").val() || "").trim();
+
+                const isCustom = $("#node-input-tuningPreset").val() === "custom";
+
+                const errors = [];
+
+                const warnings = [];
+
+
+                if (maxLimit < minLimit) {
+
+                    errors.push("Max Limit trebuie sa fie >= Min Limit.");
+
+                }
+
+                if (recoverThreshold > exportThreshold) {
+
+                    errors.push("Recover Threshold trebuie sa fie <= Export Threshold.");
+
+                }
+
+                if (isCustom && staleTimeoutMs > 0 && staleTimeoutMs < controlPeriodMs) {
+
+                    errors.push("Stale Timeout trebuie sa fie >= Control Period.");
+
+                }
+
+                if (isCustom && deadband > 0 && deadband < 20) {
+
+                    warnings.push("Deadband foarte mic (<20W) poate produce oscilatii.");
+
+                }
+
+                if (isCustom && ki > 0.08) {
+
+                    warnings.push("Ki este ridicat; poti avea overshoot sau hunting.");
+
+                }
+
+                if (isCustom && kp > 0.8) {
+
+                    warnings.push("Kp ridicat; verifica stabilitatea in sarcina variabila.");
+
+                }
+
+                if (isCustom && filterTauMs > 0 && filterTauMs < Math.max(50, controlPeriodMs / 2)) {
+
+                    warnings.push("Filter Tau foarte mic fata de Control Period poate lasa zgomotul sa intre in regulator.");
+
+                }
+
+                if (failSecureEnabled && failSecureTimeSec < 1) {
+
+                    errors.push("Fail Secure Time trebuie sa fie >= 1 sec.");
+
+                }
+
+                if (a3Enabled && a3Port < 1) {
+
+                    errors.push("A3 Modbus Port trebuie sa fie >= 1.");
+
+                }
+
+                if (a3Enabled && a3UnitId < 0) {
+
+                    errors.push("A3 Unit ID trebuie sa fie >= 0.");
+
+                }
+
+                if (a3Enabled && a3RampValue < 0) {
+
+                    errors.push("A3 Ramp Value trebuie sa fie >= 0.");
+
+                }
+
+                if (isCustom && transientIgnoreMs < 0) {
+
+                    errors.push("Transient Ignore trebuie sa fie >= 0 ms.");
+
+                }
+
+                if (outputHeartbeatMs < 250 || outputHeartbeatMs > 3500) {
+
+                    errors.push("Output Heartbeat trebuie sa fie intre 250 si 3500 ms, sub timeout-ul implicit al multi-inverter.");
+
+                }
+
+                if (isCustom && (maxStepUpW < 0 || maxStepDownW < 0)) {
+
+                    errors.push("Max Step Up/Down trebuie sa fie >= 0.");
+
+                }
+
+                if (isCustom && adaptiveErrorBandW < 1) {
+
+                    errors.push("Adaptive Error Band trebuie sa fie >= 1 W.");
+
+                }
+
+                if (isCustom && (adaptiveMinScale <= 0 || adaptiveMinScale > 1)) {
+
+                    errors.push("Adaptive Min Scale trebuie sa fie in intervalul (0, 1].");
+
+                }
+
+                if ((useGlobalPvCap || feedForwardEnabled) && !globalPvTotalVar) {
+
+                    errors.push("PV Global Variable este obligatoriu pentru Dynamic PV Cap sau PV Feed-forward.");
+
+                }
+
+                if (pvCapSupported && globalPvCapOffsetW < 0) {
+
+                    errors.push("PV Cap Offset trebuie sa fie >= 0.");
+
+                }
+                if (pvCapSupported && (pvCapHoldMs < 0 || pvCapReleaseWPerSec < 0)) {
+                    errors.push("PV Availability Hold si PV Estimate Release trebuie sa fie >= 0.");
+                }
+                if (feedForwardGain < 0 || feedForwardGain > 1.5) {
+                    errors.push("Feed-forward Gain trebuie sa fie intre 0 si 1.5.");
+                }
+
+                if (nominalPowerFromGlobal && !nominalPowerGlobalVar) {
+
+                    errors.push("Global Variable Name este obligatoriu cand citirea Nominal Power din variabila globala este activa.");
+
+                }
+
+                if (maxLimitFromGlobal && !maxLimitGlobalVar) {
+
+                    errors.push("Global Variable Name este obligatoriu cand citirea Max Limit din variabila globala este activa.");
+
+                }
+
+
+                const blocks = [];
+
+                if (errors.length) {
+
+                    blocks.push('<div class="ce-validation-block ce-error"><i class="fa fa-exclamation-triangle"></i> ' + errors.join(" ") + "</div>");
+
+                }
+
+                if (warnings.length) {
+
+                    blocks.push('<div class="ce-validation-block ce-warning"><i class="fa fa-exclamation-circle"></i> ' + warnings.join(" ") + "</div>");
+
+                }
+
+
+                $("#node-control-export-validation").html(blocks.join("")).toggle(blocks.length > 0);
+
+            }
+
+
+            function toggleFields() {
+
+                if ($("#node-input-a3TestsEnabled").is(":checked") && $("#node-input-mode").val() !== "nominal_power") {
+
+                    $("#node-input-mode").val("nominal_power");
+
+                }
+
+                const mode = $("#node-input-mode").val();
+
+                const closedLoop = mode !== "nominal_power";
+
+                const pvCapSupported = mode !== "nominal_power";
+
+                const showAdvanced = closedLoop && $("#node-input-tuningPreset").val() === "custom";
+
+                const nominalPowerFromGlobal = $("#node-input-nominalPowerFromGlobal").is(":checked");
+                const maxLimitFromGlobal = $("#node-input-maxLimitFromGlobal").is(":checked");
+
+                const useGlobalPvCap = $("#node-input-useGlobalPvCap").is(":checked");
+                const feedForwardEnabled = $("#node-input-feedForwardEnabled").is(":checked");
+
+
+                $("#row-grid-setpoint").toggle(mode === "grid_set_point");
+
+                $("#row-nominal-power-global-checkbox").toggle(mode === "nominal_power");
+
+                $("#row-nominal-power-global-var").toggle(mode === "nominal_power" && nominalPowerFromGlobal);
+
+                $("#row-nominal-power").toggle(mode === "nominal_power" && !nominalPowerFromGlobal);
+
+                $("#row-max-limit").toggle(!maxLimitFromGlobal);
+
+                $("#row-max-limit-global-var").toggle(maxLimitFromGlobal);
+
+                $("#row-zero-feed-in-mode").toggle(mode === "zero_feed_in");
+
+                $(".advanced-section").toggle(closedLoop);
+
+                $("#row-load-normal-custom").toggle(closedLoop && $("#node-input-tuningPreset").val() === "custom");
+
+
+                $(".loop-row").toggle(showAdvanced);
+
+                $("#row-sign-convention").toggle(closedLoop);
+
+                $("#row-tuning-preset").toggle(closedLoop);
+
+                $("#row-legacy-max-step").toggle(false);
+
+                $("#row-fail-secure-time").toggle($("#node-input-failSecureEnabled").is(":checked"));
+                $("#row-a3-modbus-host, #row-a3-modbus-port, #row-a3-modbus-unit, #row-a3-ramp-type, #row-a3-ramp-value, #row-a3-map").toggle($("#node-input-a3TestsEnabled").is(":checked"));
+
+                $("#row-use-global-pv-cap").toggle(pvCapSupported);
+
+                $("#row-global-pv-var").toggle(pvCapSupported && (useGlobalPvCap || feedForwardEnabled));
+
+                $("#row-global-pv-offset").toggle(pvCapSupported && useGlobalPvCap);
+                $("#row-pv-cap-growth-only, #row-pv-cap-hold, #row-pv-cap-release").toggle(pvCapSupported && useGlobalPvCap);
+                $("#row-feed-forward-enabled").toggle(pvCapSupported);
+                $("#row-feed-forward-gain").toggle(pvCapSupported && feedForwardEnabled);
+
+                showValidation();
+
+            }
+
+
+            function normalizeZeroFeedInModeSelection() {
+
+                const current = String($("#node-input-zeroFeedInMode").val() || "").toLowerCase();
+
+                if (current !== "relative" && current !== "absolute") {
+
+                    $("#node-input-zeroFeedInMode").val("relative");
+
+                }
+
+            }
+
+
+            $("#node-input-mode")
+
+                .off(".ceEditor")
+
+                .on("change.ceEditor", toggleFields);
+
+
+            $("#node-input-tuningPreset")
+
+                .off(".ceEditor")
+
+                .on("change.ceEditor", function () {
+
+                    const presetKey = $("#node-input-tuningPreset").val();
+
+                    if (presetKey === "custom" && !customDefaultsSeeded) {
+
+                        // Entering custom for the first time: preload from Normal
+
+                        // so user can tweak starting from the known normal behavior.
+
+                        applyPreset("normal");
+
+                        customDefaultsSeeded = true;
+
+                    }
+
+                    if (presetKey !== "custom") {
+
+                        applyPreset(presetKey);
+
+                    }
+
+                    toggleFields();
+
+                });
+
+
+            $("#node-input-loadNormalCustom")
+
+                .off(".ceEditor")
+
+                .on("click.ceEditor", function (evt) {
+
+                    evt.preventDefault();
+
+                    $("#node-input-tuningPreset").val("custom");
+
+                    applyPreset("normal");
+
+                    customDefaultsSeeded = true;
+
+                    toggleFields();
+
+                });
+
+
+            $(tuningFieldSelector)
+
+                .off(".ceEditor")
+
+                .on("keyup.ceEditor change.ceEditor", markCustomPreset);
+
+
+            $(validationFieldSelector)
+
+                .off(".ceEditor")
+
+                .on("keyup.ceEditor change.ceEditor", showValidation);
+
+
+            $("#node-input-failSecureEnabled")
+
+                .off(".ceEditor")
+
+                .on("change.ceEditor", function() {
+
+                    toggleFields();
+
+                });
+
+
+            $("#node-input-failSecureTimeSec")
+
+                .off(".ceEditor")
+
+                .on("keyup.ceEditor change.ceEditor", showValidation);
+
+
+            $("#node-input-a3TestsEnabled")
+
+                .off(".ceEditor")
+
+                .on("change.ceEditor", function() {
+
+                    if ($(this).is(":checked")) {
+
+                        $("#node-input-mode").val("nominal_power");
+
+                    }
+
+                    toggleFields();
+
+                });
+
+
+            $("#node-input-a3ModbusPort, #node-input-a3ModbusUnitId, #node-input-a3RampValue")
+
+                .off(".ceEditor")
+
+                .on("keyup.ceEditor change.ceEditor", showValidation);
+
+
+            $("#node-input-useGlobalPvCap")
+
+                .off(".ceEditor")
+
+                .on("change.ceEditor", function() {
+
+                    toggleFields();
+
+                });
+
+
+            $("#node-input-globalPvTotalVar")
+
+                .off(".ceEditor")
+
+                .on("blur.ceEditor", function() {
+
+                    const key = String($(this).val() || "").trim();
+
+                    $(this).val(key || "total_pv");
+
+                    showValidation();
+
+                });
+
+
+            $("#node-input-globalPvCapOffsetW")
+
+                .off(".ceEditor")
+
+                .on("keyup.ceEditor change.ceEditor", showValidation);
+
+            $("#node-input-feedForwardEnabled")
+                .off(".ceEditor")
+                .on("change.ceEditor", toggleFields);
+
+            $("#node-input-pvCapHoldMs, #node-input-pvCapReleaseWPerSec, #node-input-feedForwardGain")
+                .off(".ceEditor")
+                .on("keyup.ceEditor change.ceEditor", showValidation);
+
+
+            $("#node-input-nominalPowerFromGlobal")
+
+                .off(".ceEditor")
+
+                .on("change.ceEditor", function() {
+
+                    toggleFields();
+
+                });
+
+
+            $("#node-input-nominalPowerGlobalVar")
+
+                .off(".ceEditor")
+
+                .on("blur.ceEditor", function() {
+
+                    const key = String($(this).val() || "").trim();
+
+                    $(this).val(key || "nominal_power");
+
+                    showValidation();
+
+                });
+
+            $("#node-input-maxLimitFromGlobal")
+
+                .off(".ceEditor")
+
+                .on("change.ceEditor", toggleFields);
+
+
+            $("#node-input-maxLimitGlobalVar")
+
+                .off(".ceEditor")
+
+                .on("blur.ceEditor", function() {
+
+                    const key = String($(this).val() || "").trim();
+
+                    $(this).val(key || "max_limit");
+
+                    showValidation();
+
+                });
+
+
+            $("#node-input-adaptiveGains")
+
+                .off(".ceEditor")
+
+                .on("change.ceEditor", function() {
+
+                    const enabled = $("#node-input-adaptiveGains").is(":checked");
+
+                    $("#row-adaptive-error-band, #row-adaptive-min-scale").toggle(enabled);
+
+                    showValidation();
+
+                });
+
+
+            if ($("#node-input-tuningPreset").val() === "tuning") {
+
+                $("#node-input-tuningPreset").val("normal");
+
+            }
+
+            if (!$("#node-input-tuningPreset").val()) {
+
+                $("#node-input-tuningPreset").val("normal");
+
+            }
+
+            customDefaultsSeeded = $("#node-input-tuningPreset").val() === "custom";
+
+            normalizeZeroFeedInModeSelection();
+
+            if ($("#node-input-adaptiveGains").is(":checked")) {
+
+                $("#row-adaptive-error-band, #row-adaptive-min-scale").show();
+
+            } else {
+
+                $("#row-adaptive-error-band, #row-adaptive-min-scale").hide();
+
+            }
+
+            toggleFields();
+
+            showValidation();
+
+            setTimeout(function () { editorReady = true; }, 0);
+
+        },
+
+
+        oneditsave: function () {
+
+            this.useGlobalPvCap = $("#node-input-useGlobalPvCap").is(":checked");
+
+            this.globalPvTotalVar = String($("#node-input-globalPvTotalVar").val() || "").trim() || "total_pv";
+
+            this.globalPvCapOffsetW = Number($("#node-input-globalPvCapOffsetW").val() || 0);
+            this.pvCapOnlyBlocksIncrease = $("#node-input-pvCapOnlyBlocksIncrease").is(":checked");
+            this.pvCapHoldMs = Number($("#node-input-pvCapHoldMs").val() || 0);
+            this.pvCapReleaseWPerSec = Number($("#node-input-pvCapReleaseWPerSec").val() || 0);
+            this.feedForwardEnabled = $("#node-input-feedForwardEnabled").is(":checked");
+            this.feedForwardGain = Number($("#node-input-feedForwardGain").val() || 0);
+
+            this.nominalPowerFromGlobal = $("#node-input-nominalPowerFromGlobal").is(":checked");
+
+            this.nominalPowerGlobalVar = String($("#node-input-nominalPowerGlobalVar").val() || "").trim() || "nominal_power";
+
+            this.failSecureEnabled = $("#node-input-failSecureEnabled").is(":checked");
+
+            this.failSecureTimeSec = Number($("#node-input-failSecureTimeSec").val() || 10);
+
+            this.a3TestsEnabled = $("#node-input-a3TestsEnabled").is(":checked");
+
+            this.a3ModbusHost = String($("#node-input-a3ModbusHost").val() || "").trim() || "0.0.0.0";
+
+            this.a3ModbusPort = Number($("#node-input-a3ModbusPort").val() || 1502);
+
+            this.a3ModbusUnitId = Number($("#node-input-a3ModbusUnitId").val() || 1);
+
+            this.a3RampType = $("#node-input-a3RampType").val() || "none";
+
+            this.a3RampValue = Number($("#node-input-a3RampValue").val() || 0);
+
+            if (this.a3TestsEnabled) {
+
+                $("#node-input-mode").val("nominal_power");
+
+                this.mode = "nominal_power";
+
+            }
+
+            this.outputs = this.failSecureEnabled ? 2 : 1;
+
+            $("#node-input-mode, #node-input-tuningPreset, #node-input-deadband, #node-input-filterTauMs, #node-input-kp, #node-input-ki, #node-input-recoveryDelayMs, #node-input-transientIgnoreMs, #node-input-maxStepUpW, #node-input-maxStepDownW, #node-input-adaptiveGains, #node-input-adaptiveErrorBandW, #node-input-adaptiveMinScale, #node-input-minLimit, #node-input-maxLimit, #node-input-exportThresholdW, #node-input-recoverThresholdW, #node-input-staleTimeoutMs, #node-input-outputHeartbeatMs, #node-input-controlPeriodMs, #node-input-useGlobalPvCap, #node-input-globalPvTotalVar, #node-input-globalPvCapOffsetW, #node-input-nominalPowerFromGlobal, #node-input-nominalPowerGlobalVar, #node-input-failSecureEnabled, #node-input-failSecureTimeSec, #node-input-a3TestsEnabled, #node-input-a3ModbusPort, #node-input-a3ModbusUnitId, #node-input-a3RampValue").off(".ceEditor");
+
+        },
+
+
+        oneditcancel: function () {
+
+            $("#node-input-mode, #node-input-tuningPreset, #node-input-deadband, #node-input-filterTauMs, #node-input-kp, #node-input-ki, #node-input-recoveryDelayMs, #node-input-transientIgnoreMs, #node-input-maxStepUpW, #node-input-maxStepDownW, #node-input-adaptiveGains, #node-input-adaptiveErrorBandW, #node-input-adaptiveMinScale, #node-input-minLimit, #node-input-maxLimit, #node-input-exportThresholdW, #node-input-recoverThresholdW, #node-input-staleTimeoutMs, #node-input-outputHeartbeatMs, #node-input-controlPeriodMs, #node-input-useGlobalPvCap, #node-input-globalPvTotalVar, #node-input-globalPvCapOffsetW, #node-input-nominalPowerFromGlobal, #node-input-nominalPowerGlobalVar, #node-input-failSecureEnabled, #node-input-failSecureTimeSec, #node-input-a3TestsEnabled, #node-input-a3ModbusPort, #node-input-a3ModbusUnitId, #node-input-a3RampValue").off(".ceEditor");
+
+        }
+
+
+    };
+
+
+    RED.nodes.registerType('control-export', controlExportDefinition);
+
+
+</script>
+
+
+
+<script type="text/html" data-template-name="control-export">
+    <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="control-export-editor">
+
+        <div class="pr-section">
+
+            <div class="pr-section-title"><i class="fa fa-sliders"></i> Basic</div>
+
+            <p class="pr-section-note">Setarile esentiale pentru functionarea nodului.</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="control-export">
+
+                </div>
+
+
+                <div class="form-row">
+
+                    <label for="node-input-mode"><i class="fa fa-cogs"></i> Mode</label>
+
+                    <select id="node-input-mode">
+
+                        <option value="zero_feed_in">Zero Feed-In</option>
+
+                        <option value="grid_set_point">Grid Set Point</option>
+
+                        <option value="nominal_power">Nominal Power</option>
+
+                    </select>
+
+                </div>
+
+
+                <div class="form-row" id="row-grid-setpoint">
+
+                    <label for="node-input-gridSetPoint"><i class="fa fa-bullseye"></i> Grid Target (W)</label>
+
+                    <input type="text" id="node-input-gridSetPoint" placeholder="0">
+
+                </div>
+
+
+                <div class="form-row" id="row-zero-feed-in-mode">
+
+                    <label for="node-input-zeroFeedInMode"><i class="fa fa-crosshairs"></i> Zero Feed-In</label>
+
+                    <select id="node-input-zeroFeedInMode">
+
+                        <option value="relative">0 Relativ</option>
+
+                        <option value="absolute">0 Absolut</option>
+
+                    </select>
+
+                </div>
+
+
+                <div class="form-row" id="row-nominal-power">
+
+                    <label for="node-input-nominalPower"><i class="fa fa-bolt"></i> Fixed Power (W)</label>
+
+                    <input type="text" id="node-input-nominalPower" placeholder="1000">
+
+                </div>
+
+
+                <div class="form-row pr-checkbox-row" id="row-nominal-power-global-checkbox">
+
+                    <label for="node-input-nominalPowerFromGlobal"><i class="fa fa-globe"></i> Read Nominal Power From Global</label>
+
+                    <input type="checkbox" id="node-input-nominalPowerFromGlobal">
+
+                </div>
+
+
+                <div class="form-row" id="row-nominal-power-global-var">
+
+                    <label for="node-input-nominalPowerGlobalVar"><i class="fa fa-key"></i> Global Variable Name</label>
+
+                    <input type="text" id="node-input-nominalPowerGlobalVar" placeholder="nominal_power">
+
+                </div>
+
+
+                <div class="form-row pr-checkbox-row">
+
+                    <label for="node-input-a3TestsEnabled"><i class="fa fa-flask"></i> Teste A3</label>
+
+                    <input type="checkbox" id="node-input-a3TestsEnabled">
+
+                </div>
+
+
+                <div class="form-row" id="row-a3-modbus-host">
+
+                    <label for="node-input-a3ModbusHost"><i class="fa fa-server"></i> A3 Host</label>
+
+                    <input type="text" id="node-input-a3ModbusHost" placeholder="0.0.0.0">
+
+                </div>
+
+
+                <div class="form-row" id="row-a3-modbus-port">
+
+                    <label for="node-input-a3ModbusPort"><i class="fa fa-plug"></i> A3 Port</label>
+
+                    <input type="text" id="node-input-a3ModbusPort" placeholder="1502">
+
+                </div>
+
+
+                <div class="form-row" id="row-a3-modbus-unit">
+
+                    <label for="node-input-a3ModbusUnitId"><i class="fa fa-hashtag"></i> A3 Unit ID</label>
+
+                    <input type="text" id="node-input-a3ModbusUnitId" placeholder="1">
+
+                </div>
+
+
+                <div class="form-row" id="row-a3-ramp-type">
+
+                    <label for="node-input-a3RampType"><i class="fa fa-sliders"></i> A3 Ramp Type</label>
+
+                    <select id="node-input-a3RampType">
+
+                        <option value="none">No ramp</option>
+
+                        <option value="time">Ramp Time (s)</option>
+
+                        <option value="gradient_pct">Gradient (%/s)</option>
+
+                        <option value="gradient_w">Gradient (W/s)</option>
+
+                    </select>
+
+                </div>
+
+
+                <div class="form-row" id="row-a3-ramp-value">
+
+                    <label for="node-input-a3RampValue"><i class="fa fa-tachometer"></i> A3 Ramp Value</label>
+
+                    <input type="text" id="node-input-a3RampValue" placeholder="0">
+
+                </div>
+
+
+                <div class="form-row pr-span-2" id="row-a3-map">
+
+                    <div class="ce-meta-info">A3 Modbus: reg 2-3 = nominal W (int32), reg 4 = ramp type (0 none, 1 time, 2 %/s, 3 W/s), reg 5-6 = ramp value (int32).</div>
+
+                </div>
+
+
+                <div class="form-row loop-row" id="row-tuning-preset">
+
+                    <label for="node-input-tuningPreset"><i class="fa fa-magic"></i> Tuning Preset</label>
+
+                    <select id="node-input-tuningPreset">
+
+                        <option value="normal">Normal</option>
+
+                        <option value="stable_grid">Stable Grid Setpoint</option>
+
+                        <option value="custom">Custom</option>
+
+                    </select>
+
+                </div>
+
+
+                <div class="form-row" id="row-min-limit">
+
+                    <label for="node-input-minLimit"><i class="fa fa-arrow-down"></i> Min Limit (W)</label>
+
+                    <input type="text" id="node-input-minLimit" placeholder="0">
+
+                </div>
+
+
+                <div class="form-row" id="row-max-limit">
+
+                    <label for="node-input-maxLimit"><i class="fa fa-arrow-up"></i> Max Limit (W)</label>
+
+                    <input type="text" id="node-input-maxLimit" placeholder="1000">
+
+                </div>
+
+
+                <div class="form-row pr-checkbox-row">
+
+                    <label for="node-input-maxLimitFromGlobal"><i class="fa fa-globe"></i> Read Max Limit From Global</label>
+
+                    <input type="checkbox" id="node-input-maxLimitFromGlobal">
+
+                </div>
+
+
+                <div class="form-row" id="row-max-limit-global-var">
+
+                    <label for="node-input-maxLimitGlobalVar"><i class="fa fa-key"></i> Global Variable Name</label>
+
+                    <input type="text" id="node-input-maxLimitGlobalVar" placeholder="max_limit">
+
+                </div>
+
+
+            </div>
+
+        </div>
+
+
+        <div class="pr-section advanced-section">
+
+            <div class="pr-section-header">
+
+                <div class="pr-section-title"><i class="fa fa-flask"></i> Advanced Parameters</div>
+
+                <div id="row-load-normal-custom" style="display:none;">
+
+                    <a href="#" id="node-input-loadNormalCustom" class="ce-subtle-action"><i class="fa fa-undo"></i> Default values</a>
+
+                </div>
+
+            </div>
+
+            <p class="pr-section-note">Parametri de control, siguranta si diagnoza.</p>
+
+
+            <div class="pr-grid pr-grid-2">
+
+                <div class="form-row loop-row" id="row-sign-convention">
+
+                    <label for="node-input-signConvention"><i class="fa fa-random"></i> Sign Convention</label>
+
+                    <select id="node-input-signConvention">
+
+                        <option value="positive_import">+ = import, - = export</option>
+
+                        <option value="positive_export">+ = export, - = import</option>
+
+                    </select>
+
+                </div>
+
+
+                <div class="form-row loop-row" id="row-deadband">
+
+                    <label for="node-input-deadband"><i class="fa fa-arrows-h"></i> Deadband (W)</label>
+
+                    <input type="text" id="node-input-deadband" placeholder="100">
+
+                </div>
+
+
+                <div class="form-row loop-row" id="row-filter-tau">
+
+                    <label for="node-input-filterTauMs"><i class="fa fa-sliders"></i> Filter Tau (ms)</label>
+
+                    <input type="text" id="node-input-filterTauMs" placeholder="1500">
+
+                </div>
+
+
+                <div class="form-row loop-row" id="row-control-period">
+
+                    <label for="node-input-controlPeriodMs"><i class="fa fa-clock-o"></i> Control Period (ms)</label>
+
+                    <input type="text" id="node-input-controlPeriodMs" placeholder="500">
+
+                </div>
+
+
+                <div class="form-row loop-row" id="row-transient-ignore">
+
+                    <label for="node-input-transientIgnoreMs"><i class="fa fa-hourglass-start"></i> Transient Ignore (ms)</label>
+
+                    <input type="text" id="node-input-transientIgnoreMs" placeholder="2000">
+
+                </div>
+
+
+                <div class="form-row loop-row" id="row-max-step-up">
+
+                    <label for="node-input-maxStepUpW"><i class="fa fa-level-up"></i> Max Step Up (W/cycle)</label>
+
+                    <input type="text" id="node-input-maxStepUpW" placeholder="0">
+
+                </div>
+
+
+                <div class="form-row loop-row" id="row-max-step-down">
+
+                    <label for="node-input-maxStepDownW"><i class="fa fa-level-down"></i> Max Step Down (W/cycle)</label>
+
+                    <input type="text" id="node-input-maxStepDownW" placeholder="0">
+
+                </div>
+
+
+                <div class="form-row loop-row pr-checkbox-row" id="row-adaptive-gains">
+
+                    <label for="node-input-adaptiveGains"><i class="fa fa-magic"></i> Adaptive Gains</label>
+
+                    <input type="checkbox" id="node-input-adaptiveGains">
+
+                </div>
+
+
+                <div class="form-row loop-row" id="row-adaptive-error-band">
+
+                    <label for="node-input-adaptiveErrorBandW"><i class="fa fa-arrows-h"></i> Adaptive Error Band (W)</label>
+
+                    <input type="text" id="node-input-adaptiveErrorBandW" placeholder="2500">
+
+                </div>
+
+
+                <div class="form-row loop-row" id="row-adaptive-min-scale">
+
+                    <label for="node-input-adaptiveMinScale"><i class="fa fa-compress"></i> Adaptive Min Scale</label>
+
+                    <input type="text" id="node-input-adaptiveMinScale" placeholder="0.25">
+
+                </div>
+
+
+                <div class="form-row loop-row" id="row-kp">
+
+                    <label for="node-input-kp"><i class="fa fa-line-chart"></i> Kp</label>
+
+                    <input type="text" id="node-input-kp" placeholder="0.35">
+
+                </div>
+
+
+                <div class="form-row loop-row" id="row-ki">
+
+                    <label for="node-input-ki"><i class="fa fa-area-chart"></i> Ki</label>
+
+                    <input type="text" id="node-input-ki" placeholder="0.03">
+
+                </div>
+
+                <div class="form-row loop-row" id="row-export-threshold">
+
+                    <label for="node-input-exportThresholdW"><i class="fa fa-bell"></i> Export Threshold (W)</label>
+
+                    <input type="text" id="node-input-exportThresholdW" placeholder="50">
+
+                </div>
+
+
+                <div class="form-row loop-row" id="row-recover-threshold">
+
+                    <label for="node-input-recoverThresholdW"><i class="fa fa-undo"></i> Recover Threshold (W)</label>
+
+                    <input type="text" id="node-input-recoverThresholdW" placeholder="20">
+
+                </div>
+
+
+                <div class="form-row loop-row" id="row-recovery-delay">
+
+                    <label for="node-input-recoveryDelayMs"><i class="fa fa-hourglass-half"></i> Recovery Delay (ms)</label>
+
+                    <input type="text" id="node-input-recoveryDelayMs" placeholder="1500">
+
+                </div>
+
+
+                <div class="form-row loop-row" id="row-smoothing-alpha">
+
+                    <label for="node-input-smoothingAlpha"><i class="fa fa-filter"></i> Legacy Smoothing Alpha</label>
+
+                    <input type="text" id="node-input-smoothingAlpha" placeholder="0.15">
+
+                </div>
+
+
+                <div class="form-row loop-row" id="row-legacy-max-step" style="display:none;">
+
+                    <label for="node-input-maxStepW"><i class="fa fa-step-forward"></i> Legacy Max Step (W/ciclu)</label>
+
+                    <input type="text" id="node-input-maxStepW" placeholder="0">
+
+                </div>
+
+            </div>
+
+        </div>
+
+
+        <div class="pr-section">
+
+            <div class="pr-section-title"><i class="fa fa-shield"></i> Safety & Output</div>
+
+            <p class="pr-section-note">Limite, fallback pe stale telemetry si topic-ul de iesire.</p>
+
+
+            <div class="pr-grid pr-grid-2">
+
+                <div class="form-row" id="row-stale-timeout">
+
+                    <label for="node-input-staleTimeoutMs"><i class="fa fa-shield"></i> Stale Timeout (ms)</label>
+
+                    <input type="text" id="node-input-staleTimeoutMs" placeholder="5000">
+
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-fastSetpointMaxTelemetryAgeMs"><i class="fa fa-bolt"></i> Setpoint Cache Max Telemetry Age (ms)</label>
+                    <input type="text" id="node-input-fastSetpointMaxTelemetryAgeMs" placeholder="600">
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-outputHeartbeatMs"><i class="fa fa-heartbeat"></i> Output Heartbeat (ms)</label>
+                    <input type="text" id="node-input-outputHeartbeatMs" placeholder="2000">
+                </div>
+
+
+                <div class="form-row" id="row-safe-limit">
+
+                    <label for="node-input-safeLimitOnStale"><i class="fa fa-life-ring"></i> Safe Limit on Stale (W)</label>
+
+                    <input type="text" id="node-input-safeLimitOnStale" placeholder="0">
+
+                </div>
+
+
+                <div class="form-row" id="row-debug-level">
+
+                    <label for="node-input-debugLevel"><i class="fa fa-bug"></i> Debug</label>
+
+                    <select id="node-input-debugLevel">
+
+                        <option value="off">Off</option>
+
+                        <option value="normal">Normal</option>
+
+                        <option value="verbose">Verbose</option>
+
+                    </select>
+
+                </div>
+
+
+                <div class="form-row" id="row-start-limit-mode">
+
+                    <label for="node-input-startLimitMode"><i class="fa fa-play"></i> Start Limit</label>
+
+                    <select id="node-input-startLimitMode">
+
+                        <option value="min_limit">Start from Min Limit</option>
+
+                        <option value="last_limit">Start from Last Limit</option>
+
+                    </select>
+
+                </div>
+
+
+                <div class="form-row pr-span-2" id="row-output-topic">
+
+                    <label for="node-input-outputTopic"><i class="fa fa-sign-out"></i> Output Topic</label>
+
+                    <input type="text" id="node-input-outputTopic" placeholder="site-limit">
+
+                </div>
+
+
+                <div class="form-row pr-checkbox-row" id="row-use-global-pv-cap">
+
+                    <label for="node-input-useGlobalPvCap"><i class="fa fa-line-chart"></i> Dynamic PV Cap (global)</label>
+
+                    <input type="checkbox" id="node-input-useGlobalPvCap">
+
+                </div>
+
+
+                <div class="form-row" id="row-global-pv-var" style="display:none;">
+
+                    <label for="node-input-globalPvTotalVar"><i class="fa fa-globe"></i> PV Global Variable</label>
+
+                    <input type="text" id="node-input-globalPvTotalVar" placeholder="total_pv">
+
+                </div>
+
+
+                <div class="form-row" id="row-global-pv-offset" style="display:none;">
+
+                    <label for="node-input-globalPvCapOffsetW"><i class="fa fa-plus-circle"></i> PV Cap Offset (W)</label>
+
+                    <input type="text" id="node-input-globalPvCapOffsetW" placeholder="500">
+
+                </div>
+
+                <div class="form-row pr-checkbox-row" id="row-pv-cap-growth-only" style="display:none;">
+                    <label for="node-input-pvCapOnlyBlocksIncrease"><i class="fa fa-level-up"></i> PV Cap Growth Only</label>
+                    <input type="checkbox" id="node-input-pvCapOnlyBlocksIncrease">
+                </div>
+
+                <div class="form-row" id="row-pv-cap-hold" style="display:none;">
+                    <label for="node-input-pvCapHoldMs"><i class="fa fa-pause"></i> PV Availability Hold (ms)</label>
+                    <input type="text" id="node-input-pvCapHoldMs" placeholder="10000">
+                </div>
+
+                <div class="form-row" id="row-pv-cap-release" style="display:none;">
+                    <label for="node-input-pvCapReleaseWPerSec"><i class="fa fa-level-down"></i> PV Estimate Release (W/s)</label>
+                    <input type="text" id="node-input-pvCapReleaseWPerSec" placeholder="1000">
+                </div>
+
+                <div class="form-row pr-checkbox-row" id="row-feed-forward-enabled">
+                    <label for="node-input-feedForwardEnabled"><i class="fa fa-forward"></i> PV Feed-forward</label>
+                    <input type="checkbox" id="node-input-feedForwardEnabled">
+                </div>
+
+                <div class="form-row" id="row-feed-forward-gain">
+                    <label for="node-input-feedForwardGain"><i class="fa fa-bullseye"></i> Feed-forward Gain</label>
+                    <input type="text" id="node-input-feedForwardGain" placeholder="0.85">
+                </div>
+
+
+                <div class="form-row pr-checkbox-row" id="row-fail-secure-enabled">
+
+                    <label for="node-input-failSecureEnabled"><i class="fa fa-exclamation-triangle"></i> Fail Secure</label>
+
+                    <input type="checkbox" id="node-input-failSecureEnabled">
+
+                </div>
+
+
+                <div class="form-row" id="row-fail-secure-time" style="display:none;">
+
+                    <label for="node-input-failSecureTimeSec"><i class="fa fa-clock-o"></i> Fail Secure Time (s)</label>
+
+                    <input type="text" id="node-input-failSecureTimeSec" placeholder="10">
+
+                </div>
+
+            </div>
+
+
+            <div class="form-row" id="node-control-export-validation" style="display:none;"></div>
+
+        </div>
+
+    </div>
+
+</script>
+
+
+<style>
+
+    .control-export-editor {
+
+        --pr-border: #d7dde5;
+
+        --pr-muted: #667085;
+
+        --pr-surface: #f8fafc;
+
+        --ce-invalid: #b94a48;
+
+        --ce-warn: #8a6d3b;
+
+    }
+
+
+    .control-export-editor .pr-section {
+
+        margin: 0 0 18px;
+
+        padding: 14px 16px 16px;
+
+        border: 1px solid var(--pr-border);
+
+        border-radius: 10px;
+
+        background: var(--pr-surface);
+
+    }
+
+
+    .control-export-editor .pr-section-title {
+
+        display: flex;
+
+        align-items: center;
+
+        gap: 8px;
+
+        margin: 0 0 4px;
+
+        font-size: 15px;
+
+        font-weight: 600;
+
+        color: #243447;
+
+    }
+
+
+    .control-export-editor .pr-section-note {
+
+        margin: 0 0 14px;
+
+        color: var(--pr-muted);
+
+        font-size: 12px;
+
+        line-height: 1.45;
+
+    }
+
+
+    .control-export-editor .pr-section-header {
+
+        display: flex;
+
+        align-items: flex-start;
+
+        justify-content: space-between;
+
+        gap: 10px;
+
+        margin: 0 0 4px;
+
+    }
+
+
+    .control-export-editor .pr-grid {
+
+        display: grid;
+
+        grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+
+        gap: 12px 16px;
+
+    }
+
+
+    .control-export-editor .pr-grid-2 {
+
+        grid-template-columns: repeat(2, minmax(320px, 1fr));
+
+    }
+
+
+    .control-export-editor .pr-span-2 {
+
+        grid-column: 1 / -1;
+
+    }
+
+
+    .control-export-editor .form-row {
+
+        margin-bottom: 12px;
+
+    }
+
+
+    .control-export-editor .pr-grid .form-row,
+
+    .control-export-editor .form-row:last-child {
+
+        margin-bottom: 0;
+
+    }
+
+
+    .control-export-editor .pr-checkbox-row {
+
+        display: flex;
+
+        align-items: center;
+
+        justify-content: flex-start;
+
+        gap: 8px;
+
+    }
+
+
+    .control-export-editor .form-row > label {
+
+        width: 170px;
+
+        font-weight: 600;
+
+    }
+
+
+    .control-export-editor .form-row > input[type="text"],
+
+    .control-export-editor .form-row > input[type="number"],
+
+    .control-export-editor .form-row > select {
+
+        width: calc(100% - 180px);
+
+    }
+
+
+    .control-export-editor .pr-checkbox-row > label {
+
+        width: auto;
+
+        margin: 0;
+
+        flex: 0 0 auto;
+
+    }
+
+
+    .control-export-editor .pr-checkbox-row > input[type="checkbox"] {
+
+        width: auto;
+
+        margin: 0;
+
+        float: none;
+
+        flex: 0 0 auto;
+
+    }
+
+
+    .control-export-editor .ce-meta-info {
+
+        border: 1px solid #d8e1ea;
+
+        border-radius: 6px;
+
+        background: #f7fbff;
+
+        color: #4b5563;
+
+        padding: 8px 10px;
+
+        line-height: 1.35;
+
+    }
+
+
+    .control-export-editor #node-control-export-validation { margin-top: 8px; }
+
+
+    .control-export-editor .ce-validation-block {
+
+        border-radius: 6px;
+
+        padding: 8px 10px;
+
+        margin-top: 6px;
+
+        font-weight: 600;
+
+        border: 1px solid transparent;
+
+    }
+
+
+    .control-export-editor .ce-validation-block i { margin-right: 6px; }
+
+
+    .control-export-editor .ce-validation-block.ce-error {
+
+        color: var(--ce-invalid);
+
+        background: #fdf2f2;
+
+        border-color: #f3c2c2;
+
+    }
+
+
+    .control-export-editor .ce-validation-block.ce-warning {
+
+        color: var(--ce-warn);
+
+        background: #fff8e8;
+
+        border-color: #f1dfb3;
+
+    }
+
+
+    .control-export-editor .ce-subtle-action {
+
+        display: inline-flex;
+
+        align-items: center;
+
+        gap: 6px;
+
+        padding: 6px 10px;
+
+        background: #eceff3;
+
+        color: #4b5563;
+
+        font-size: 13px;
+
+        text-decoration: none;
+
+        border: 1px solid #d6dbe3;
+
+        border-radius: 10px;
+
+        white-space: nowrap;
+
+    }
+
+
+    .control-export-editor .ce-subtle-action:hover {
+
+        color: #243447;
+
+        background: #e5e9ef;
+
+        border-color: #c8d0db;
+
+    }
+
+
+    @media (max-width: 1100px) {
+
+        .control-export-editor .pr-grid-2 {
+
+            grid-template-columns: 1fr;
+
+        }
+
+    }
+
+</style>
+
+
+
+<script type="text/html" data-help-name="control-export">
+
+    <p>
+
+        Nodul <b>control-export</b> calculeaza limita totala de putere care trebuie trimisa catre
+
+        sistemul fotovoltaic. Limita rezultata apare in <code>msg.payload.site_limit_w</code> si poate fi
+
+        folosita direct de <code>multi-inverter</code> sau de un nod de scriere catre invertor.
+
+    </p>
+
+
+    <pre>meter / PCC telemetry -> control-export -> multi-inverter -> inverter write</pre>
+
+
+    <p>
+
+        Nodul nu scrie singur in invertor. El calculeaza comanda de limitare pe baza puterii masurate
+
+        in punctul de cuplare la retea, a tintei configurate si a limitelor de siguranta.
+
+    </p>
+
+
+    <h3>Ce face nodul</h3>
+
+    <ul>
+
+        <li>citeste puterea din retea din <code>msg.payload</code> sau din campuri cunoscute ale mesajului</li>
+
+        <li>aplica semnul corect al masurarii, in functie de conventia aleasa</li>
+
+        <li>filtreaza masurarea pentru a evita reactii la varfuri foarte scurte</li>
+
+        <li>calculeaza o corectie PI fata de tinta dorita</li>
+
+        <li>limiteaza viteza de crestere si scadere a comenzii</li>
+
+        <li>taie rezultatul intre <code>Min Limit</code> si <code>Max Limit</code></li>
+
+        <li>poate aplica un plafon dinamic in functie de productia PV disponibila</li>
+
+        <li>poate intra in fallback daca telemetria devine prea veche</li>
+
+        <li>poate emite un semnal separat de fail secure pe a doua iesire</li>
+
+    </ul>
+
+
+    <h3>Input acceptat</h3>
+
+    <p>
+
+        Intrarea principala trebuie sa contina puterea masurata in retea sau in PCC. Valoarea poate fi
+
+        numerica direct in <code>msg.payload</code>:
+
+    </p>
+
+
+    <pre>msg.payload = -250</pre>
+
+
+    <p>
+
+        Sau poate fi intr-un obiect. Nodul cauta automat aceste campuri:
+
+    </p>
+
+
+    <ul>
+
+        <li><code>payload.power_w</code></li>
+
+        <li><code>payload.summary.power.total_w</code></li>
+
+        <li><code>payload.grid_reference_w</code></li>
+
+        <li><code>payload.pcc_power</code></li>
+
+        <li><code>payload.value</code></li>
+
+        <li><code>payload.grid_power</code></li>
+
+        <li><code>payload.power</code></li>
+
+        <li><code>payload.pcc_power_w</code></li>
+
+    </ul>
+
+
+    <pre>{
+
+  "payload": {
+
+    "power_w": -320,
+
+    "summary": {
+
+      "power": {
+
+        "total_w": -320
+
+      }
+
+    }
+
+  }
+
+}</pre>
+
+
+    <h3>Timestamp</h3>
+
+    <p>
+
+        Pentru verificarea vechimii masurarii, nodul foloseste primul timestamp valid gasit in:
+
+        <code>msg.timestamp</code>, <code>msg.ts</code>, <code>msg.time</code> sau variantele echivalente din
+
+        <code>msg.payload</code>, inclusiv campuri terminate in <code>_ms</code>.
+
+        Daca nu exista timestamp, se foloseste timpul curent.
+
+    </p>
+
+
+    <p>
+
+        Valorile mici sunt interpretate ca secunde si convertite in milisecunde. Valorile mari sunt tratate
+
+        ca timestamp in milisecunde.
+
+    </p>
+
+
+    <h3>Conventia de semn</h3>
+
+    <p>
+
+        Este foarte important ca semnul puterii din retea sa fie corect. In conventia uzuala
+
+        <code>positive_import</code>, importul este pozitiv si exportul este negativ:
+
+    </p>
+
+
+    <ul>
+
+        <li><code>+500 W</code> = se importa 500 W din retea</li>
+
+        <li><code>-500 W</code> = se exporta 500 W in retea</li>
+
+    </ul>
+
+
+    <p>
+
+        Daca meterul tau foloseste conventia inversa, selecteaza conventia potrivita in configuratie.
+
+        O conventie gresita face regulatorul sa corecteze in directia gresita.
+
+    </p>
+
+
+    <h3>Moduri de lucru</h3>
+
+
+    <h4>Zero Feed-In</h4>
+
+    <p>
+
+        Modul <b>Zero Feed-In</b> urmareste o tinta de <code>0 W</code> in punctul de retea. Este modul
+
+        folosit cand nu vrei injectie in retea.
+
+    </p>
+
+
+    <ul>
+
+        <li><b>Relative</b> foloseste puterea totala masurata, de obicei <code>payload.power_w</code> sau <code>payload.summary.power.total_w</code>.</li>
+
+        <li><b>Absolute</b> foloseste faza cu cel mai mare export dintre L1, L2 si L3.</li>
+
+    </ul>
+
+
+    <p>
+
+        Pentru <b>Absolute</b>, mesajul trebuie sa contina valori pe faze. Nodul cauta campuri de forma:
+
+        <code>power_l1_w</code>, <code>l1_power_w</code>, <code>l1_w</code> si echivalentele pentru L2/L3,
+
+        inclusiv in <code>payload.summary.power</code>.
+
+    </p>
+
+
+    <h4>Grid Set Point</h4>
+
+    <p>
+
+        Modul <b>Grid Set Point</b> urmareste valoarea configurata in <b>Grid Set Point (W)</b>.
+
+        Este util cand vrei un mic import permanent sau un export controlat.
+
+    </p>
+
+
+    <ul>
+
+        <li><code>0 W</code> = echilibru in PCC</li>
+
+        <li><code>+100 W</code> = tine aproximativ 100 W import, daca semnul este pozitiv la import</li>
+
+        <li><code>-500 W</code> = permite aproximativ 500 W export, daca semnul este pozitiv la import</li>
+
+    </ul>
+
+
+    <h4>Nominal Power</h4>
+
+    <p>
+
+        Modul <b>Nominal Power</b> emite o limita fixa. Nu foloseste feedback din retea pentru control.
+
+        Valoarea este taiata intre <code>Min Limit</code> si <code>Max Limit</code>.
+
+    </p>
+
+
+    <p>
+
+        Daca este activata optiunea de nominal power din global context, nodul citeste valoarea din variabila
+
+        globala configurata. Altfel foloseste valoarea introdusa in nod.
+
+    </p>
+
+
+    <h3>Teste A3 prin Modbus TCP</h3>
+
+    <p>
+
+        Cand <b>Teste A3</b> este activ, nodul porneste un server Modbus TCP si trece automat in
+
+        <b>Nominal Power</b>. Comenzile primite prin Modbus schimba limita nominala, tipul de rampa si
+
+        valoarea rampei, apoi nodul emite imediat o comanda noua pe iesirea principala.
+
+    </p>
+
+    <h4>Setari recomandate pe dispozitivul testat</h4>
+
+    <ul>
+
+        <li><b>Teste A3</b>: activ</li>
+
+        <li><b>A3 Host</b>: <code>0.0.0.0</code> cand comanda vine de pe alt dispozitiv; <code>127.0.0.1</code> doar pentru test local pe acelasi dispozitiv</li>
+
+        <li><b>A3 Port</b>: <code>1502</code> pentru <code>control-export</code></li>
+
+        <li><b>A3 Unit ID</b>: <code>1</code></li>
+
+        <li><b>Min Limit (W)</b>: de obicei <code>0</code></li>
+
+        <li><b>Max Limit (W)</b>: puterea maxima permisa, de exemplu <code>125000</code>. Daca ramane <code>1000</code>, o comanda de <code>5000 W</code> va fi taiata la <code>1000 W</code>.</li>
+
+    </ul>
+
+    <h4>Harta registrelor A3</h4>
+
+    <ul>
+
+        <li><code>0</code>: versiune profil, read-only, valoare <code>1</code></li>
+
+        <li><code>1</code>: enabled, read-only, valoare <code>1</code></li>
+
+        <li><code>2-3</code>: nominal power in W, <code>int32</code>, big-endian word order</li>
+
+        <li><code>4</code>: ramp type, <code>uint16</code>: <code>0</code> none, <code>1</code> time, <code>2</code> gradient %/s, <code>3</code> gradient W/s</li>
+
+        <li><code>5-6</code>: ramp value, <code>int32</code>, big-endian word order</li>
+
+        <li><code>7</code>: sequence, read-only, creste la fiecare comanda Modbus acceptata</li>
+
+        <li><code>8</code>: timestamp scurt al ultimei comenzi, read-only</li>
+
+    </ul>
+
+    <p>
+
+        Sunt acceptate functiile Modbus <code>03</code> / <code>04</code> pentru citire si <code>06</code> /
+
+        <code>16</code> pentru scriere. Pentru o comanda completa se recomanda <code>FC16</code> pe registrele
+
+        <code>2-6</code>, astfel incat nominalul si rampa se actualizeaza impreuna.
+
+    </p>
+
+    <h4>Exemplu comanda A3</h4>
+
+    <p>
+
+        Pentru a trimite <code>5000 W</code> fara rampa, scrie cu <code>FC16</code> de la registrul <code>2</code>,
+
+        cantitate <code>5</code>, valorile:
+
+    </p>
+
+    <pre>reg 2 = 0
+reg 3 = 5000
+reg 4 = 0
+reg 5 = 0
+reg 6 = 0</pre>
+
+    <p>
+
+        Pentru <code>8000 W</code> cu rampa de timp <code>10 s</code>:
+
+    </p>
+
+    <pre>reg 2 = 0
+reg 3 = 8000
+reg 4 = 1
+reg 5 = 0
+reg 6 = 10</pre>
+
+    <p>
+
+        Output-ul asteptat dupa comanda:
+
+    </p>
+
+    <pre>{
+  "payload": {
+    "site_limit_w": 5000,
+    "powerType": "active",
+    "mode": "watts",
+    "a3_tests": true,
+    "ramp": { "type": "none", "value": 0 }
+  }
+}</pre>
+
+    <p>
+
+        Campurile din editorul nodului sunt configuratie initiala si nu se actualizeaza live cand vine o
+
+        comanda Modbus. Pentru confirmare, citeste registrele <code>0-8</code> sau pune un nod <code>debug</code>
+
+        pe iesirea <code>control-export</code>.
+
+    </p>
+
+
+    <h3>Limite principale</h3>
+
+    <ul>
+
+        <li><b>Min Limit (W)</b> este limita minima pe care nodul o poate emite.</li>
+
+        <li><b>Max Limit (W)</b> este limita maxima pe care nodul o poate emite.</li>
+
+        <li><b>Safe Limit on Stale (W)</b> este limita trimisa cand telemetria este prea veche.</li>
+
+        <li><b>Start Limit</b> alege daca nodul porneste de la limita minima sau de la ultima limita salvata.</li>
+
+    </ul>
+
+
+    <p>
+
+        Recomandare: seteaza <code>Max Limit</code> la puterea maxima pe care instalatia are voie sa o produca,
+
+        nu neaparat la puterea totala instalata, daca ai restrictii de retea.
+
+    </p>
+
+
+    <h3>Tuning</h3>
+
+    <p>
+
+        Parametrii de tuning controleaza cat de repede si cat de agresiv reactioneaza nodul.
+
+        Valorile implicite sunt un punct de pornire stabil pentru zero export.
+
+    </p>
+
+
+    <ul>
+
+        <li><b>Deadband (W)</b> este limita maxima a zonei calme. Banda efectiva este asimetrica: spre export foloseste minimul dintre Deadband si Export Threshold, iar spre import minimul dintre Deadband si Recover Threshold.</li>
+
+        <li><b>Filter Tau (ms)</b> controleaza filtrarea masurarii. Valori mai mari inseamna reactie mai calma.</li>
+
+        <li><b>Kp</b> este castigul proportional. Valori mai mari reactioneaza mai tare la eroare.</li>
+
+        <li><b>Ki</b> este castigul integral. Ajuta la eliminarea erorii ramase in timp.</li>
+
+        <li><b>Control Period (ms)</b> este perioada la care nodul recalculeaza comanda.</li>
+
+        <li><b>Transient Ignore (ms)</b> intarzie numai recuperarea in sus; reducerea la export ramane imediata pentru siguranta.</li>
+
+        <li><b>Max Step Up (W)</b> limiteaza cat de repede poate creste limita.</li>
+
+        <li><b>Max Step Down (W)</b> limiteaza cat de repede poate scadea limita.</li>
+
+        <li><b>Adaptive Gains</b> reduce automat castigurile cand eroarea este mica, pentru stabilitate mai buna.</li>
+
+    </ul>
+
+
+    <h3>Detectie export si revenire</h3>
+
+    <ul>
+
+        <li><b>Export Threshold (W)</b> este pragul peste care nodul considera ca exista export semnificativ.</li>
+
+        <li><b>Recover Threshold (W)</b> este pragul sub care nodul permite revenirea in sus a limitei.</li>
+
+        <li><b>Recovery Delay (ms)</b> este timpul minim fara export semnificativ inainte ca limita sa poata creste.</li>
+
+    </ul>
+
+
+    <p>
+
+        Aceste campuri sunt utile pentru a evita situatia in care limita urca imediat dupa o taiere si produce
+
+        oscilatii repetate.
+
+    </p>
+
+    <h3>Preset Stable Grid Setpoint</h3>
+    <p>
+        Presetul foloseste valorile orientate spre precizie si revenire controlata: Deadband 150 W, Filter Tau
+        1500 ms, Kp 0.24, Ki 0.008, Control Period 1000 ms, Recovery Delay 2000 ms, Transient Ignore 800 ms,
+        Max Step Up 1000 W, Max Step Down 1800 W si Adaptive Min Scale 0.45. Reducerea ramane mai rapida decat
+        cresterea pentru protectie la export, iar componenta integrala mica elimina eroarea reziduala.
+    </p>
+
+
+    <h3>Dynamic PV Cap</h3>
+
+    <p>
+
+        <b>Dynamic PV Cap</b> limiteaza numai cresterea comenzii la puterea PV disponibila estimata plus un
+        offset. Cu <b>PV Cap Growth Only</b> activ, o scadere a puterii PV masurate nu poate reduce singura
+        limita deja emisa. Reducerile raman in responsabilitatea regulatorului pe baza masurarii din PCC.
+
+    </p>
+
+
+    <pre>crestere permisa <= pv_available_estimate_w + pv_cap_offset_w</pre>
+
+
+    <p>
+
+        Puterea PV poate veni din variabila globala configurata sau din mesaje de telemetrie PV. Estimarea
+        disponibila urca imediat, pastreaza varful pentru <b>PV Availability Hold</b>, apoi coboara cel mult cu
+        <b>PV Estimate Release</b>. Aceasta evita bucla limita - productie masurata - plafon - limita. Pentru mesajele
+
+        de telemetrie PV, nodul cauta <code>payload.power_w</code> si identifica sursa din
+
+        <code>payload.inverter_id</code>, <code>msg.inverter_id</code> sau <code>msg.topic</code>. Sursa trebuie
+
+        sa fie aceeasi cu numele configurat la PV Global Variable.
+
+    </p>
+
+    <h3>PV Feed-forward</h3>
+    <p>
+        Feed-forward estimeaza direct limita necesara din puterea PV masurata si eroarea PCC. Pentru conventia
+        de semn selectata, tinta este aproximativ <code>pv_total_w - gain * error_w</code>. Rezultatul nu ocoleste
+        limitele hard, pasii Max Step Up/Down, protectia la export sau regulatorul PI; doar aduce mai repede
+        comanda in apropierea punctului corect. <b>Feed-forward Gain</b> este limitat la intervalul 0...1.5,
+        iar valoarea recomandata initial este 0.85.
+    </p>
+
+    <h3>Filtrarea masurarii PCC</h3>
+    <p>
+        Inainte de filtrul temporal configurat prin <b>Filter Tau</b>, nodul aplica o mediana pe ultimele trei
+        masurari ale aceleiasi surse. Impulsurile izolate sunt astfel respinse fara a intarzia protectia rapida:
+        reducerea imediata la export continua sa foloseasca cea mai protectiva valoare dintre brut si filtrat.
+    </p>
+
+
+    <p>
+
+        Plafonul PV dinamic se aplica in modurile de control pe retea. In <b>Nominal Power</b>, nodul emite
+
+        limita nominala configurata.
+
+    </p>
+
+
+    <h3>Fail Secure</h3>
+
+    <p>
+
+        Daca <b>Fail Secure</b> este activ, nodul primeste a doua iesire. Aceasta trimite un mesaj doar cand
+
+        limita ramane la <code>Min Limit</code> mai mult decat timpul configurat si eroarea indica o situatie
+
+        care nu se recupereaza.
+
+    </p>
+
+
+    <pre>{
+
+  "topic": "control-export/fail-secure",
+
+  "payload": 1,
+
+  "fail_secure": {
+
+    "active": true,
+
+    "duration_ms": 12000,
+
+    "min_limit_w": 0,
+
+    "site_limit_w": 0,
+
+    "timeout_s": 10
+
+  }
+
+}</pre>
+
+
+    <p>
+
+        Foloseste acest semnal pentru alarme, opriri suplimentare sau logica externa de siguranta.
+
+    </p>
+
+
+    <h3>Output principal</h3>
+
+    <p>
+
+        Mesajul principal este trimis pe prima iesire, cu topicul configurat in <b>Output Topic</b>.
+
+        Campurile de baza sunt disponibile indiferent de nivelul de debug.
+
+    </p>
+
+
+    <pre>{
+
+  "topic": "site-limit",
+
+  "payload": {
+
+    "site_limit_w": 5400,
+
+    "grid_reference_w": -120,
+
+    "grid_target_w": 0,
+
+    "reason": "tracking",
+
+    "controller_state": "tracking",
+
+    "stale": false,
+
+    "pv_total_w": 6100,
+
+    "pv_cap_limit_w": 6600,
+
+    "pv_cap_offset_w": 500,
+
+    "pv_cap_applied": false,
+
+    "pv_available_estimate_w": 6100,
+
+    "pv_cap_blocked_increase": false,
+
+    "controller_requested_limit_w": 5400,
+
+    "feed_forward_target_w": 6202,
+
+    "timestamp_ms": 1776692400000
+
+  }
+
+}</pre>
+
+
+    <h3>Campuri importante din output</h3>
+
+    <ul>
+
+        <li><code>site_limit_w</code> este limita totala calculata pentru sistem.</li>
+
+        <li><code>grid_reference_w</code> este puterea masurata in retea, dupa conventia configurata.</li>
+
+        <li><code>grid_target_w</code> este tinta urmarita de regulator.</li>
+
+        <li><code>reason</code> explica de ce a fost emisa limita curenta.</li>
+
+        <li><code>controller_state</code> arata starea interna principala a regulatorului.</li>
+
+        <li><code>stale</code> devine <code>true</code> cand se foloseste fallback din cauza telemetriei vechi.</li>
+
+        <li><code>pv_total_w</code> este puterea PV folosita pentru Dynamic PV Cap, daca este disponibila.</li>
+
+        <li><code>pv_cap_limit_w</code> este plafonul calculat din PV total plus offset.</li>
+
+        <li><code>pv_cap_applied</code> arata daca plafonul PV a taiat limita.</li>
+
+        <li><code>pv_available_estimate_w</code> este estimarea PV stabilizata cu hold si release.</li>
+
+        <li><code>pv_cap_blocked_increase</code> arata ca plafonul a blocat doar cresterea comenzii.</li>
+
+        <li><code>controller_requested_limit_w</code> este limita ceruta inainte de arbitrarea plafonului PV.</li>
+
+        <li><code>feed_forward_target_w</code> este tinta calculata din balanta instantanee de putere.</li>
+
+        <li><code>timestamp_ms</code> este timestamp-ul folosit pentru calcul.</li>
+
+    </ul>
+
+
+    <h3>Debug</h3>
+
+    <p>
+
+        Cu debug activ, outputul include detalii suplimentare precum:
+
+        <code>raw_grid_reference_w</code>, <code>filtered_grid_reference_w</code>, <code>error_w</code>,
+
+        <code>correction_w</code>, <code>control_active</code>, <code>export_detected</code>,
+
+        <code>recovery_blocked</code>, <code>ramp_direction</code>, <code>clamped_by_min</code>,
+
+        <code>clamped_by_max</code> si <code>measurement_age_ms</code>.
+
+    </p>
+
+
+    <p>
+
+        Cu debug verbose apar si campurile interne normalizate, termenii PI, castigurile active si parametrii
+
+        de tuning folositi la calcul. Foloseste verbose doar pentru diagnostic, deoarece mesajul devine mai mare.
+
+    </p>
+
+
+    <h3>Status in editor</h3>
+
+    <ul>
+
+        <li><b>verde</b> inseamna control activ si tracking normal.</li>
+
+        <li><b>albastru</b> inseamna nominal, deadband, hold sau recovery hold.</li>
+
+        <li><b>galben</b> inseamna telemetrie stale si fallback activ.</li>
+
+        <li><b>rosu</b> inseamna eroare de input sau procesare.</li>
+
+    </ul>
+
+
+    <h3>Recomandari practice</h3>
+
+    <ul>
+
+        <li>Verifica intai semnul meterului cu un debug node, inainte sa activezi controlul real.</li>
+
+        <li>Porneste cu <code>Max Limit</code> sub limita reala acceptata de instalatie si creste treptat.</li>
+
+        <li>Daca limita oscileaza, mareste <code>Deadband</code> sau <code>Filter Tau</code> si scade usor <code>Kp</code>.</li>
+
+        <li>Daca raspunsul este prea lent, scade <code>Filter Tau</code> sau mareste usor <code>Kp</code>.</li>
+
+        <li>Daca productia revine prea repede dupa o taiere, mareste <code>Recovery Delay</code>.</li>
+
+        <li>Seteaza intotdeauna <code>Stale Timeout</code> si <code>Safe Limit on Stale</code> pentru o stare sigura.</li>
+
+    </ul>
+
+</script>
+
+
+<script type="text/html" data-help-name="control-export-legacy">
+
+
+    <p>
+
+
+        Nodul <b>control-export</b> calculează o limită totală de putere pentru un sistem fotovoltaic pe baza
+
+
+        puterii măsurate în punctul de cuplare cu rețeaua. Rezultatul este emis ca <code>site_limit_w</code>
+
+
+        pentru a controla producția totală a sistemului.
+
+
+    </p>
+
+
+
+    <p>
+
+
+        Nodul este potrivit pentru aplicații de tip:
+
+
+    </p>
+
+
+
+    <pre>meter / grid telemetry → control-export → multi-inverter → inverter write</pre>
+
+
+
+    <h3>Ce face nodul</h3>
+
+
+    <ul>
+
+
+        <li>citește puterea din rețea din <code>msg.payload</code></li>
+
+
+        <li>normalizează semnul măsurării conform convenției configurate</li>
+
+
+        <li>filtrează măsurarea folosită de control</li>
+
+
+        <li>rulează calculul la o perioadă internă fixă</li>
+
+
+        <li>aplică un control PI în jurul unei ținte, cu anti-windup de bază</li>
+
+
+        <li>folosește praguri și întârziere raportate la ținta configurată pentru revenirea în sus</li>
+
+
+        <li>aplică limite minime și maxime</li>
+
+
+        <li>intră în fallback dacă telemetria este veche</li>
+
+
+    </ul>
+
+
+
+    <h3>Input acceptat</h3>
+
+
+    <p>Nodul acceptă mai multe formate uzuale:</p>
+
+
+
+    <pre>msg.payload = 1200</pre>
+
+
+    <p>Interpretare: valoare numerică directă pentru puterea din rețea.</p>
+
+
+
+    <pre>msg.payload = {
+
+
+  "grid_reference_w": 1200
+
+
+}</pre>
+
+
+
+    <pre>msg.payload = {
+
+
+  "pcc_power": 1200
+
+
+}</pre>
+
+
+
+    <pre>msg.payload = {
+
+
+  "value": 1200
+
+
+}</pre>
+
+
+
+    <pre>msg.payload = {
+
+
+  "grid_power": 1200
+
+
+}</pre>
+
+
+
+    <p>
+
+
+        Pentru timestamp, nodul încearcă să folosească:
+
+
+        <code>msg.timestamp</code>, <code>msg.ts</code>, <code>msg.time</code>,
+
+
+        respectiv variantele echivalente din <code>msg.payload</code>.
+
+
+        Dacă nu există timestamp, se folosește timpul curent.
+
+
+    </p>
+
+
+
+    <h3>Moduri de lucru</h3>
+
+
+
+    <h4>Zero Feed-In</h4>
+
+
+    <p>
+
+
+        Nodul urmărește o țintă de <code>0W</code> în rețea.
+
+
+        Este modul uzual pentru aplicațiile unde nu se dorește export.
+
+        În acest mod poți alege:
+
+        <b>0 relativ</b> (referință din <code>power_w</code>) sau
+
+        <b>0 absolut</b> (referință din faza cu cel mai mare export, dintre L1/L2/L3).
+
+
+    </p>
+
+
+
+    <h4>Grid Set Point</h4>
+
+
+    <p>
+
+
+        Nodul urmărește valoarea configurată în <b>Grid Set Point (W)</b>.
+
+
+    </p>
+
+
+    <ul>
+
+
+        <li><code>-100W</code> = menține un mic import</li>
+
+
+        <li><code>0W</code> = urmărește echilibru în PCC</li>
+
+
+        <li><code>50W</code> = permite un mic export</li>
+
+
+    </ul>
+
+
+
+    <h4>Nominal Power</h4>
+
+
+    <p>
+
+
+        Nodul emite direct o limită fixă dată de <b>Nominal Power (W)</b>, tăiată între Min și Max.
+
+
+        În acest mod nu se mai face control în funcție de rețea.
+
+
+    </p>
+
+
+
+    <h3>Parametri</h3>
+
+
+
+    <h4>Name</h4>
+
+
+    <p>
+
+
+        Numele afișat în editorul Node-RED.
+
+
+    </p>
+
+
+
+    <h4>Mode</h4>
+
+
+    <p>
+
+
+        Selectează modul de funcționare al nodului.
+
+
+    </p>
+
+
+
+    <h4>Grid Set Point (W)</h4>
+
+
+    <p>
+
+
+        Ținta dorită în rețea trebuie introdusă în convenția fixă a nodului.
+
+
+        În această convenție (<b>+ = import, - = export</b>), o valoare negativă înseamnă export dorit.
+
+
+    </p>
+
+
+
+    <h4>Zero Feed-In</h4>
+
+
+    <p>
+
+
+        <code>0 relativ</code> folosește referința <code>power_w</code>.
+
+        <code>0 absolut</code> folosește faza cu cel mai mare export, ca să reducă exportul pe toate fazele.
+
+
+    </p>
+
+
+
+    <h4>Nominal Power (W)</h4>
+
+
+    <p>
+
+
+        Limita fixă totală folosită în modul <b>Nominal Power</b>.
+
+
+    </p>
+
+
+
+    <h4>Tuning Preset</h4>
+
+
+    <p>
+
+
+        <b>Fast</b> reacționează rapid la creșteri/scăderi de consum.
+
+        <b>Balanced</b> ignoră vârfuri scurte (aprox. 1-2s) și apoi corectează.
+
+        <b>Conservative</b> este mai lent și mai filtrat pentru stabilitate maximă.
+
+        În <b>Custom</b> configurezi manual toți parametrii.
+
+
+    </p>
+
+
+
+    <h4>Semn rețea</h4>
+
+
+    <p>
+
+
+        În preset-urile standard (<b>Conservative / Balanced / Fast</b>) convenția este fixă: <b>+ = import, - = export</b>.
+
+
+        În <b>Custom</b> poți alege manual convenția.
+
+
+    </p>
+
+
+
+    <h4>Deadband (W)</h4>
+
+
+    <p>
+
+
+        Zonă de toleranță în jurul țintei. Dacă eroarea este în această zonă, limita rămâne neschimbată.
+
+
+    </p>
+
+
+
+    <h4>Legacy Smoothing Alpha</h4>
+
+
+    <p>
+
+
+        Parametru păstrat pentru compatibilitate.
+
+
+        Filtrarea principală folosită de control este determinată de <b>Filter Tau (ms)</b>.
+
+
+    </p>
+
+
+
+    <h4>Filter Tau (ms)</h4>
+
+
+    <p>
+
+
+        Constanta de timp a filtrului aplicat măsurării din rețea.
+
+
+        Valori mai mari produc o filtrare mai puternică.
+
+
+    </p>
+
+
+
+    <h4>Kp</h4>
+
+
+    <p>
+
+
+        Câștigul proporțional al regulatorului.
+
+
+        El stabilește cât de puternic reacționează limita la eroarea față de țintă.
+
+
+    </p>
+
+
+
+    <h4>Ki</h4>
+
+
+    <p>
+
+
+        Câștigul integral al regulatorului.
+
+
+        Ajută la eliminarea offset-ului static față de țintă, mai ales când sistemul are inerție sau rampă lentă.
+
+
+    </p>
+
+
+
+    <h4>Control Period (ms)</h4>
+
+
+    <p>
+
+
+        Perioada internă la care nodul recalculează comanda.
+
+
+        Mesajele pot veni mai des, dar limita este actualizată la acest interval.
+
+
+    </p>
+
+
+
+    <h4>Transient Ignore (ms)</h4>
+
+
+    <p>
+
+
+        Durata minimă în care deficitul de export trebuie să rămână stabil înainte ca limita să crească.
+
+        Reducerea limitei la export nu este întârziată de acest parametru, pentru a păstra protecția rapidă.
+
+
+    </p>
+
+
+    <h4>Export Threshold (W)</h4>
+
+
+    <p>
+
+
+        Prag peste care nodul consideră că există export semnificativ.
+
+
+    </p>
+
+
+
+    <h4>Recover Threshold (W)</h4>
+
+
+    <p>
+
+
+        Prag sub care nodul permite revenirea în sus a limitei.
+
+
+    </p>
+
+
+
+    <h4>Recovery Delay (ms)</h4>
+
+
+    <p>
+
+
+        Timp minim fără export semnificativ înainte ca limita să poată crește.
+
+
+    </p>
+
+
+
+    <h4>Legacy Max Step (W/ciclu)</h4>
+
+
+    <p>
+
+
+        Parametru păstrat pentru compatibilitate. Nu este folosit de logica principală.
+
+
+    </p>
+
+
+
+    <h4>Stale Timeout (ms)</h4>
+
+
+    <p>
+
+
+        Timpul maxim acceptat pentru prospețimea telemetriei.
+
+
+        Dacă timestamp-ul este mai vechi decât această valoare, datele sunt considerate stale.
+
+
+    </p>
+
+
+
+    <h4>Safe Limit on Stale (W)</h4>
+
+
+    <p>
+
+
+        Limita totală emisă când telemetria este stale.
+
+
+    </p>
+
+
+
+    <h4>Min Limit (W)</h4>
+
+
+    <p>
+
+
+        Limita minimă permisă pentru comanda totală.
+
+
+    </p>
+
+
+
+    <h4>Max Limit (W)</h4>
+
+
+    <p>
+
+
+        Limita maximă permisă pentru comanda totală.
+
+
+    </p>
+
+
+
+    <h4>Output Topic</h4>
+
+
+    <p>
+
+
+        Topic-ul pus în mesajul de ieșire.
+
+
+    </p>
+
+
+
+    <h4>Start Limit</h4>
+
+
+    <p>
+
+
+        Alege limita folosită la pornire/deploy:
+
+        <code>Start from Min Limit</code> sau <code>Start from Last Limit</code>.
+
+
+    </p>
+
+
+
+    <h4>Dynamic PV Cap (global)</h4>
+
+
+    <p>
+
+
+        Dacă este activ, nodul citește puterea PV totală din variabila globală setată în <b>PV Global Variable</b>
+
+        și plafonează limita la <code>PV + offset</code>.
+
+        Offset-ul pornește din <b>PV Cap Offset (W)</b> când eroarea față de setpoint este mare,
+
+        iar aproape de setpoint se reduce automat pentru reglaj mai fin și mai puține oscilații.
+
+        Acest plafon se aplică doar în modurile <b>Zero Feed-In</b> și <b>Grid Set Point</b>, nu în <b>Nominal Power</b>.
+
+
+    </p>
+
+
+
+    <h3>Output</h3>
+
+
+    <p>Nodul emite mesajul principal cu topicul configurat. Dacă activezi <code>Fail Secure</code>, apare și a doua ieșire: aceasta trimite <code>payload = 1</code> când limita trimisă rămâne la <code>Min Limit</code> mai mult decât timpul configurat.</p>
+
+
+
+    <pre>{
+
+
+  "topic": "site-limit",
+
+
+  "payload": {
+
+
+    "site_limit_w": 5400,
+
+
+    "grid_reference_w": 620,
+
+
+    "filtered_grid_reference_w": 510,
+
+
+    "grid_target_w": -100,
+
+
+    "correction_w": 240,
+
+
+    "error_w": 610,
+
+
+    "control_active": true,
+
+
+    "reason": "tracking",
+
+
+    "stale": false,
+
+
+    "export_detected": true,
+
+
+    "ramp_direction": "down",
+
+
+    "kp": 0.2,
+
+
+    "control_period_ms": 1000,
+
+
+    "filter_tau_ms": 2500,
+
+
+    "measurement_age_ms": 82,
+
+
+    "timestamp_ms": 1774692000000
+
+
+  }
+
+
+}</pre>
+
+
+
+    <h3>Semnificația câmpurilor din output</h3>
+
+
+    <ul>
+
+
+        <li><code>site_limit_w</code> — limita totală calculată pentru site</li>
+
+
+        <li><code>raw_grid_reference_w</code> — valoarea brută primită direct de la meter</li>
+
+
+        <li><code>grid_reference_w</code> — măsurarea în convenția configurată în nod</li>
+
+
+        <li><code>normalized_grid_reference_w</code> — măsurarea internă folosită de regulator</li>
+
+
+        <li><code>filtered_grid_reference_w</code> — măsurarea filtrată în convenția configurată</li>
+
+
+        <li><code>normalized_filtered_grid_reference_w</code> — măsurarea filtrată folosită intern de control</li>
+
+
+        <li><code>grid_target_w</code> — ținta urmărită în convenția configurată</li>
+
+
+        <li><code>normalized_grid_target_w</code> — ținta internă după normalizarea semnului</li>
+
+
+        <li><code>correction_w</code> — corecția aplicată față de limita precedentă</li>
+
+
+        <li><code>error_w</code> — eroarea față de țintă</li>
+
+
+        <li><code>p_term_w</code> — contribuția proporțională a regulatorului</li>
+
+
+        <li><code>i_term_w</code> — contribuția integratorului</li>
+
+
+        <li><code>control_active</code> — indică dacă nodul a modificat activ limita</li>
+
+
+        <li><code>reason</code> — motivul ieșirii: <code>tracking</code>, <code>deadband</code>, <code>hold_period</code>, <code>recovery_hold</code>, <code>stale</code>, <code>nominal</code></li>
+
+
+        <li><code>controller_state</code> — stare explicită a regulatorului, utilă pentru diagnoză</li>
+
+
+        <li><code>stale</code> — indică fallback din cauza telemetriei vechi</li>
+
+
+        <li><code>export_detected</code> — indică depășirea pragului de export</li>
+
+
+        <li><code>recovery_blocked</code> — indică blocarea temporară a creșterii limitei</li>
+
+
+        <li><code>ramp_direction</code> — sensul ultimei modificări: <code>up</code>, <code>down</code>, <code>hold</code></li>
+
+
+        <li><code>clamped_by_min</code> / <code>clamped_by_max</code> — arată dacă limita a fost tăiată de limitele configurate</li>
+
+
+        <li><code>kp</code> — câștigul activ al regulatorului</li>
+
+
+        <li><code>ki</code> — câștigul integral activ</li>
+
+
+        <li><code>control_period_ms</code> — perioada internă a controlului</li>
+
+
+        <li><code>filter_tau_ms</code> — constanta de timp a filtrului</li>
+
+
+        <li><code>measurement_age_ms</code> — vechimea ultimei măsurători disponibile</li>
+
+
+        <li><code>timestamp_ms</code> — timestamp-ul folosit pentru evaluare</li>
+
+
+    </ul>
+
+
+
+    <h3>Status în editor</h3>
+
+
+    <ul>
+
+
+        <li><b>verde</b> — control activ și urmărire normală</li>
+
+
+        <li><b>albastru</b> — menținere în deadband, hold period sau recovery hold</li>
+
+
+        <li><b>galben</b> — telemetrie stale, fallback activ</li>
+
+
+        <li><b>roșu</b> — eroare de input sau procesare</li>
+
+
+    </ul>
+
+
+
+    <h3>Exemple de utilizare</h3>
+
+
+
+    <h4>1. Zero-export conservator</h4>
+
+
+    <ul>
+
+
+        <li>Mode = <code>Zero Feed-In</code></li>
+
+
+        <li>Deadband = <code>180</code></li>
+
+
+        <li>Filter Tau = <code>2800</code></li>
+
+
+        <li>Kp = <code>0.22</code></li>
+
+
+        <li>Ki = <code>0.01</code></li>
+
+
+        <li>Control Period = <code>800</code></li>
+
+
+        <li>Export Threshold = <code>60</code></li>
+
+
+        <li>Recover Threshold = <code>25</code></li>
+
+
+        <li>Recovery Delay = <code>3000</code></li>
+
+
+        <li>Safe Limit on Stale = <code>0</code></li>
+
+
+    </ul>
+
+
+
+    <h4>2. Grid setpoint cu mic import</h4>
+
+
+    <ul>
+
+
+        <li>Mode = <code>Grid Set Point</code></li>
+
+
+        <li>Grid Set Point = <code>+100</code> pentru convenția implicită <code>+ = import</code></li>
+
+
+        <li>Deadband = <code>80..150</code></li>
+
+
+        <li>Filter Tau = <code>1200..2000</code></li>
+
+
+        <li>Kp = <code>0.25..0.35</code></li>
+
+
+        <li>Ki = <code>0.01..0.03</code></li>
+
+
+    </ul>
+
+
+
+    <h4>3. Grid setpoint cu export controlat</h4>
+
+
+    <ul>
+
+
+        <li>Mode = <code>Grid Set Point</code></li>
+
+
+        <li>Grid Set Point = <code>+500</code> sau <code>-500</code> în funcție de convenția de semn aleasă</li>
+
+
+        <li>Deadband = <code>80..120</code></li>
+
+
+        <li>Filter Tau = <code>1000..1500</code></li>
+
+
+        <li>Kp = <code>0.30..0.45</code></li>
+
+
+        <li>Ki = <code>0.02..0.05</code></li>
+
+
+        <li>Export Threshold = <code>40..80</code></li>
+
+
+        <li>Recover Threshold = <code>15..30</code></li>
+
+
+    </ul>
+
+
+
+    <h4>4. Zero-export foarte stabil pentru contoare zgomotoase</h4>
+
+
+    <ul>
+
+
+        <li>Mode = <code>Zero Feed-In</code></li>
+
+
+        <li>Deadband = <code>150..250</code></li>
+
+
+        <li>Filter Tau = <code>2500..4000</code></li>
+
+
+        <li>Kp = <code>0.15..0.25</code></li>
+
+
+        <li>Ki = <code>0.00..0.02</code></li>
+
+
+        <li>Control Period = <code>700..1200</code></li>
+
+
+        <li>Recovery Delay = <code>2000..5000</code></li>
+
+
+    </ul>
+
+
+
+    <h4>5. Zero-export mai rapid pentru sisteme reactive</h4>
+
+
+    <ul>
+
+
+        <li>Mode = <code>Zero Feed-In</code></li>
+
+
+        <li>Deadband = <code>50..100</code></li>
+
+
+        <li>Filter Tau = <code>800..1500</code></li>
+
+
+        <li>Kp = <code>0.35..0.55</code></li>
+
+
+        <li>Ki = <code>0.02..0.06</code></li>
+
+
+        <li>Control Period = <code>300..700</code></li>
+
+
+        <li>Export Threshold = <code>30..60</code></li>
+
+
+        <li>Recover Threshold = <code>10..20</code></li>
+
+
+    </ul>
+
+
+
+    <h4>6. Sistem cu baterie sau consum foarte variabil</h4>
+
+
+    <ul>
+
+
+        <li>Mode = <code>Grid Set Point</code></li>
+
+
+        <li>Grid Set Point = <code>+100</code> la convenția <code>+ = import</code>, sau o valoare mică de bias utilă instalației</li>
+
+
+        <li>Deadband = <code>100..180</code></li>
+
+
+        <li>Filter Tau = <code>1500..3000</code></li>
+
+
+        <li>Kp = <code>0.20..0.35</code></li>
+
+
+        <li>Ki = <code>0.01..0.03</code></li>
+
+
+        <li>Recovery Delay = <code>1500..3000</code></li>
+
+
+    </ul>
+
+
+
+    <h4>7. Limită fixă pentru test</h4>
+
+
+    <ul>
+
+
+        <li>Mode = <code>Nominal Power</code></li>
+
+
+        <li>Nominal Power = <code>8000</code></li>
+
+
+    </ul>
+
+
+
+    <h4>8. Punct de pornire recomandat</h4>
+
+
+    <ul>
+
+
+        <li>Folosește valorile default actuale dacă nu ai încă măsurători de tuning</li>
+
+
+        <li>Dacă limita oscilează prea mult: mărește <code>Deadband</code> și <code>Filter Tau</code>, sau scade <code>Kp</code> / <code>Ki</code></li>
+
+
+        <li>Dacă nodul reacționează prea lent: scade <code>Filter Tau</code>, mărește ușor <code>Kp</code> și redu <code>Control Period</code></li>
+
+
+        <li>Dacă urcă prea greu după o limitare: redu <code>Recovery Delay</code> sau ajustează <code>Kp</code></li>
+
+
+        <li>Dacă taie prea agresiv producția: redu <code>Kp</code> și/sau crește <code>Deadband</code></li>
+
+
+    </ul>
+
+
+
+    <h3>Recomandări practice</h3>
+
+
+    <ul>
+
+
+        <li>pentru telemetrie rapidă, folosește o perioadă internă de control mai mare decât perioada mesajelor</li>
+
+
+        <li>pentru un comportament mai calm, mărește <code>Deadband</code> și <code>Filter Tau</code> sau scade <code>Kp</code></li>
+
+
+        <li>pentru revenire mai lentă, mărește <code>Recovery Delay</code> sau redu <code>Kp</code></li>
+
+
+        <li>setează întotdeauna <code>Stale Timeout</code> și <code>Safe Limit on Stale</code></li>
+
+
+    </ul>
+
+
+    <h3>Referinta completa parametri</h3>
+
+    <ul>
+
+        <li><code>mode</code>: selecteaza Zero Feed-In, Grid Set Point sau Nominal Power.</li>
+
+        <li><code>zeroFeedInMode</code>: <code>relative</code> foloseste suma fazelor, <code>absolute</code> protejeaza fiecare faza.</li>
+
+        <li><code>requireAllPhases</code>: cere L1/L2/L3 valide pentru modurile care folosesc faze.</li>
+
+        <li><code>tuningPreset</code>: aplica seturi de reglaj; <code>stable_grid</code> este recomandat cand telemetria vine foarte des si vrei mai putine oscilatii.</li>
+
+        <li><code>gridSetPoint</code>: tinta de retea in W pentru Grid Set Point.</li>
+
+        <li><code>nominalPower</code>: limita fixa in W pentru Nominal Power.</li>
+
+        <li><code>nominalPowerFromGlobal</code> si <code>nominalPowerGlobalVar</code>: citesc limita nominala din context global.</li>
+        <li><code>maxLimitFromGlobal</code> si <code>maxLimitGlobalVar</code>: citesc limita maxima din context global.</li>
+
+        <li><code>a3TestsEnabled</code>: porneste serverul Modbus TCP pentru teste A3 si forteaza modul Nominal Power.</li>
+
+        <li><code>a3ModbusHost</code>: interfata pe care asculta serverul A3; foloseste <code>0.0.0.0</code> pentru acces din retea.</li>
+
+        <li><code>a3ModbusPort</code>: portul serverului A3, implicit <code>1502</code>.</li>
+
+        <li><code>a3ModbusUnitId</code>: Unit ID Modbus acceptat, implicit <code>1</code>.</li>
+
+        <li><code>a3RampType</code> si <code>a3RampValue</code>: valorile initiale de rampa pana la prima comanda Modbus.</li>
+
+        <li><code>signConvention</code>: adapteaza semnul import/export la sensul meterului.</li>
+
+        <li><code>deadband</code>: zona moarta in W.</li>
+
+        <li><code>minLimit</code> si <code>maxLimit</code>: limitele hard minime si maxime ale comenzii emise.</li>
+
+        <li><code>outputTopic</code>: topic-ul mesajului catre <code>fronius-write</code> sau <code>multi-inverter</code>.</li>
+
+        <li><code>smoothingAlpha</code>: filtrare simpla a comenzii vechi; valori mai mici inseamna raspuns mai lent.</li>
+
+        <li><code>filterTauMs</code>: filtrarea masurarii de retea.</li>
+
+        <li><code>kp</code> si <code>ki</code>: castigurile proportional si integral ale regulatorului.</li>
+
+        <li><code>controlPeriodMs</code>: perioada minima intre calcule de control.</li>
+
+        <li><code>exportThresholdW</code>: pragul peste care exportul este considerat critic si poate produce reducere rapida.</li>
+
+        <li><code>recoverThresholdW</code> si <code>recoveryDelayMs</code>: controleaza cand si cat de repede se revine dupa limitare.</li>
+
+        <li><code>transientIgnoreMs</code>: ignora abateri scurte pentru a reduce reactiile la zgomot.</li>
+
+        <li><code>maxStepUpW</code> si <code>maxStepDownW</code>: limiteaza cresterea/scaderea comenzii pe ciclu.</li>
+
+        <li><code>adaptiveGains</code>, <code>adaptiveErrorBandW</code>, <code>adaptiveMinScale</code>: reduc castigurile cand eroarea este mica.</li>
+
+        <li><code>maxStepW</code>: compatibilitate legacy pentru pas maxim simetric.</li>
+
+        <li><code>staleTimeoutMs</code>: vechimea maxima acceptata pentru telemetrie.</li>
+
+        <li><code>maxFutureTimestampMs</code>: toleranta pentru timestamp-uri venite din viitor.</li>
+
+        <li><code>fastSetpointMaxTelemetryAgeMs</code>: permite aplicarea unui setpoint nou cu ultima telemetrie cache, doar daca aceasta este mai noua decat pragul.</li>
+
+        <li><code>outputHeartbeatMs</code>: retransmite periodic ultima limita neschimbata; intre heartbeat-uri comenzile identice sunt suprimate.</li>
+
+        <li><code>safeLimitOnStale</code>: limita folosita cand telemetria este stale.</li>
+
+        <li><code>debugLevel</code>: <code>off</code>, <code>normal</code> sau <code>verbose</code>.</li>
+
+        <li><code>startLimitMode</code>: alege limita initiala dupa deploy/restart.</li>
+
+        <li><code>useGlobalPvCap</code>, <code>globalPvTotalVar</code>, <code>globalPvCapOffsetW</code>: plafoneaza cresterea limitei dupa productia PV disponibila publicata global.</li>
+
+        <li><code>pvCapOnlyBlocksIncrease</code>: impiedica plafonul PV sa produca singur scaderi ale limitei.</li>
+
+        <li><code>pvCapHoldMs</code> si <code>pvCapReleaseWPerSec</code>: stabilizeaza estimarea puterii PV disponibile.</li>
+
+        <li><code>feedForwardEnabled</code> si <code>feedForwardGain</code>: activeaza anticiparea bazata pe balanta PV/PCC, limitata in continuare de rampe si PI.</li>
+
+        <li><code>failSecureEnabled</code> si <code>failSecureTimeSec</code>: activeaza iesirea de fail secure daca nodul ramane la limita minima si exportul rezidual continua prea mult timp.</li>
+
+        <li><code>loadNormalCustom</code>: valoare interna legacy pentru compatibilitate cu configuratii mai vechi.</li>
+
+    </ul>
+
+
+    <h3>Exemplu setpoint rapid fara oscilatii excesive</h3>
+
+    <pre>{
+  "topic": "control-export/setpoint",
+  "payload": {
+    "grid_target_w": -8000
+  }
+}</pre>
+
+    <p>Cu <code>fastSetpointMaxTelemetryAgeMs = 250</code>, nodul poate recalcula imediat daca ultima masurare de retea are sub 250 ms. Pentru stabilitate la telemetrie de 200 ms, foloseste presetul <code>stable_grid</code> si pastreaza <code>controlPeriodMs</code> mai mare decat perioada meterului.</p>
+
+
+</script>