@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/control-reactive/control-reactive.js

@@ -0,0 +1,2124 @@
+module.exports = function (RED) {
+
+
+    "use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+    const {
+        atLeast,
+        clampNumber,
+        toFiniteNumber
+    } = require("../lib/numbers");
+    const {
+        createA3TestServer
+    } = require("../lib/a3-test-server");
+
+
+
+    function clamp(value, min, max) {
+
+        if (!Number.isFinite(value)) return min;
+
+        return Math.min(Math.max(value, min), max);
+
+    }
+
+
+
+    function firstFinite() {
+
+        for (let i = 0; i < arguments.length; i++) {
+
+            if (arguments[i] === null || arguments[i] === undefined || arguments[i] === "") continue;
+
+            const n = Number(arguments[i]);
+
+            if (Number.isFinite(n)) return n;
+
+        }
+
+        return null;
+
+    }
+
+
+
+    function normalizeDebugLevel(value) {
+
+        const level = String(value || "").toLowerCase();
+
+        if (level === "normal" || level === "verbose") return level;
+
+        return "off";
+
+    }
+
+
+
+    function normalizeTuningPreset(value) {
+
+        const key = String(value || "").toLowerCase();
+
+        if (key === "custom" || key === "stable_grid") return key;
+
+        return "normal";
+
+    }
+
+
+
+    function extractTimestampMs(msg) {
+
+        const candidate = firstFinite(
+
+            msg && msg.timestamp,
+
+            msg && msg.ts,
+
+            msg && msg.time,
+
+            msg && msg.timestamp_ms,
+
+            msg && msg.time_ms,
+
+            msg && msg.payload && msg.payload.timestamp,
+
+            msg && msg.payload && msg.payload.ts,
+
+            msg && msg.payload && msg.payload.time,
+
+            msg && msg.payload && msg.payload.timestamp_ms,
+
+            msg && msg.payload && msg.payload.time_ms
+
+        );
+
+
+        if (candidate === null) return Date.now();
+
+        if (candidate < 1e11) return Math.round(candidate * 1000);
+
+        return Math.round(candidate);
+
+    }
+
+
+
+    function ReactiveControlNode(config) {
+
+        RED.nodes.createNode(this, config);
+
+
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+
+
+
+        node.name = config.name || "";
+
+        node.mode = config.mode || "zero_feed_in";
+
+        node.zeroFeedInMode = config.zeroFeedInMode === "absolute" ? "absolute" : "relative";
+
+        node.tuningPreset = normalizeTuningPreset(config.tuningPreset);
+
+
+        node.gridSetPointVar = toFiniteNumber(config.gridSetPointVar, 0);
+
+        node.configuredNominalReactivePowerVar = atLeast(config.nominalReactivePowerVar, 1, 25000);
+        node.nominalReactivePowerFromGlobal = !!config.nominalReactivePowerFromGlobal;
+        node.nominalReactivePowerGlobalVar = String(config.nominalReactivePowerGlobalVar || "max_q").trim() || "max_q";
+        node.nominalReactivePowerVar = node.configuredNominalReactivePowerVar;
+
+        node.fixedReactivePowerVar = toFiniteNumber(config.fixedReactivePowerVar, 0);
+        node.fixedReactivePowerFromGlobal = !!config.fixedReactivePowerFromGlobal;
+        node.fixedReactivePowerGlobalVar = String(config.fixedReactivePowerGlobalVar || "nominal_reactive_power").trim() || "nominal_reactive_power";
+
+
+        node.deadbandVar = atLeast(config.deadbandVar, 0, 100);
+
+        node.commandDeadbandVar = atLeast(config.commandDeadbandVar ?? config.outputDeadbandVar, 0, 50);
+
+        node.filterTauMs = atLeast(config.filterTauMs ?? config.avgWindowMs, 0, 4000);
+
+        node.noiseThresholdVar = atLeast(config.noiseThresholdVar, 0, 120);
+
+        node.noiseReleaseMs = atLeast(config.noiseReleaseMs, 0, 3000);
+
+        node.kp = atLeast(config.kp, 0, 0.08);
+
+        node.ki = atLeast(config.ki, 0, 0);
+
+        node.controlPeriodMs = atLeast(config.controlPeriodMs ?? config.sendIntervalMs, 50, 1000);
+
+        node.minCommandIntervalMs = atLeast(config.minCommandIntervalMs, 0, 10000);
+
+        node.settleAfterCommandMs = atLeast(config.settleAfterCommandMs ?? config.minCommandIntervalMs, 0, 10000);
+
+        node.transientIgnoreMs = atLeast(config.transientIgnoreMs, 0, 0);
+
+        node.maxStepUpVar = atLeast(config.maxStepUpVar, 0, 200);
+
+        node.maxStepDownVar = atLeast(config.maxStepDownVar, 0, 200);
+
+        node.adaptiveGains = config.adaptiveGains === true;
+
+        node.adaptiveErrorBandVar = atLeast(config.adaptiveErrorBandVar, 1, 2500);
+
+        node.adaptiveMinScale = clampNumber(config.adaptiveMinScale, 0.05, 1, 0.25);
+
+
+        node.maxStepVar = atLeast(config.maxStepVar, 0, 0); // legacy
+
+        if (node.maxStepUpVar <= 0 && node.maxStepVar > 0) node.maxStepUpVar = node.maxStepVar;
+
+        if (node.maxStepDownVar <= 0 && node.maxStepVar > 0) node.maxStepDownVar = node.maxStepVar;
+
+
+        node.staleTimeoutMs = atLeast(config.staleTimeoutMs, 0, 5000);
+
+        node.maxFutureTimestampMs = atLeast(config.maxFutureTimestampMs, 0, 2000);
+
+        node.safeLimitOnStale = clampNumber(config.safeLimitOnStale, -node.nominalReactivePowerVar, node.nominalReactivePowerVar, 0);
+
+        node.debugLevel = normalizeDebugLevel(config.debugLevel);
+
+        node.startLimitMode = (function(v) {
+
+            const m = String(v || "").toLowerCase();
+
+            if (m === "last_limit") return m;
+
+            return "last_limit";
+
+        })(config.startLimitMode);
+
+        node.failSecureEnabled = !!config.failSecureEnabled;
+
+        node.failSecureTimeSec = atLeast(config.failSecureTimeSec, 1, 10);
+        node.a3TestsEnabled = !!config.a3TestsEnabled;
+        node.a3ModbusHost = String(config.a3ModbusHost || "0.0.0.0").trim() || "0.0.0.0";
+        node.a3ModbusPort = atLeast(config.a3ModbusPort, 1, 1503);
+        node.a3ModbusUnitId = atLeast(config.a3ModbusUnitId, 0, 1);
+        node.a3RampType = String(config.a3RampType || "none").trim() || "none";
+        node.a3RampValue = atLeast(config.a3RampValue, 0, 0);
+
+
+        node.outputTopic = String(config.outputTopic || "control-reactive").trim() || "control-reactive";
+
+        if (node.a3TestsEnabled) {
+            node.mode = "nominal_reactive_power";
+            node.fixedReactivePowerFromGlobal = false;
+            node.nominalReactivePowerFromGlobal = false;
+        }
+
+
+
+        const tuningPresets = {
+
+            normal: {
+
+                deadbandVar: 100,
+
+                filterTauMs: 2000,
+
+                kp: 0.08,
+
+                ki: 0,
+
+                transientIgnoreMs: 0,
+
+                maxStepUpVar: 200,
+
+                maxStepDownVar: 200,
+
+                adaptiveGains: false,
+
+                adaptiveErrorBandVar: 2000,
+
+                adaptiveMinScale: 0.2
+
+            },
+
+            stable_grid: {
+
+                deadbandVar: 150,
+
+                filterTauMs: 5000,
+
+                kp: 0.06,
+
+                ki: 0,
+
+                transientIgnoreMs: 0,
+
+                maxStepUpVar: 120,
+
+                maxStepDownVar: 120,
+
+                adaptiveGains: false,
+
+                adaptiveErrorBandVar: 2500,
+
+                adaptiveMinScale: 0.25
+
+            }
+
+        };
+
+
+        if (node.tuningPreset !== "custom") {
+
+            const preset = tuningPresets[node.tuningPreset] || tuningPresets.normal;
+
+            node.deadbandVar = preset.deadbandVar;
+
+            node.filterTauMs = preset.filterTauMs;
+
+            node.kp = preset.kp;
+
+            node.ki = preset.ki;
+
+            node.transientIgnoreMs = preset.transientIgnoreMs;
+
+            node.maxStepUpVar = preset.maxStepUpVar;
+
+            node.maxStepDownVar = preset.maxStepDownVar;
+
+            node.adaptiveGains = preset.adaptiveGains;
+
+            node.adaptiveErrorBandVar = preset.adaptiveErrorBandVar;
+
+            node.adaptiveMinScale = preset.adaptiveMinScale;
+
+        }
+
+
+
+        let enabled = true;
+
+        let lastLimit = null;
+
+        let filteredReactiveReference = null;
+
+        let lastMeasurementTs = null;
+
+        let lastControlTs = 0;
+
+        let lastRawReactiveReference = null;
+
+        let lastMsgTimestampMs = null;
+
+        let lastAcceptedMeasurementTs = null;
+
+        let integratorState = 0;
+
+        let outsideDeadbandSinceMs = null;
+
+        let failSecureBreachStartMs = null;
+
+        let failSecureActive = false;
+
+        let hasEmittedCommand = false;
+
+        let lastCommandSentAtMs = 0;
+
+        let lastFailSecureOutputActive = false;
+        let watchdogTimer = null;
+        let a3Server = null;
+        let lastInputAtMs = null;
+        let watchdogSafeEmitted = false;
+
+        let settleUntilMs = 0;
+
+        let noiseMetricVar = 0;
+
+        let noiseBelowSinceMs = null;
+
+        let lastNoiseReference = null;
+
+        let lastNoiseTimestampMs = null;
+
+
+        const nodeCtx = node.context();
+        const globalCtx = node.context().global;
+
+
+        function refreshNominalReactivePowerFromGlobal() {
+
+            let maxQ = node.configuredNominalReactivePowerVar;
+
+            if (node.nominalReactivePowerFromGlobal) {
+
+                const value = Number(globalCtx.get(node.nominalReactivePowerGlobalVar));
+
+                if (Number.isFinite(value)) maxQ = value;
+
+            }
+
+            node.nominalReactivePowerVar = Math.max(1, maxQ);
+
+            return node.nominalReactivePowerVar;
+
+        }
+
+        function validateRequiredGlobalValues() {
+
+            const requirements = [];
+            if (node.fixedReactivePowerFromGlobal) requirements.push([node.fixedReactivePowerGlobalVar, "Fixed Q", 0]);
+            if (node.nominalReactivePowerFromGlobal) requirements.push([node.nominalReactivePowerGlobalVar, "Max Q", 1]);
+
+            for (const requirement of requirements) {
+
+                const key = String(requirement[0] || "").trim();
+                const raw = key ? globalCtx.get(key) : undefined;
+                const value = Number(raw);
+                if (raw === undefined || raw === null || raw === "" || !Number.isFinite(value) || (requirement[2] > 0 && value < requirement[2])) {
+                    node.status({ fill: "red", shape: "ring", text: "ALARM: global " + requirement[1] + " missing (" + key + ")" });
+                    return false;
+                }
+
+            }
+
+            return true;
+
+        }
+
+        if (!validateRequiredGlobalValues()) {
+
+            node.warn("control-reactive blocked: required global value is missing or invalid");
+
+        }
+
+
+
+        function getPersistedLastLimit() {
+
+            const n = Number(nodeCtx.get("control_reactive_last_limit_var"));
+
+            if (!Number.isFinite(n)) return null;
+
+            return clamp(n, -node.nominalReactivePowerVar, node.nominalReactivePowerVar);
+
+        }
+
+
+
+        function persistLastLimit(value) {
+
+            if (!Number.isFinite(value)) return;
+
+            nodeCtx.set(
+
+                "control_reactive_last_limit_var",
+
+                clamp(Number(value), -node.nominalReactivePowerVar, node.nominalReactivePowerVar)
+
+            );
+
+        }
+
+
+
+        (function initializeStartLimit() {
+
+            if (node.startLimitMode === "last_limit") {
+
+                const persisted = getPersistedLastLimit();
+
+                if (Number.isFinite(persisted)) {
+
+                    lastLimit = persisted;
+
+                    hasEmittedCommand = true;
+
+                    return;
+
+                }
+
+            }
+
+            lastLimit = 0;
+
+        })();
+
+
+
+        function restoreStartLimitState(nowMs) {
+
+            if (node.startLimitMode === "last_limit") {
+
+                const persisted = getPersistedLastLimit();
+
+                if (Number.isFinite(persisted)) {
+
+                    lastLimit = persisted;
+
+                    hasEmittedCommand = true;
+
+                    lastCommandSentAtMs = nowMs;
+
+                    settleUntilMs = nowMs + node.settleAfterCommandMs;
+
+                    resetPostCommandObservation();
+
+                    return;
+
+                }
+
+            }
+
+
+            lastLimit = 0;
+
+            hasEmittedCommand = false;
+
+            lastCommandSentAtMs = 0;
+
+            settleUntilMs = 0;
+
+        }
+
+
+
+        function resetControlState() {
+
+            integratorState = 0;
+
+            filteredReactiveReference = null;
+
+            lastMeasurementTs = null;
+
+            lastControlTs = 0;
+
+            lastAcceptedMeasurementTs = null;
+
+            outsideDeadbandSinceMs = null;
+
+            failSecureBreachStartMs = null;
+
+            failSecureActive = false;
+
+            settleUntilMs = 0;
+
+            noiseMetricVar = 0;
+
+            noiseBelowSinceMs = null;
+
+            lastNoiseReference = null;
+
+            lastNoiseTimestampMs = null;
+
+        }
+
+
+
+        function resetPostCommandObservation() {
+
+            integratorState = 0;
+
+            outsideDeadbandSinceMs = null;
+
+            noiseMetricVar = 0;
+
+            noiseBelowSinceMs = null;
+
+            lastNoiseReference = null;
+
+            lastNoiseTimestampMs = null;
+
+        }
+
+
+
+        function shouldEmitCommand(nextLimit, reason, nowMs) {
+
+            if (!Number.isFinite(nextLimit)) return false;
+
+            if (!hasEmittedCommand) return true;
+
+
+            const previousLimit = Number.isFinite(lastLimit) ? Number(lastLimit) : null;
+
+            if (!Number.isFinite(previousLimit)) return true;
+
+
+            const delta = Math.abs(Number(nextLimit) - previousLimit);
+
+            const roundedChanged = Math.round(nextLimit) !== Math.round(previousLimit);
+
+            const intervalOk = node.minCommandIntervalMs <= 0 ||
+
+                !Number.isFinite(lastCommandSentAtMs) ||
+
+                lastCommandSentAtMs <= 0 ||
+
+                (nowMs - lastCommandSentAtMs) >= node.minCommandIntervalMs;
+
+
+            if (!roundedChanged) return false;
+
+            if (reason === "stale") return true;
+
+            if (delta < node.commandDeadbandVar) return false;
+
+            return intervalOk;
+
+        }
+
+
+
+        function updateNoiseState(referenceVar, measurementTsMs) {
+
+            if (!Number.isFinite(referenceVar)) {
+
+                return {
+
+                    metricVar: noiseMetricVar,
+
+                    stable: true,
+
+                    durationMs: 0
+
+                };
+
+            }
+
+
+            if (!Number.isFinite(lastNoiseReference)) {
+
+                lastNoiseReference = Number(referenceVar);
+
+                lastNoiseTimestampMs = measurementTsMs;
+
+                noiseMetricVar = 0;
+
+                noiseBelowSinceMs = measurementTsMs;
+
+                return {
+
+                    metricVar: noiseMetricVar,
+
+                    stable: true,
+
+                    durationMs: 0
+
+                };
+
+            }
+
+
+            const dtMs = Number.isFinite(measurementTsMs) && Number.isFinite(lastNoiseTimestampMs)
+
+                ? Math.max(1, measurementTsMs - lastNoiseTimestampMs)
+
+                : Math.max(1, node.controlPeriodMs);
+
+            const alpha = node.filterTauMs > 0
+
+                ? clamp(dtMs / (node.filterTauMs + dtMs), 0, 1)
+
+                : 1;
+
+
+            const deltaVar = Math.abs(Number(referenceVar) - Number(lastNoiseReference));
+
+            noiseMetricVar = alpha * deltaVar + (1 - alpha) * noiseMetricVar;
+
+            lastNoiseReference = Number(referenceVar);
+
+            lastNoiseTimestampMs = measurementTsMs;
+
+
+            if (node.noiseThresholdVar <= 0) {
+
+                noiseBelowSinceMs = measurementTsMs;
+
+                return {
+
+                    metricVar: noiseMetricVar,
+
+                    stable: true,
+
+                    durationMs: 0
+
+                };
+
+            }
+
+
+            if (noiseMetricVar <= node.noiseThresholdVar) {
+
+                if (!Number.isFinite(noiseBelowSinceMs)) {
+
+                    noiseBelowSinceMs = measurementTsMs;
+
+                }
+
+            } else {
+
+                noiseBelowSinceMs = null;
+
+            }
+
+
+            const stableDurationMs = Number.isFinite(noiseBelowSinceMs)
+
+                ? Math.max(0, measurementTsMs - noiseBelowSinceMs)
+
+                : 0;
+
+            const stable = noiseMetricVar <= node.noiseThresholdVar &&
+
+                (node.noiseReleaseMs <= 0 || stableDurationMs >= node.noiseReleaseMs);
+
+
+            return {
+
+                metricVar: noiseMetricVar,
+
+                stable: stable,
+
+                durationMs: stableDurationMs
+
+            };
+
+        }
+
+
+
+        function markCommandEmitted(siteLimit, nowMs) {
+
+            lastLimit = clamp(Number(siteLimit), -node.nominalReactivePowerVar, node.nominalReactivePowerVar);
+
+            lastCommandSentAtMs = nowMs;
+
+            settleUntilMs = nowMs + node.settleAfterCommandMs;
+
+            hasEmittedCommand = true;
+
+            resetPostCommandObservation();
+
+            persistLastLimit(lastLimit);
+
+        }
+
+
+
+        function isStale(timestampMs, nowMs) {
+
+            if (node.staleTimeoutMs <= 0) return false;
+
+            if (!Number.isFinite(timestampMs)) return true;
+
+            return (nowMs - timestampMs) > node.staleTimeoutMs;
+
+        }
+
+
+
+        function effectiveGains(errorAbs) {
+
+            if (!node.adaptiveGains) {
+
+                return { kp: node.kp, ki: node.ki, scale: 1 };
+
+            }
+
+
+            const progress = clamp(Number(errorAbs || 0) / node.adaptiveErrorBandVar, 0, 1);
+
+            const scale = node.adaptiveMinScale + (1 - node.adaptiveMinScale) * progress;
+
+            return {
+
+                kp: node.kp * scale,
+
+                ki: node.ki * scale,
+
+                scale: scale
+
+            };
+
+        }
+
+
+
+        function extractReactiveTelemetry(msg) {
+
+            const p = msg && msg.payload;
+
+            if (!p || typeof p !== "object") {
+
+                return {
+
+                    ok: false,
+
+                    missing: ["reactive_l1_var", "reactive_l2_var", "reactive_l3_var", "reactive_total_var"],
+
+                    values: null
+
+                };
+
+            }
+
+
+            const summary = p.summary || {};
+
+            const reactive = summary.reactive || {};
+
+            const reactivePower = p.reactive_power || {};
+
+
+            const l1 = firstFinite(
+
+                p.reactive_l1_var,
+
+                p.q_l1_var,
+
+                reactive.l1_var,
+
+                reactivePower.l1_var
+
+            );
+
+            const l2 = firstFinite(
+
+                p.reactive_l2_var,
+
+                p.q_l2_var,
+
+                reactive.l2_var,
+
+                reactivePower.l2_var
+
+            );
+
+            const l3 = firstFinite(
+
+                p.reactive_l3_var,
+
+                p.q_l3_var,
+
+                reactive.l3_var,
+
+                reactivePower.l3_var
+
+            );
+
+            const total = firstFinite(
+
+                p.reactive_total_var,
+
+                p.q_total_var,
+
+                p.grid_reactive_power_var,
+
+                p.reactive_power_var,
+
+                reactive.total_var,
+
+                reactivePower.total_var
+
+            );
+
+
+            const missing = [];
+
+            if (!Number.isFinite(l1)) missing.push("reactive_l1_var");
+
+            if (!Number.isFinite(l2)) missing.push("reactive_l2_var");
+
+            if (!Number.isFinite(l3)) missing.push("reactive_l3_var");
+
+            if (!Number.isFinite(total)) missing.push("reactive_total_var");
+
+
+            if (missing.length > 0) {
+
+                return { ok: false, missing: missing, values: null };
+
+            }
+
+
+            return {
+
+                ok: true,
+
+                missing: [],
+
+                values: { l1: Number(l1), l2: Number(l2), l3: Number(l3), total: Number(total) }
+
+            };
+
+        }
+
+
+        function closestPhaseReactiveValue(values) {
+
+            if (!values) return null;
+
+            const list = [values.l1, values.l2, values.l3].filter(function (v) { return Number.isFinite(v); });
+
+            if (!list.length) return null;
+
+            return list.reduce(function (best, value) {
+
+                if (!Number.isFinite(best)) return value;
+
+                return Math.abs(value) < Math.abs(best) ? value : best;
+
+            }, null);
+
+        }
+
+
+        function extractControlReactiveReference(msg) {
+
+            const telemetry = extractReactiveTelemetry(msg);
+
+            if (!telemetry.ok) {
+
+                return telemetry;
+
+            }
+
+
+            const values = telemetry.values;
+
+            if (node.mode === "zero_feed_in" && node.zeroFeedInMode === "absolute") {
+
+                const closest = closestPhaseReactiveValue(values);
+
+                if (!Number.isFinite(closest)) {
+
+                    return {
+
+                        ok: false,
+
+                        missing: ["reactive_l1_var", "reactive_l2_var", "reactive_l3_var"],
+
+                        values: null
+
+                    };
+
+                }
+
+                return { ok: true, missing: [], values: values, reference: Number(closest) };
+
+            }
+
+
+            return { ok: true, missing: [], values: values, reference: Number(values.total) };
+
+        }
+
+
+
+        function updateFilter(reactiveReference, measurementTsMs) {
+
+            if (!Number.isFinite(reactiveReference)) return filteredReactiveReference;
+
+
+            if (filteredReactiveReference === null || !Number.isFinite(lastMeasurementTs)) {
+
+                filteredReactiveReference = reactiveReference;
+
+                lastMeasurementTs = measurementTsMs;
+
+                return filteredReactiveReference;
+
+            }
+
+
+            const dtMs = Math.max(1, measurementTsMs - lastMeasurementTs);
+
+            const alpha = node.filterTauMs > 0
+
+                ? clamp(dtMs / (node.filterTauMs + dtMs), 0, 1)
+
+                : 1;
+
+
+            filteredReactiveReference = alpha * reactiveReference + (1 - alpha) * filteredReactiveReference;
+
+            lastMeasurementTs = measurementTsMs;
+
+            return filteredReactiveReference;
+
+        }
+
+
+
+        function getReactiveTargetVar() {
+
+            if (node.mode === "zero_feed_in") return 0;
+
+            if (node.mode === "grid_set_point") return Number(node.gridSetPointVar || 0);
+
+            return null;
+
+        }
+
+        function readFixedReactivePowerVar() {
+            if (node.a3TestsEnabled && a3Server) {
+                const command = a3Server.getCommand();
+                if (command && Number.isFinite(command.nominalPower)) {
+                    return command.nominalPower;
+                }
+            }
+
+            if (!node.fixedReactivePowerFromGlobal) {
+                return Number(node.fixedReactivePowerVar);
+            }
+
+            const key = String(node.fixedReactivePowerGlobalVar || "").trim();
+            if (!key) {
+                return Number(node.fixedReactivePowerVar);
+            }
+
+            const raw = globalCtx.get(key);
+            const n = Number(raw);
+            if (Number.isFinite(n)) {
+                return n;
+            }
+
+            return Number(node.fixedReactivePowerVar);
+        }
+
+
+
+        function computeClosedLoopLimit(filteredReference) {
+
+            const target = getReactiveTargetVar();
+
+            const error = filteredReference - target;
+
+            const previousLimit = Number.isFinite(lastLimit)
+
+                ? lastLimit
+
+                : 0;
+
+
+            if (Math.abs(error) <= node.deadbandVar && Number.isFinite(lastLimit)) {
+
+                return {
+
+                    siteLimit: previousLimit,
+
+                    reactiveTargetVar: target,
+
+                    correction: 0,
+
+                    error: error,
+
+                    pTerm: 0,
+
+                    iTerm: 0,
+
+                    active: false,
+
+                    rampDirection: "hold",
+
+                    reason: "deadband",
+
+                    controllerState: "inside_deadband",
+
+                    clampedByMin: false,
+
+                    clampedByMax: false,
+
+                    effectiveKp: node.kp,
+
+                    effectiveKi: 0,
+
+                    gainsScale: 1
+
+                };
+
+            }
+
+
+            const proportionalStep = node.kp > 0
+
+                ? error * node.kp
+
+                : error;
+
+            let candidateLimit = previousLimit + proportionalStep;
+
+
+            const maxStepUp = node.maxStepUpVar > 0 ? node.maxStepUpVar : Infinity;
+
+            const maxStepDown = node.maxStepDownVar > 0 ? node.maxStepDownVar : Infinity;
+
+            const rawDelta = candidateLimit - previousLimit;
+
+
+            if (rawDelta > maxStepUp) {
+
+                candidateLimit = previousLimit + maxStepUp;
+
+            } else if (rawDelta < -maxStepDown) {
+
+                candidateLimit = previousLimit - maxStepDown;
+
+            }
+
+
+            const unclampedCandidate = candidateLimit;
+
+            candidateLimit = clamp(candidateLimit, -node.nominalReactivePowerVar, node.nominalReactivePowerVar);
+
+
+            const clampedByMin = candidateLimit <= -node.nominalReactivePowerVar && unclampedCandidate < -node.nominalReactivePowerVar;
+
+            const clampedByMax = candidateLimit >= node.nominalReactivePowerVar && unclampedCandidate > node.nominalReactivePowerVar;
+
+
+            const rampDirection = candidateLimit > previousLimit
+
+                ? "up"
+
+                : candidateLimit < previousLimit
+
+                    ? "down"
+
+                    : "hold";
+
+
+            let controllerState = "tracking";
+
+            if (clampedByMin) controllerState = "at_min_limit";
+
+            else if (clampedByMax) controllerState = "at_max_limit";
+
+            else if (rampDirection === "up") controllerState = "increasing_limit";
+
+            else if (rampDirection === "down") controllerState = "decreasing_limit";
+
+
+            return {
+
+                siteLimit: candidateLimit,
+
+                reactiveTargetVar: target,
+
+                correction: candidateLimit - previousLimit,
+
+                error: error,
+
+                pTerm: candidateLimit - previousLimit,
+
+                iTerm: 0,
+
+                active: rampDirection !== "hold",
+
+                rampDirection: rampDirection,
+
+                reason: "tracking",
+
+                controllerState: controllerState,
+
+                clampedByMin: clampedByMin,
+
+                clampedByMax: clampedByMax,
+
+                effectiveKp: node.kp,
+
+                effectiveKi: 0,
+
+                gainsScale: 1
+
+            };
+
+        }
+
+
+        function buildStatus(info) {
+
+            if (info.reason === "stale") {
+
+                node.status({ fill: "yellow", shape: "ring", text: "stale | limit " + Math.round(info.siteLimit) + "VAr" });
+
+                return;
+
+            }
+
+
+            if (info.mode === "nominal_reactive_power") {
+
+                node.status({ fill: "blue", shape: "dot", text: "nominal | limit " + Math.round(info.siteLimit) + "VAr" });
+
+                return;
+
+            }
+
+
+            const reactiveNow = Number.isFinite(info.reactiveReference) ? Math.round(info.reactiveReference) : 0;
+
+            const target = Number.isFinite(info.reactiveTargetVar) ? Math.round(info.reactiveTargetVar) : 0;
+
+            const limit = Math.round(info.siteLimit);
+
+            const state = info.controllerState || info.reason || "idle";
+
+            const text = "q " + reactiveNow + "VAr | target " + target + "VAr | limit " + limit + "VAr | " + state;
+
+
+            if (info.active) {
+
+                node.status({ fill: "green", shape: "dot", text: text });
+
+                return;
+
+            }
+
+
+            node.status({ fill: "blue", shape: "ring", text: text });
+
+        }
+
+
+
+        function computeAutoRampSeconds() {
+
+            const intervalSeconds = Math.round(Math.max(0, Number(node.minCommandIntervalMs || 0)) / 1000);
+
+            return Math.max(0, intervalSeconds - 1);
+
+        }
+
+
+
+        function buildOutputPayload(context) {
+
+            const autoRampSeconds = computeAutoRampSeconds();
+
+            const basePayload = {
+
+                powerType: "reactive",
+
+                mode: "vars",
+
+                limit_var: Math.round(context.siteLimit),
+
+                ramp: node.a3TestsEnabled && a3Server ? {
+
+                    type: a3Server.getCommand().rampType,
+
+                    value: a3Server.getCommand().rampValue
+
+                } : {
+
+                    type: "time",
+
+                    value: autoRampSeconds
+
+                },
+
+                grid_reference_var: Number.isFinite(context.filteredReference) ? Math.round(context.filteredReference) : null,
+
+                grid_target_var: Number.isFinite(context.reactiveTargetVar) ? Math.round(context.reactiveTargetVar) : null,
+
+                reason: context.reason,
+
+                controller_state: context.controllerState,
+
+                stale: context.stale,
+
+                timestamp_ms: context.msgTimestampMs
+
+            };
+
+            if (node.a3TestsEnabled) {
+                const command = a3Server ? a3Server.getCommand() : null;
+                basePayload.a3_tests = true;
+                basePayload.a3_sequence = command ? command.sequence : 0;
+            }
+
+
+            if (node.debugLevel === "off") {
+
+                return basePayload;
+
+            }
+
+
+            const normalPayload = Object.assign({}, basePayload, {
+
+                raw_grid_reference_var: Number.isFinite(context.rawReactiveReference) ? Math.round(context.rawReactiveReference) : null,
+
+                filtered_grid_reference_var: Number.isFinite(context.filteredReference) ? Math.round(context.filteredReference) : null,
+
+                error_var: Number.isFinite(context.error) ? Math.round(context.error) : null,
+
+                correction_var: Number.isFinite(context.correction) ? Math.round(context.correction) : null,
+
+                noise_metric_var: Number.isFinite(context.noiseMetricVar) ? Math.round(context.noiseMetricVar) : null,
+
+                noise_stable: context.noiseStable,
+
+                noise_stable_duration_ms: context.noiseStableDurationMs,
+
+                settle_remaining_ms: context.settleRemainingMs,
+
+                auto_ramp_seconds: autoRampSeconds,
+
+                control_active: context.active,
+
+                ramp_direction: context.rampDirection,
+
+                clamped_by_min: context.clampedByMin,
+
+                clamped_by_max: context.clampedByMax,
+
+                measurement_age_ms: context.measurementAgeMs
+
+            });
+
+
+            if (node.debugLevel === "normal") {
+
+                return normalPayload;
+
+            }
+
+
+            return Object.assign({}, normalPayload, {
+
+                p_term_var: context.pTerm,
+
+                i_term_var: context.iTerm,
+
+                effective_kp: context.effectiveKp,
+
+                effective_ki: context.effectiveKi,
+
+                adaptive_gain_scale: context.gainsScale,
+
+                kp: node.kp,
+
+                ki: node.ki,
+
+                max_step_up_var: node.maxStepUpVar,
+
+                max_step_down_var: node.maxStepDownVar,
+
+                adaptive_gains: node.adaptiveGains,
+
+                adaptive_error_band_var: node.adaptiveErrorBandVar,
+
+                adaptive_min_scale: node.adaptiveMinScale,
+
+                control_period_ms: node.controlPeriodMs,
+
+                filter_tau_ms: node.filterTauMs,
+
+                debug_level: node.debugLevel
+
+            });
+
+        }
+
+
+
+        function evaluateFailSecure(context, nowMs) {
+
+            if (!node.failSecureEnabled) {
+
+                failSecureBreachStartMs = null;
+
+                failSecureActive = false;
+
+                return {
+
+                    active: false,
+
+                    durationMs: 0,
+
+                    nominalReactivePowerVar: node.nominalReactivePowerVar,
+
+                    siteLimitVar: Number(context && context.siteLimit)
+
+                };
+
+            }
+
+
+            const siteLimitVar = Number(context && context.siteLimit);
+
+            const epsilon = 1e-6;
+
+            const eligible = node.mode !== "nominal_reactive_power" && Number.isFinite(siteLimitVar);
+
+            const violation = eligible && Math.abs(siteLimitVar) >= (node.nominalReactivePowerVar - epsilon);
+
+
+            if (violation) {
+
+                if (!Number.isFinite(failSecureBreachStartMs)) {
+
+                    failSecureBreachStartMs = nowMs;
+
+                }
+
+                const durationMs = Math.max(0, nowMs - failSecureBreachStartMs);
+
+                const triggerMs = Math.max(1000, Math.round(node.failSecureTimeSec * 1000));
+
+                failSecureActive = durationMs >= triggerMs;
+
+                return {
+
+                    active: failSecureActive,
+
+                    durationMs: durationMs,
+
+                    nominalReactivePowerVar: node.nominalReactivePowerVar,
+
+                    siteLimitVar: siteLimitVar
+
+                };
+
+            }
+
+
+            failSecureBreachStartMs = null;
+
+            failSecureActive = false;
+
+            return {
+
+                active: false,
+
+                durationMs: 0,
+
+                nominalReactivePowerVar: node.nominalReactivePowerVar,
+
+                siteLimitVar: siteLimitVar
+
+            };
+
+        }
+
+
+
+        function emitStopZero(send, nowMs) {
+
+            const out = {
+
+                topic: node.outputTopic,
+
+                payload: buildOutputPayload({
+
+                    siteLimit: 0,
+
+                    rawReactiveReference: null,
+
+                    filteredReference: null,
+
+                    reactiveTargetVar: 0,
+
+                    correction: 0,
+
+                    error: 0,
+
+                    pTerm: 0,
+
+                    iTerm: 0,
+
+                    active: false,
+
+                    reason: "stop_zero",
+
+                    controllerState: "stopped",
+
+                    stale: false,
+
+                    rampDirection: "hold",
+
+                    clampedByMin: false,
+
+                    clampedByMax: false,
+
+                    measurementAgeMs: 0,
+
+                    effectiveKp: node.kp,
+
+                    effectiveKi: node.ki,
+
+                    gainsScale: 1,
+
+                    msgTimestampMs: nowMs
+
+                }),
+
+                controller: {
+
+                    type: "control-reactive",
+
+                    mode: node.mode,
+
+                    reason: "stop_zero",
+
+                    timestamp_ms: nowMs
+
+                }
+
+            };
+
+
+            node.status({ fill: "red", shape: "dot", text: "AUTO Q STOP -> send Q=0" });
+
+            markCommandEmitted(0, nowMs);
+
+            send(out);
+
+        }
+
+
+        function emitA3NominalCommand(nowMs, reason) {
+            const command = a3Server ? a3Server.getCommand() : {
+                nominalPower: node.fixedReactivePowerVar,
+                rampType: node.a3RampType,
+                rampValue: node.a3RampValue,
+                sequence: 0
+            };
+            const siteLimit = clamp(command.nominalPower, -node.nominalReactivePowerVar, node.nominalReactivePowerVar);
+
+            lastLimit = siteLimit;
+            hasEmittedCommand = true;
+            lastCommandSentAtMs = nowMs;
+            persistLastLimit(lastLimit);
+
+            buildStatus({
+                mode: "nominal_reactive_power",
+                siteLimit: siteLimit,
+                reactiveReference: lastRawReactiveReference,
+                reactiveTargetVar: null,
+                active: false,
+                reason: reason || "a3_modbus_command",
+                rampDirection: "hold",
+                controllerState: "a3_nominal_mode"
+            });
+
+            node.send({
+                topic: node.outputTopic,
+                payload: buildOutputPayload({
+                    siteLimit: siteLimit,
+                    rawReactiveReference: null,
+                    filteredReference: filteredReactiveReference,
+                    reactiveTargetVar: null,
+                    correction: 0,
+                    error: null,
+                    pTerm: 0,
+                    effectiveKp: node.kp,
+                    effectiveKi: node.ki,
+                    gainsScale: 1,
+                    iTerm: 0,
+                    active: false,
+                    reason: reason || "a3_modbus_command",
+                    controllerState: "a3_nominal_mode",
+                    stale: false,
+                    rampDirection: "hold",
+                    clampedByMin: siteLimit <= -node.nominalReactivePowerVar,
+                    clampedByMax: siteLimit >= node.nominalReactivePowerVar,
+                    noiseMetricVar: noiseMetricVar,
+                    noiseStable: true,
+                    noiseStableDurationMs: 0,
+                    settleRemainingMs: 0,
+                    measurementAgeMs: null,
+                    msgTimestampMs: nowMs
+                })
+            });
+
+        }
+
+
+
+        node.on("input", function (msg, send, done) {
+
+            try {
+                const nowMs = Date.now();
+
+                const topic = String(msg && msg.topic || "").trim().toLowerCase();
+
+                if (topic !== "stop" && !validateRequiredGlobalValues()) {
+
+                    done();
+
+                    return;
+
+                }
+
+
+                if (topic === "start") {
+
+                    enabled = true;
+
+                    resetControlState();
+
+                    restoreStartLimitState(nowMs);
+
+                    node.status({
+
+                        fill: "green",
+
+                        shape: "dot",
+
+                        text: "AUTO Q START | limit " + Math.round(lastLimit || 0) + "VAr"
+
+                    });
+
+                    done();
+
+                    return;
+
+                }
+
+
+                if (topic === "stop") {
+
+                    enabled = false;
+
+                    resetControlState();
+
+                    emitStopZero(send, nowMs);
+
+                    done();
+
+                    return;
+
+                }
+
+                refreshNominalReactivePowerFromGlobal();
+
+
+                if (!enabled) {
+
+                    node.status({ fill: "grey", shape: "ring", text: "AUTO disabled -> idle" });
+
+                    done();
+
+                    return;
+
+                }
+
+
+                const msgTimestampMs = extractTimestampMs(msg);
+
+                if ((msgTimestampMs - nowMs) > node.maxFutureTimestampMs) {
+                    throw new Error("Timestamp din viitor peste limita admisa");
+                }
+
+                const stale = isStale(msgTimestampMs, nowMs);
+
+                if (!stale && Number.isFinite(lastAcceptedMeasurementTs) && msgTimestampMs < lastAcceptedMeasurementTs) {
+                    node.status({ fill: "yellow", shape: "ring", text: "ignored older telemetry" });
+                    done();
+                    return;
+                }
+
+                const controlDue = !hasEmittedCommand || (nowMs - lastCommandSentAtMs) >= node.minCommandIntervalMs;
+
+
+                let siteLimit;
+
+                let reactiveReference = lastRawReactiveReference;
+
+                let filteredReference = filteredReactiveReference;
+
+                let reactiveTargetVar = null;
+
+                let correction = null;
+
+                let error = null;
+
+                let pTerm = null;
+
+                let effectiveKp = null;
+
+                let effectiveKi = null;
+
+                let gainsScale = null;
+
+                let iTerm = integratorState;
+
+                let active = false;
+
+                let reason = "nominal";
+
+                let rampDirection = "hold";
+
+                let controllerState = node.mode === "nominal_reactive_power" ? "nominal_mode" : "waiting_measurement";
+
+                let clampedByMin = false;
+
+                let clampedByMax = false;
+
+                let rawReactiveReference = null;
+
+                let noiseStable = true;
+
+                let noiseStableDurationMs = 0;
+
+                let settleRemainingMs = Math.max(0, lastCommandSentAtMs > 0 ? (node.minCommandIntervalMs - (nowMs - lastCommandSentAtMs)) : 0);
+
+
+                if (node.mode === "nominal_reactive_power") {
+
+                    outsideDeadbandSinceMs = null;
+
+                    siteLimit = clamp(readFixedReactivePowerVar(), -node.nominalReactivePowerVar, node.nominalReactivePowerVar);
+
+                    reason = "nominal";
+
+                    integratorState = 0;
+
+                } else if (stale) {
+
+                    outsideDeadbandSinceMs = null;
+
+                    siteLimit = clamp(node.safeLimitOnStale, -node.nominalReactivePowerVar, node.nominalReactivePowerVar);
+
+                    reason = "stale";
+
+                    controllerState = "stale_fallback";
+
+                    integratorState = 0;
+
+                } else {
+
+                    const reactiveInput = extractControlReactiveReference(msg);
+
+                    if (!reactiveInput.ok || !Number.isFinite(reactiveInput.reference)) {
+
+                        const missingList = reactiveInput && Array.isArray(reactiveInput.missing)
+
+                            ? reactiveInput.missing.join(", ")
+
+                            : "reactive_l1_var, reactive_l2_var, reactive_l3_var, reactive_total_var";
+
+                        throw new Error("Lipsesc valori reactive meter: " + missingList);
+
+                    }
+
+                    rawReactiveReference = reactiveInput.reference;
+                    lastInputAtMs = nowMs;
+                    watchdogSafeEmitted = false;
+
+
+                    reactiveReference = rawReactiveReference;
+
+                    filteredReference = updateFilter(reactiveReference, msgTimestampMs);
+
+                    noiseMetricVar = 0;
+
+                    noiseStable = true;
+
+                    noiseStableDurationMs = 0;
+
+                    lastRawReactiveReference = reactiveReference;
+
+                    lastMsgTimestampMs = msgTimestampMs;
+
+                    lastAcceptedMeasurementTs = msgTimestampMs;
+
+
+                    if (controlDue) {
+
+                        const result = computeClosedLoopLimit(filteredReference);
+
+
+                        siteLimit = result.siteLimit;
+
+                        reactiveTargetVar = result.reactiveTargetVar;
+
+                        correction = result.correction;
+
+                        error = result.error;
+
+                        pTerm = result.pTerm;
+
+                        effectiveKp = result.effectiveKp;
+
+                        effectiveKi = result.effectiveKi;
+
+                        gainsScale = result.gainsScale;
+
+                        iTerm = result.iTerm;
+
+                        active = result.active;
+
+                        reason = result.reason;
+
+                        rampDirection = result.rampDirection;
+
+                        controllerState = result.controllerState;
+
+                        clampedByMin = result.clampedByMin;
+
+                        clampedByMax = result.clampedByMax;
+
+                    } else {
+
+                        siteLimit = Number.isFinite(lastLimit) ? lastLimit : 0;
+
+                        reactiveTargetVar = getReactiveTargetVar();
+
+                        error = Number.isFinite(filteredReference) ? (filteredReference - reactiveTargetVar) : null;
+
+                        pTerm = Number.isFinite(error) ? node.kp * error : null;
+
+                        effectiveKp = node.kp;
+
+                        effectiveKi = node.ki;
+
+                        gainsScale = 1;
+
+                        iTerm = integratorState;
+
+                        correction = 0;
+
+                        active = false;
+
+                        rampDirection = "hold";
+
+                        reason = "hold_period";
+
+                        controllerState = "hold_period";
+
+                    }
+
+                }
+
+
+                siteLimit = clamp(siteLimit, -node.nominalReactivePowerVar, node.nominalReactivePowerVar);
+
+
+                const effectiveSiteLimit = Number.isFinite(lastLimit) ? Number(lastLimit) : 0;
+
+                const shouldEmitMain = controlDue && shouldEmitCommand(siteLimit, reason, nowMs);
+
+
+                if (!shouldEmitMain && reason === "hold_period") {
+
+                    controllerState = "waiting_command_window";
+
+                }
+
+
+                buildStatus({
+
+                    mode: node.mode,
+
+                    siteLimit: shouldEmitMain ? siteLimit : effectiveSiteLimit,
+
+                    reactiveReference: filteredReference !== null ? filteredReference : reactiveReference,
+
+                    reactiveTargetVar: reactiveTargetVar,
+
+                    active: active,
+
+                    reason: reason,
+
+                    rampDirection: rampDirection,
+
+                    controllerState: controllerState
+
+                });
+
+
+                const measurementAgeMs = Number.isFinite(lastMsgTimestampMs) ? Math.max(0, nowMs - lastMsgTimestampMs) : null;
+
+
+                const mainMsg = {
+
+                    topic: node.outputTopic,
+
+                    payload: buildOutputPayload({
+
+                        siteLimit: siteLimit,
+
+                        rawReactiveReference: rawReactiveReference,
+
+                        filteredReference: filteredReference,
+
+                        reactiveTargetVar: reactiveTargetVar,
+
+                        correction: correction,
+
+                        error: error,
+
+                        pTerm: pTerm,
+
+                        effectiveKp: effectiveKp,
+
+                        effectiveKi: effectiveKi,
+
+                        gainsScale: gainsScale,
+
+                        iTerm: iTerm,
+
+                        active: active,
+
+                        reason: reason,
+
+                        controllerState: controllerState,
+
+                        stale: stale,
+
+                        rampDirection: rampDirection,
+
+                        clampedByMin: clampedByMin,
+
+                        clampedByMax: clampedByMax,
+
+                        noiseMetricVar: noiseMetricVar,
+
+                        noiseStable: noiseStable,
+
+                        noiseStableDurationMs: noiseStableDurationMs,
+
+                        settleRemainingMs: settleRemainingMs,
+
+                        measurementAgeMs: measurementAgeMs,
+
+                        msgTimestampMs: msgTimestampMs
+
+                    }),
+
+                    controller: {
+
+                        type: "control-reactive",
+
+                        mode: node.mode,
+
+                        zero_feed_in_mode: node.zeroFeedInMode,
+
+                        reason: reason,
+
+                        q_avg_var: Number.isFinite(filteredReference) ? Math.round(filteredReference) : null,
+
+                        grid_target_var: Number.isFinite(reactiveTargetVar) ? Math.round(reactiveTargetVar) : null,
+
+                        error_var: Number.isFinite(error) ? Math.round(error) : null,
+
+                        kp: node.kp,
+
+                        ki: node.ki,
+
+                        deadband_var: node.deadbandVar,
+
+                        filter_tau_ms: node.filterTauMs,
+
+                        control_period_ms: node.controlPeriodMs,
+
+                        max_step_up_var: node.maxStepUpVar,
+
+                        max_step_down_var: node.maxStepDownVar,
+
+                        noise_metric_var: Math.round(noiseMetricVar),
+
+                        noise_threshold_var: node.noiseThresholdVar,
+
+                        noise_release_ms: node.noiseReleaseMs,
+
+                        noise_stable: noiseStable,
+
+                        noise_stable_duration_ms: noiseStableDurationMs,
+
+                        settle_after_command_ms: node.minCommandIntervalMs,
+
+                        settle_remaining_ms: settleRemainingMs,
+
+                        nominal_reactive_power_var: node.nominalReactivePowerVar,
+
+                        fixed_reactive_power_var: node.fixedReactivePowerVar,
+
+                        timestamp_ms: msgTimestampMs
+
+                    }
+
+                };
+
+
+                const failSecureState = evaluateFailSecure({
+
+                    stale: stale,
+
+                    error: error,
+
+                    siteLimit: shouldEmitMain ? siteLimit : effectiveSiteLimit
+
+                }, nowMs);
+
+
+                const failSecureStateChanged = failSecureState.active !== lastFailSecureOutputActive;
+
+                let failMsg = null;
+
+
+                if (node.failSecureEnabled && failSecureState.active) {
+
+                    failMsg = {
+
+                        topic: "control-reactive/fail-secure",
+
+                        payload: 1,
+
+                        fail_secure: {
+
+                            active: true,
+
+                            duration_ms: failSecureState.durationMs,
+
+                            nominal_reactive_power_var: failSecureState.nominalReactivePowerVar,
+
+                            site_limit_var: failSecureState.siteLimitVar,
+
+                            timeout_s: node.failSecureTimeSec,
+
+                            timestamp_ms: nowMs
+
+                        }
+
+                    };
+
+                }
+
+
+                lastFailSecureOutputActive = failSecureState.active;
+
+
+                if (shouldEmitMain) {
+
+                    markCommandEmitted(siteLimit, nowMs);
+
+                }
+
+
+                if (node.failSecureEnabled) {
+
+                    if (shouldEmitMain) {
+
+                        send([mainMsg, failMsg]);
+
+                    } else if (failSecureStateChanged && failMsg) {
+
+                        send([null, failMsg]);
+
+                    }
+
+                } else if (shouldEmitMain) {
+
+                    send(mainMsg);
+
+                }
+
+
+                done();
+
+            } catch (err) {
+
+                node.status({ fill: "red", shape: "ring", text: err.message || "error" });
+
+                done(err);
+
+            }
+
+        });
+
+
+
+        if (node.staleTimeoutMs > 0 && node.mode !== "nominal_reactive_power") {
+            watchdogTimer = setInterval(function () {
+                const nowMs = Date.now();
+                if (!enabled || watchdogSafeEmitted || !Number.isFinite(lastInputAtMs) || (nowMs - lastInputAtMs) <= node.staleTimeoutMs) {
+                    return;
+                }
+
+                if (!validateRequiredGlobalValues()) return;
+
+                watchdogSafeEmitted = true;
+                integratorState = 0;
+                refreshNominalReactivePowerFromGlobal();
+                lastLimit = 0;
+                emitStopZero(function (message) {
+                    node.send(message);
+                }, nowMs);
+            }, Math.max(250, Math.min(node.staleTimeoutMs, 1000)));
+        }
+
+        if (node.a3TestsEnabled) {
+            a3Server = createA3TestServer({
+                host: node.a3ModbusHost,
+                port: node.a3ModbusPort,
+                unitId: node.a3ModbusUnitId,
+                nominalPower: node.fixedReactivePowerVar,
+                minNominal: -node.nominalReactivePowerVar,
+                maxNominal: node.nominalReactivePowerVar,
+                rampType: node.a3RampType,
+                rampValue: node.a3RampValue,
+                onCommand: function () {
+                    emitA3NominalCommand(Date.now(), "a3_modbus_command");
+                },
+                onError: function (err) {
+                    node.warn("control-reactive A3 Modbus: " + err.message);
+                },
+                onProtocolIssue: function (issue) {
+                    if (node.debugLevel !== "off") {
+                        node.warn("control-reactive A3 Modbus issue: " + issue.code);
+                    }
+                }
+            });
+
+            a3Server.start().then(function () {
+                node.status({
+                    fill: "blue",
+                    shape: "dot",
+                    text: "A3 Modbus " + node.a3ModbusHost + ":" + node.a3ModbusPort
+                });
+                emitA3NominalCommand(Date.now(), "a3_start");
+            }).catch(function (err) {
+                node.status({ fill: "red", shape: "ring", text: "A3 Modbus: " + err.message });
+                node.error("control-reactive A3 Modbus: " + err.message);
+            });
+        }
+
+        node.on("close", function(done) {
+            if (watchdogTimer) {
+                clearInterval(watchdogTimer);
+                watchdogTimer = null;
+            }
+
+            persistLastLimit(lastLimit);
+
+            if (a3Server) {
+                const server = a3Server;
+                a3Server = null;
+                server.stop().finally(function () {
+                    if (typeof done === "function") done();
+                });
+                return;
+            }
+
+            if (typeof done === "function") done();
+
+        });
+
+    
+        });
+    }
+
+
+
+    RED.nodes.registerType("control-reactive", ReactiveControlNode);
+
+    RED.nodes.registerType("reactive-control", ReactiveControlNode);
+
+};