@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/fronius-write/fronius-write.html

@@ -0,0 +1,1789 @@
+<script type="text/javascript">
+
+    const FRONIUS_WRITE_MAX_NOMINAL_POWER_W = 125000;
+
+    function froniusWriteIsBlank(value) {
+        return value === undefined || value === null || String(value).trim() === "";
+    }
+
+    function froniusWriteOptionalNumber(value, min, max) {
+        if (froniusWriteIsBlank(value)) {
+            return true;
+        }
+
+        const n = Number(value);
+
+        if (!Number.isFinite(n) || n < min) {
+            return false;
+        }
+
+        return max === undefined || n <= max;
+    }
+
+    RED.nodes.registerType("fronius-write", {
+
+
+        category: "Atelierul de Tehnologii",
+
+
+        color: "#e67700",
+
+
+        defaults: {
+            license: { value: "", type: "atelier-license", required: true },
+
+
+            name: { value: "" },
+
+
+            host: { value: "", required: true },
+
+
+            port: { value: 502, required: true, validate: RED.validators.number() },
+
+
+            unitId: { value: 1, required: true, validate: RED.validators.number() },
+
+
+            powerType: { value: "active" },
+
+
+            mode: { value: "watts" },
+
+
+            maxPower: {
+                value: 25000,
+                validate: function (v) {
+                    if (froniusWriteIsBlank(v)) {
+                        return true;
+                    }
+
+                    const n = Number(v);
+                    return Number.isFinite(n) && n > 0 && n <= FRONIUS_WRITE_MAX_NOMINAL_POWER_W;
+                }
+            },
+
+            latencyTargetMs: {
+                value: 200,
+                validate: function (v) {
+                    return froniusWriteOptionalNumber(v, 1);
+                }
+            },
+
+            maxCommandAgeMs: {
+                value: 1000,
+                validate: function (v) {
+                    return froniusWriteOptionalNumber(v, 50);
+                }
+            },
+
+            disableReadbackVerification: { value: false },
+
+            nominalPower: {
+
+                value: 25000,
+
+                validate: function (v) {
+
+                    if (froniusWriteIsBlank(v)) {
+
+                        return true;
+
+                    }
+
+                    const nominal = Number(v);
+
+                    const maxPower = Number($("#node-input-maxPower").val());
+
+
+                    if (!Number.isFinite(nominal) || nominal <= 0) {
+
+                        return false;
+
+                    }
+
+                    if (nominal > FRONIUS_WRITE_MAX_NOMINAL_POWER_W) {
+
+                        return false;
+
+                    }
+
+
+                    return true;
+
+                }
+
+            },
+
+
+            nominalReactivePower: {
+                value: 25000,
+                validate: function (v) {
+                    if (froniusWriteIsBlank(v)) {
+                        return true;
+                    }
+
+                    const n = Number(v);
+                    return Number.isFinite(n) && n > 0 && n <= FRONIUS_WRITE_MAX_NOMINAL_POWER_W;
+                }
+            },
+
+
+            rampType: { value: "none" },
+
+
+            rampTime: {
+                value: 0,
+                validate: function (v) {
+                    return froniusWriteOptionalNumber(v, 0);
+                }
+            },
+
+
+            rampGradientPct: {
+                value: 10,
+                validate: function (v) {
+                    return froniusWriteOptionalNumber(v, 0);
+                }
+            },
+
+
+            rampGradientWatts: {
+                value: 2500,
+                validate: function (v) {
+                    return froniusWriteOptionalNumber(v, 0);
+                }
+            },
+
+
+            rampGradientVars: {
+                value: 2500,
+                validate: function (v) {
+                    return froniusWriteOptionalNumber(v, 0);
+                }
+            },
+
+
+            rampUpValue: {
+                value: 0,
+                validate: function (v) {
+                    return froniusWriteOptionalNumber(v, 0);
+                }
+            },
+
+
+            rampDownValue: {
+                value: 0,
+                validate: function (v) {
+                    return froniusWriteOptionalNumber(v, 0);
+                }
+            },
+
+
+            multiInverter: { value: false },
+
+
+            inverterId: {
+
+                value: "",
+
+                validate: function (v) {
+
+                    const isMulti = $("#node-input-multiInverter").is(":checked");
+
+                    return !isMulti || !!String(v || "").trim();
+
+                }
+
+            }
+
+
+        },
+
+
+        inputs: 1,
+
+
+        outputs: 1,
+
+
+        icon: "font-awesome/fa-sliders",
+
+
+        label: function () {
+
+            const baseLabel = this.name || this.host || "fronius-write";
+
+            if (this.multiInverter && this.inverterId) {
+
+                const suffix = " [" + this.inverterId + "]";
+
+                if (baseLabel.indexOf(suffix) !== -1) {
+
+                    return baseLabel;
+
+                }
+
+                return baseLabel + " [" + this.inverterId + "]";
+
+            }
+
+            return baseLabel;
+
+
+        },
+
+
+        oneditprepare: function () {
+
+
+            const node = this;
+
+
+
+            function normalizePowerType(value) {
+
+
+                return value === "reactive" ? "reactive" : "active";
+
+
+            }
+
+
+
+            function normalizeMode(powerType, mode) {
+
+
+                if (powerType === "reactive") {
+
+
+                    if (mode === "vars" || mode === "percent") return mode;
+
+
+                    return "vars";
+
+
+                }
+
+
+
+                if (mode === "watts" || mode === "percent") return mode;
+
+
+                return "watts";
+
+
+            }
+
+
+            function normalizeInverterId(value) {
+
+                return String(value || "").trim();
+
+            }
+
+
+            function ensureNumberInput(selector, fallback) {
+
+                const value = String($(selector).val() || "").trim();
+
+                if (!Number.isFinite(Number(value))) {
+
+                    $(selector).val(fallback);
+
+                }
+
+            }
+
+
+            function buildAutoName() {
+
+                const host = ($("#node-input-host").val() || "").trim();
+
+                const isMulti = $("#node-input-multiInverter").is(":checked");
+
+                const inverterId = normalizeInverterId($("#node-input-inverterId").val());
+
+
+                if (!isMulti || !inverterId) {
+
+                    return host;
+
+                }
+
+
+                return host ? (host + " [" + inverterId + "]") : inverterId;
+
+            }
+
+            const savedAutoName = node.host && node.inverterId
+                ? node.host + " [" + node.inverterId + "]"
+                : "";
+            let autoNameEnabled = !node.name || node.name === node.host || node.name === savedAutoName || node.name === "fronius-write";
+
+
+            function toggleMultiInverterFields() {
+
+                const enabled = $("#node-input-multiInverter").is(":checked");
+
+                $("#row-inverter-id").toggle(enabled);
+
+            }
+
+
+            function applyRuntimeDefaults(state) {
+
+                if (!state || state.status !== "ok") return;
+
+
+                const runtimePowerType = normalizePowerType(state.power_type);
+
+                const runtimeMode = normalizeMode(runtimePowerType, state.mode);
+
+
+                $("#node-input-powerType").val(runtimePowerType);
+
+                rebuildModeOptions(runtimeMode);
+
+                toggleFields();
+
+            }
+
+
+            function loadRuntimeState() {
+
+                if (!node.id) return;
+
+
+                $.getJSON("fronius-write/state/" + encodeURIComponent(node.id))
+
+                    .done(function (res) {
+
+                        if (res && res.ok && res.state) {
+
+                            applyRuntimeDefaults(res.state);
+
+                        }
+
+                    });
+
+            }
+
+
+
+            function rebuildModeOptions(preferredMode) {
+
+
+                const powerType = normalizePowerType($("#node-input-powerType").val());
+
+
+                const $mode = $("#node-input-mode");
+
+
+                const modeToApply = normalizeMode(powerType, preferredMode || $mode.val());
+
+
+
+                $mode.empty();
+
+
+
+                if (powerType === "reactive") {
+
+
+                    $mode.append('<option value="vars">Fixed Reactive Power (VAr)</option>');
+
+
+                    $mode.append('<option value="percent">Percent (%)</option>');
+
+
+                } else {
+
+
+                    $mode.append('<option value="watts">Fixed Power (W)</option>');
+
+
+                    $mode.append('<option value="percent">Percent (%)</option>');
+
+
+                }
+
+
+
+                $mode.val(modeToApply);
+
+
+            }
+
+
+
+            function toggleFields() {
+
+
+                const powerType = normalizePowerType($("#node-input-powerType").val());
+
+
+                const rampType = $("#node-input-rampType").val();
+
+
+
+                const showNominalForRamp = rampType === "gradient_pct" || rampType === "gradient_w";
+
+
+
+                const showMaxPower = powerType === "active";
+
+
+
+                const showNominalPower =
+
+
+                    powerType === "active" && showNominalForRamp;
+
+
+
+                const showNominalReactivePower =
+
+
+                    powerType === "reactive" && showNominalForRamp;
+
+
+
+                $("#row-nominal-power").toggle(showMaxPower);
+
+
+                $("#row-ramp-nominal-power").toggle(showNominalPower);
+
+
+                $("#row-nominal-reactive-power").toggle(showNominalReactivePower);
+
+
+
+                $("#row-ramp-up-value").hide();
+
+
+                $("#row-ramp-down-value").hide();
+
+
+
+                if (rampType !== "none") {
+
+
+                    let rampLabel = "Ramp Value";
+
+
+                    if (rampType === "time") {
+
+
+                        rampLabel = "Ramp Time (s)";
+
+
+                    } else if (rampType === "gradient_pct") {
+
+
+                        rampLabel = "Ramp Gradient (%/s)";
+
+
+                    } else if (rampType === "gradient_w") {
+
+
+                        rampLabel = powerType === "reactive" ? "Ramp Gradient (VAr/s)" : "Ramp Gradient (W/s)";
+
+
+                    }
+
+
+                    $("#node-label-rampUpValue").text(rampLabel.replace("Ramp ", "Ramp Up "));
+
+
+                    $("#node-label-rampDownValue").text(rampLabel.replace("Ramp ", "Ramp Down "));
+
+
+                    $("#row-ramp-up-value").show();
+
+
+                    $("#row-ramp-down-value").show();
+
+
+                }
+
+
+                refreshValidationMessage();
+
+
+            }
+
+
+            function refreshValidationMessage() {
+
+                const maxPower = Number($("#node-input-maxPower").val());
+
+                const nominalPower = Number($("#node-input-nominalPower").val());
+
+                const showNominalPower = $("#row-ramp-nominal-power").is(":visible");
+
+                const invalidNominal = showNominalPower &&
+
+                    Number.isFinite(maxPower) &&
+
+                    maxPower > 0 &&
+
+                    Number.isFinite(nominalPower) &&
+
+                    nominalPower > 0 &&
+
+                    nominalPower < maxPower;
+
+                const invalidPowerLimit = showNominalPower &&
+
+                    Number.isFinite(nominalPower) &&
+
+                    nominalPower > FRONIUS_WRITE_MAX_NOMINAL_POWER_W;
+
+
+                $("#node-fronius-write-validation")
+
+                    .toggle(invalidNominal || invalidPowerLimit)
+
+                    .html(invalidPowerLimit
+
+                        ? '<div class="fw-validation-block"><i class="fa fa-warning"></i> Nominal Power (W) trebuie sa fie cel mult 125000 W.</div>'
+
+                        : invalidNominal
+
+                        ? '<div class="fw-validation-block"><i class="fa fa-warning"></i> Nominal Power (W) trebuie sa fie mai mare sau egal cu Max Power (W).</div>'
+
+                        : "");
+
+            }
+
+
+
+            const savedPowerType = normalizePowerType(node.powerType || "active");
+
+
+            const savedMode = normalizeMode(savedPowerType, node.mode || "watts");
+
+
+            const savedRampType = node.rampType || "none";
+
+
+
+            $("#node-input-powerType").val(savedPowerType);
+
+
+            $("#node-input-rampType").val(savedRampType);
+
+
+            ensureNumberInput("#node-input-port", 502);
+
+            ensureNumberInput("#node-input-unitId", 1);
+
+            ensureNumberInput("#node-input-maxPower", node.maxPower || node.nominalPower || 25000);
+
+            ensureNumberInput("#node-input-nominalPower", node.nominalPower || node.maxPower || 25000);
+
+            ensureNumberInput("#node-input-nominalReactivePower", node.nominalReactivePower || node.nominalPower || 25000);
+
+            ensureNumberInput("#node-input-rampTime", 0);
+
+            ensureNumberInput("#node-input-rampGradientPct", 10);
+
+            ensureNumberInput("#node-input-rampGradientWatts", 2500);
+
+            ensureNumberInput("#node-input-rampGradientVars", 2500);
+
+            ensureNumberInput("#node-input-rampUpValue", 0);
+
+            ensureNumberInput("#node-input-rampDownValue", 0);
+
+
+
+            rebuildModeOptions(savedMode);
+
+
+            toggleFields();
+
+
+            if (!$("#node-input-name").val().trim()) {
+
+                const autoName = buildAutoName();
+
+                if (autoName) {
+
+                    $("#node-input-name").val(autoName);
+
+                }
+
+            }
+
+
+            $("#node-input-host")
+
+                .off(".froniusWriteNameSync")
+
+                .on("input.froniusWriteNameSync change.froniusWriteNameSync", function () {
+
+                    autoNameEnabled = true;
+                    $("#node-input-name").val(buildAutoName());
+
+                });
+
+
+            $("#node-input-inverterId")
+
+                .off(".froniusWriteNameSync")
+
+                .on("input.froniusWriteNameSync change.froniusWriteNameSync", function () {
+
+                    if (autoNameEnabled) {
+                        $("#node-input-name").val(buildAutoName());
+                    }
+
+                });
+
+            $("#node-input-name")
+                .off(".froniusWriteNameSync")
+                .on("input.froniusWriteNameSync", function () {
+                    const value = String($(this).val() || "").trim();
+                    autoNameEnabled = !value || value === buildAutoName();
+                });
+
+
+            $("#node-input-multiInverter")
+
+                .off(".froniusWriteMulti")
+
+                .on("change.froniusWriteMulti", function () {
+
+                    toggleMultiInverterFields();
+
+                    if (autoNameEnabled) {
+                        $("#node-input-name").val(buildAutoName());
+                    }
+
+                    $("#node-input-inverterId").trigger("change");
+
+                });
+
+
+
+            $("#node-input-powerType").off(".froniusWrite").on("change.froniusWrite", function () {
+
+
+                const powerType = normalizePowerType($(this).val());
+
+
+
+                if (powerType === "reactive") {
+
+
+                    rebuildModeOptions("vars");
+
+
+                } else {
+
+
+                    rebuildModeOptions("watts");
+
+
+                }
+
+
+
+                toggleFields();
+
+
+            });
+
+
+
+            $("#node-input-mode").off(".froniusWrite").on("change.froniusWrite", function () {
+
+
+                toggleFields();
+
+
+            });
+
+
+
+            $("#node-input-rampType").off(".froniusWrite").on("change.froniusWrite", function () {
+
+
+                toggleFields();
+
+
+            });
+
+
+            $("#node-input-maxPower").off(".froniusWrite").on("input.froniusWrite change.froniusWrite", function () {
+
+                $("#node-input-nominalPower").trigger("change");
+
+                refreshValidationMessage();
+
+            });
+
+
+            $("#node-input-nominalPower").off(".froniusWrite").on("input.froniusWrite change.froniusWrite", function () {
+
+                refreshValidationMessage();
+
+            });
+
+
+            toggleMultiInverterFields();
+
+            loadRuntimeState();
+
+
+        },
+
+
+        oneditsave: function () {
+
+
+            const powerType = $("#node-input-powerType").val() === "reactive" ? "reactive" : "active";
+
+
+            let mode = $("#node-input-mode").val();
+
+
+
+            if (powerType === "reactive") {
+
+
+                if (mode !== "vars" && mode !== "percent") {
+
+
+                    mode = "vars";
+
+
+                }
+
+
+            } else {
+
+
+                if (mode !== "watts" && mode !== "percent") {
+
+
+                    mode = "watts";
+
+
+                }
+
+
+            }
+
+
+
+            this.powerType = powerType;
+
+
+            this.mode = mode;
+
+
+            this.rampType = $("#node-input-rampType").val() || "none";
+
+
+
+            const maxPowerInput = String($("#node-input-maxPower").val() || "").trim();
+
+            const nominalPowerInput = String($("#node-input-nominalPower").val() || "").trim();
+
+            const nominalReactivePowerInput = String($("#node-input-nominalReactivePower").val() || "").trim();
+
+
+            const previousMaxPower = Number(this.maxPower);
+
+            const previousNominalPower = Number(this.nominalPower);
+
+            const previousNominalReactivePower = Number(this.nominalReactivePower);
+
+
+            function clampConfiguredPower(value, fallback) {
+
+                const n = Number(value);
+
+                const safeFallback = Number.isFinite(Number(fallback)) && Number(fallback) > 0 ? Number(fallback) : 25000;
+
+                if (!Number.isFinite(n) || n <= 0) {
+
+                    return Math.min(safeFallback, FRONIUS_WRITE_MAX_NOMINAL_POWER_W);
+
+                }
+
+                return Math.min(n, FRONIUS_WRITE_MAX_NOMINAL_POWER_W);
+
+            }
+
+
+            this.maxPower = maxPowerInput
+
+                ? clampConfiguredPower(maxPowerInput, 25000)
+
+                : clampConfiguredPower(
+                    Number.isFinite(previousMaxPower) && previousMaxPower > 0
+                        ? previousMaxPower
+                        : (Number.isFinite(previousNominalPower) && previousNominalPower > 0 ? previousNominalPower : 25000),
+                    25000
+                );
+
+
+            this.nominalPower = nominalPowerInput
+
+                ? clampConfiguredPower(nominalPowerInput, this.maxPower)
+
+                : clampConfiguredPower(
+                    Number.isFinite(previousNominalPower) && previousNominalPower > 0 ? previousNominalPower : 25000,
+                    this.maxPower
+                );
+
+
+            if (Number.isFinite(this.maxPower) && this.maxPower > 0 && this.nominalPower < this.maxPower) {
+
+                this.nominalPower = this.maxPower;
+
+            }
+
+
+            this.nominalReactivePower = nominalReactivePowerInput
+
+                ? clampConfiguredPower(nominalReactivePowerInput, this.nominalPower)
+
+                : clampConfiguredPower(
+                    Number.isFinite(previousNominalReactivePower) && previousNominalReactivePower > 0 ? previousNominalReactivePower : this.nominalPower,
+                    this.nominalPower
+                );
+
+
+
+            this.rampTime = Number($("#node-input-rampTime").val() || 0);
+
+
+            this.rampGradientPct = Number($("#node-input-rampGradientPct").val() || 0);
+
+
+            this.rampGradientWatts = Number($("#node-input-rampGradientWatts").val() || 0);
+
+
+            this.rampGradientVars = Number($("#node-input-rampGradientVars").val() || 0);
+
+            this.rampUpValue = Number($("#node-input-rampUpValue").val() || 0);
+
+            this.rampDownValue = Number($("#node-input-rampDownValue").val() || 0);
+
+            this.latencyTargetMs = Number(this.latencyTargetMs || 200);
+
+            this.maxCommandAgeMs = Number(this.maxCommandAgeMs || 1000);
+
+            this.disableReadbackVerification = $("#node-input-disableReadbackVerification").is(":checked");
+
+            this.multiInverter = $("#node-input-multiInverter").is(":checked");
+
+            this.inverterId = String($("#node-input-inverterId").val() || "").trim();
+
+
+
+            if (!$("#node-input-name").val().trim()) {
+
+                const host = ($("#node-input-host").val() || "").trim();
+
+                if (this.multiInverter && this.inverterId) {
+
+                    $("#node-input-name").val(host ? (host + " [" + this.inverterId + "]") : this.inverterId);
+
+                } else {
+
+                    $("#node-input-name").val(host);
+
+                }
+
+            }
+
+
+            $("#node-input-host").off(".froniusWriteNameSync");
+
+            $("#node-input-inverterId").off(".froniusWriteNameSync");
+            $("#node-input-name").off(".froniusWriteNameSync");
+
+            $("#node-input-powerType").off(".froniusWrite");
+
+            $("#node-input-mode").off(".froniusWrite");
+
+            $("#node-input-rampType").off(".froniusWrite");
+
+            $("#node-input-multiInverter").off(".froniusWriteMulti");
+
+            $("#node-input-maxPower").off(".froniusWrite");
+
+            $("#node-input-nominalPower").off(".froniusWrite");
+
+
+        },
+
+
+        oneditcancel: function () {
+
+
+            $("#node-input-host").off(".froniusWriteNameSync");
+
+            $("#node-input-inverterId").off(".froniusWriteNameSync");
+            $("#node-input-name").off(".froniusWriteNameSync");
+
+            $("#node-input-powerType").off(".froniusWrite");
+
+            $("#node-input-mode").off(".froniusWrite");
+
+            $("#node-input-rampType").off(".froniusWrite");
+
+            $("#node-input-multiInverter").off(".froniusWriteMulti");
+
+            $("#node-input-maxPower").off(".froniusWrite");
+
+            $("#node-input-nominalPower").off(".froniusWrite");
+
+
+        }
+
+
+    });
+
+
+</script>
+
+
+
+<script type="text/html" data-template-name="fronius-write">
+    <div class="form-row"><label for="node-input-license"><i class="fa fa-key"></i> License</label><input type="text" id="node-input-license"></div>
+
+    <div class="fronius-write-editor">
+
+        <div class="pr-section">
+
+            <div class="pr-section-title"><i class="fa fa-plug"></i> Connection</div>
+
+            <p class="pr-section-note">Configuratia de scriere SunSpec (Modbus TCP) pentru invertor Fronius.</p>
+
+
+            <div class="pr-grid pr-grid-2">
+
+                <div class="form-row">
+
+                    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+
+                    <input type="text" id="node-input-name" placeholder="192.168.0.101">
+
+                </div>
+
+
+                <div class="form-row">
+
+                    <label for="node-input-host"><i class="fa fa-globe"></i> IP</label>
+
+                    <input type="text" id="node-input-host" placeholder="192.168.0.xxx">
+
+                </div>
+
+
+                <div class="form-row">
+
+                    <label for="node-input-port"><i class="fa fa-plug"></i> Port</label>
+
+                    <input type="text" id="node-input-port" placeholder="502">
+
+                </div>
+
+
+                <div class="form-row">
+
+                    <label for="node-input-unitId"><i class="fa fa-hashtag"></i> Unit ID</label>
+
+                    <input type="text" id="node-input-unitId" placeholder="1">
+
+                </div>
+
+
+                <div class="form-row pr-checkbox-row">
+
+                    <label for="node-input-multiInverter"><i class="fa fa-sitemap"></i> Multi-inverter</label>
+
+                    <input type="checkbox" id="node-input-multiInverter">
+
+                </div>
+
+
+                <div class="form-row" id="row-inverter-id" style="display:none;">
+
+                    <label for="node-input-inverterId"><i class="fa fa-id-badge"></i> Inverter ID</label>
+
+                    <input type="text" id="node-input-inverterId" placeholder="inv1">
+
+                </div>
+
+
+            </div>
+
+        </div>
+
+
+        <div class="pr-section">
+
+            <div class="pr-section-title"><i class="fa fa-bolt"></i> Power Control</div>
+
+            <p class="pr-section-note">Alege tipul limitei si modul de lucru. Campurile necesare apar automat in functie de selectie.</p>
+
+
+            <div class="pr-grid pr-grid-2">
+
+                <div class="form-row">
+
+                    <label for="node-input-powerType"><i class="fa fa-exchange"></i> Power type</label>
+
+                    <select id="node-input-powerType">
+
+                        <option value="active">Active Power</option>
+
+                        <option value="reactive">Reactive Power</option>
+
+                    </select>
+
+                </div>
+
+
+                <div class="form-row">
+
+                    <label for="node-input-mode"><i class="fa fa-cogs"></i> Mode</label>
+
+                    <select id="node-input-mode"></select>
+
+                </div>
+
+
+                <div class="form-row" id="row-nominal-power">
+
+                    <label for="node-input-maxPower"><i class="fa fa-line-chart"></i> Max Power (W)</label>
+
+                    <input type="text" id="node-input-maxPower" placeholder="125000">
+
+                </div>
+
+
+                <div class="form-row pr-checkbox-row pr-span-2">
+
+                    <label for="node-input-disableReadbackVerification"><i class="fa fa-check-square-o"></i> Disable read-back verification</label>
+
+                    <input type="checkbox" id="node-input-disableReadbackVerification">
+
+                    <span class="pr-inline-note">Foloseste cand alt controller, de exemplu Victron, rescrie aceleasi registre SunSpec.</span>
+
+                </div>
+
+            </div>
+
+        </div>
+
+
+        <div class="pr-section">
+
+            <div class="pr-section-title"><i class="fa fa-tachometer"></i> Ramp</div>
+
+            <p class="pr-section-note">Defineste dinamica aplicarii comenzii: timp fix, gradient procentual sau gradient in unitati absolute.</p>
+
+
+            <div class="pr-grid pr-grid-2">
+
+                <div class="form-row pr-span-2">
+
+                    <label for="node-input-rampType"><i class="fa fa-sliders"></i> Ramp Type</label>
+
+                    <select id="node-input-rampType">
+
+                        <option value="none">No ramp</option>
+
+                        <option value="time">Ramp Time (s)</option>
+
+                        <option value="gradient_pct">Gradient (%/s)</option>
+
+                        <option value="gradient_w">Gradient (W/s / VAr/s)</option>
+
+                    </select>
+
+                </div>
+
+
+                <div class="form-row" id="row-ramp-nominal-power">
+
+                    <label for="node-input-nominalPower"><i class="fa fa-line-chart"></i> Nominal Power (W)</label>
+
+                    <input type="text" id="node-input-nominalPower" placeholder="125000">
+
+                </div>
+
+
+                <div class="form-row" id="row-nominal-reactive-power">
+
+                    <label for="node-input-nominalReactivePower"><i class="fa fa-area-chart"></i> Nominal Reactive Power (VAr)</label>
+
+                    <input type="text" id="node-input-nominalReactivePower" placeholder="125000">
+
+                </div>
+
+
+                <input type="hidden" id="node-input-rampTime">
+
+                <input type="hidden" id="node-input-rampGradientPct">
+
+                <input type="hidden" id="node-input-rampGradientWatts">
+
+                <input type="hidden" id="node-input-rampGradientVars">
+
+
+                <div class="form-row" id="row-ramp-up-value">
+
+                    <label for="node-input-rampUpValue"><i class="fa fa-level-up"></i> <span id="node-label-rampUpValue">Ramp Up Value</span></label>
+
+                    <input type="text" id="node-input-rampUpValue" placeholder="0 = no ramp on up">
+
+                </div>
+
+
+                <div class="form-row" id="row-ramp-down-value">
+
+                    <label for="node-input-rampDownValue"><i class="fa fa-level-down"></i> <span id="node-label-rampDownValue">Ramp Down Value</span></label>
+
+                    <input type="text" id="node-input-rampDownValue" placeholder="0 = no ramp on down">
+
+                </div>
+
+
+                <div class="form-row pr-span-2" id="node-fronius-write-validation" style="display:none;"></div>
+
+            </div>
+
+        </div>
+
+    </div>
+
+</script>
+
+
+
+<script type="text/html" data-help-name="fronius-write">
+
+
+    <p>
+
+        Nodul <b>fronius-write</b> trimite comenzi de limitare catre un invertor Fronius prin <b>SunSpec (Modbus TCP)</b>.
+
+        Nodul cauta automat modelul SunSpec de control al invertorului si scrie registrii necesari pentru putere activa sau reactiva.
+
+    </p>
+
+
+    <h3>Cerinte</h3>
+
+    <ul>
+
+        <li>Invertorul trebuie sa fie accesibil in retea prin IP.</li>
+
+        <li>Modbus TCP / SunSpec trebuie sa fie activ pe invertor.</li>
+
+        <li>Invertorul trebuie sa expuna un model SunSpec de control: <code>120</code>, <code>121</code>, <code>122</code> sau <code>123</code>.</li>
+
+        <li>Portul uzual pentru Modbus TCP este <code>502</code>.</li>
+
+    </ul>
+
+
+    <h3>Conexiune</h3>
+
+    <ul>
+
+        <li><b>Name</b> - numele afisat in flow. Daca este gol, nodul foloseste IP-ul. In modul Multi-inverter adauga si <b>Inverter ID</b>.</li>
+
+        <li><b>IP</b> - adresa invertorului Fronius, de exemplu <code>192.168.0.101</code>.</li>
+
+        <li><b>Port</b> - portul Modbus TCP; de obicei <code>502</code>.</li>
+
+        <li><b>Unit ID</b> - adresa Modbus a invertorului; in multe instalatii este <code>1</code>.</li>
+
+    </ul>
+
+
+    <h3>Power type</h3>
+
+    <ul>
+
+        <li><b>Active Power</b> - controleaza puterea activa a invertorului. Comanda poate fi in <b>W</b> sau in <b>%</b>.</li>
+
+        <li><b>Reactive Power</b> - controleaza puterea reactiva. Comanda poate fi in <b>VAr</b> sau in <b>%</b>.</li>
+
+        <li>Cand se aplica o comanda activa, nodul dezactiveaza controlul reactiv scris anterior.</li>
+
+        <li>Cand se aplica o comanda reactiva, nodul dezactiveaza controlul activ scris anterior.</li>
+
+    </ul>
+
+
+    <h3>Mode</h3>
+
+    <ul>
+
+        <li><b>Watts</b> - disponibil pentru <b>Active Power</b>. Valoarea este limitata intre <code>0</code> si <b>Max Power (W)</b>.</li>
+
+        <li><b>Percent</b> - disponibil pentru putere activa si reactiva. Valoarea este limitata intre <code>-100</code> si <code>100</code>.</li>
+
+        <li><b>VAr</b> - disponibil pentru <b>Reactive Power</b>. Valoarea este limitata intre minus si plus <b>Nominal Reactive Power (VAr)</b>.</li>
+
+    </ul>
+
+
+    <h3>Max Power</h3>
+
+    <ul>
+
+        <li><b>Max Power (W)</b> este limita maxima acceptata pentru comenzile active in W.</li>
+
+        <li>Daca intrarea cere o valoare mai mare decat <b>Max Power (W)</b>, nodul respinge comanda si trimite <code>fronius/error</code>.</li>
+
+        <li><b>Nominal Power (W)</b> este folosit pentru conversia comenzilor active din W in procent SunSpec si trebuie sa fie mai mare sau egal cu <b>Max Power (W)</b>.</li>
+
+        <li><b>Nominal Reactive Power (VAr)</b> este folosit pentru conversia comenzilor reactive din VAr in procent SunSpec.</li>
+
+        <li>Valorile trebuie sa corespunda invertorului real. O valoare gresita produce o limita procentuala gresita.</li>
+
+    </ul>
+
+
+    <h3>Ramp</h3>
+
+    <ul>
+
+        <li><b>No ramp</b> - scrie comanda fara timp de rampa.</li>
+
+        <li><b>Ramp Time (s)</b> - aplica limita intr-un numar fix de secunde.</li>
+
+        <li><b>Gradient (%/s)</b> - nodul calculeaza automat timpul de rampa din procentul comandat si gradient.</li>
+
+        <li><b>Gradient (W/s)</b> - pentru putere activa, nodul calculeaza timpul de rampa din W si <b>Nominal Power</b>.</li>
+
+        <li><b>Gradient (VAr/s)</b> - pentru putere reactiva, nodul calculeaza timpul de rampa din VAr si <b>Nominal Reactive Power</b>.</li>
+
+        <li><b>Ramp Up Value</b> suprascrie valoarea de baza cand limita creste fata de ultima comanda aplicata.</li>
+
+        <li><b>Ramp Down Value</b> suprascrie valoarea de baza cand limita scade fata de ultima comanda aplicata.</li>
+
+        <li>O rampa trimisa in <code>msg.payload.ramp</code> suprascrie rampa configurata in editor pentru acel mesaj.</li>
+
+    </ul>
+
+
+    <h3>Input simplu</h3>
+
+    <p>
+
+        Daca <code>msg.payload</code> este numar sau string numeric, valoarea este interpretata folosind <b>Power type</b> si <b>Mode</b> configurate in nod.
+
+    </p>
+
+<pre>
+
+msg.payload = 3500
+
+</pre>
+
+
+    <h3>Input obiect</h3>
+
+    <p>
+
+        Daca <code>msg.payload</code> este obiect, mesajul poate seta direct tipul puterii, modul, valoarea si rampa.
+
+    </p>
+
+    <ul>
+
+        <li><code>payload.value</code> - valoarea comenzii, interpretata cu <code>payload.powerType</code>/<code>payload.power_type</code> si <code>payload.mode</code>.</li>
+
+        <li><code>payload.site_limit_w</code>, <code>payload.limit_w</code> sau <code>payload.watts</code> - comanda activa in W.</li>
+
+        <li><code>payload.limit_pct</code> sau <code>payload.percent</code> - comanda in procent.</li>
+
+        <li><code>payload.limit_var</code>, <code>payload.vars</code> sau <code>payload.var</code> - comanda reactiva in VAr.</li>
+
+        <li><code>payload.limit_var_pct</code> - comanda reactiva in procent.</li>
+
+        <li><code>payload.ramp.type</code> - <code>none</code>, <code>time</code>, <code>gradient_pct</code> sau <code>gradient_w</code>.</li>
+
+        <li><code>payload.ramp.value</code> - valoarea rampei pentru tipul ales.</li>
+
+    </ul>
+
+
+    <h3>Exemple input</h3>
+
+<pre>
+
+msg.payload = {
+
+  limit_w: 5000,
+
+  ramp: { type: "time", value: 10 }
+
+}
+
+</pre>
+
+<pre>
+
+msg.payload = {
+
+  power_type: "reactive",
+
+  mode: "vars",
+
+  value: -1200,
+
+  ramp: { type: "gradient_w", value: 600 }
+
+}
+
+</pre>
+
+<pre>
+
+msg.payload = {
+
+  percent: 40
+
+}
+
+</pre>
+
+
+    <h3>Multi-inverter</h3>
+
+    <p>
+
+        Cand <b>Multi-inverter</b> este activ, nodul nu aplica tot payload-ul primit. El cauta limita pentru propriul <b>Inverter ID</b>
+
+        si rescrie mesajul intern ca si cum ar fi primit doar comanda acelui invertor.
+
+    </p>
+
+    <ul>
+
+        <li><b>Inverter ID</b> devine obligatoriu.</li>
+
+        <li>ID-ul trebuie sa corespunda cu ID-ul generat de nodul <code>multi-inverter</code>.</li>
+
+        <li>Payload-ul acceptat poate fi un array direct sau un obiect cu <code>payload.limits[]</code> ori <code>payload.inverters[]</code>.</li>
+
+        <li>Fiecare element poate avea <code>id</code>, <code>inverter_id</code> sau <code>topic</code>.</li>
+
+        <li>Comanda pentru invertor poate fi in <code>item.payload</code> sau direct in campurile <code>limit_w</code>, <code>limit_var</code>, <code>limit_var_pct</code> si <code>ramp</code>.</li>
+
+    </ul>
+
+<pre>
+
+msg.payload = {
+
+  limits: [
+
+    { id: "inv1", payload: { limit_w: 3200 } },
+
+    { id: "inv2", payload: { limit_w: 2800 } }
+
+  ]
+
+}
+
+</pre>
+
+    <p>
+
+        Un nod <code>fronius-write</code> configurat cu <b>Inverter ID</b> = <code>inv1</code> va aplica doar limita pentru <code>inv1</code>.
+
+    </p>
+
+
+    <h3>Ce scrie in invertor</h3>
+
+    <ul>
+
+        <li>Scrie timpul de rampa in registrul SunSpec corespunzator.</li>
+
+        <li>Scrie valoarea procentuala scalata in registrul de limita activa sau reactiva.</li>
+
+        <li>Activeaza controlul selectat prin registrul <code>enable</code>.</li>
+
+        <li>Incearca sa dezactiveze celalalt tip de control, pentru a evita comenzi active si reactive ramase simultan.</li>
+
+    </ul>
+
+    <h3>Read-back verification</h3>
+
+    <p>
+
+        Implicit, nodul citeste inapoi registrele scrise si raporteaza eroare daca invertorul intoarce alta valoare.
+
+        Bifa <b>Disable read-back verification</b> pastreaza scrierea Modbus, dar sare peste aceasta confirmare.
+
+        Este utila cand invertorul este controlat in paralel de un alt sistem, de exemplu Victron, care poate rescrie rapid limita la <code>100%</code>.
+
+    </p>
+
+
+    <h3>Output</h3>
+
+    <p>
+
+        La succes, nodul emite <code>msg.topic = "fronius/write"</code>. Payload-ul contine ce s-a aplicat efectiv:
+
+    </p>
+
+    <ul>
+
+        <li><code>status</code> - <code>ok</code>.</li>
+
+        <li><code>power_type</code> - <code>active</code> sau <code>reactive</code>.</li>
+
+        <li><code>mode</code> - <code>watts</code>, <code>vars</code> sau <code>percent</code>.</li>
+
+        <li><code>input_value</code> - valoarea primita dupa parsare.</li>
+
+        <li><code>applied_percent</code> - procentul SunSpec calculat si aplicat.</li>
+
+        <li><code>ramp_type</code>, <code>ramp_time_seconds</code> si <code>ramp_input</code> - detalii despre rampa folosita.</li>
+
+        <li><code>control_model_id</code> si adresele aferente - modelul SunSpec folosit pentru scriere.</li>
+
+        <li><code>raw_written</code> si <code>scale_factor</code> - valoarea bruta scrisa in registru si factorul de scala.</li>
+
+        <li><code>readback_verification_disabled</code> - <code>true</code> cand nodul nu a mai citit registrele inapoi pentru confirmare.</li>
+
+    </ul>
+
+
+    <h3>Erori</h3>
+
+    <p>
+
+        Daca apare o problema de conexiune, de detectare SunSpec, de validare a valorii sau de payload multi-inverter,
+
+        nodul seteaza status rosu si emite <code>msg.topic = "fronius/error"</code>.
+
+    </p>
+
+    <p>
+
+        Payload-ul de eroare contine <code>status = "error"</code>, mesajul din <code>error</code> si timestamp-ul <code>ts</code>.
+
+        Pentru erori Modbus temporare, nodul incearca automat retry si reconectare inainte sa raporteze eroarea.
+
+    </p>
+
+    <h3>Referinta completa parametri</h3>
+
+    <ul>
+
+        <li><code>host</code>, <code>port</code>, <code>unitId</code>: conexiunea Modbus TCP catre invertor.</li>
+
+        <li><code>powerType</code>: <code>active</code> pentru W/% sau <code>reactive</code> pentru VAr/%.</li>
+
+        <li><code>mode</code>: <code>watts</code>, <code>percent</code> sau <code>vars</code>.</li>
+
+        <li><code>maxPower</code>: limita maxima acceptata pentru comenzi active in W.</li>
+
+        <li><code>latencyTargetMs</code>: tinta informativa pentru latenta raportata in payload, nu modifica secventa Modbus.</li>
+
+        <li><code>maxCommandAgeMs</code>: respinge comenzi mai vechi decat pragul, pe baza timestamp-ului din mesaj.</li>
+
+        <li><code>disableReadbackVerification</code>: dezactiveaza compararea valorilor citite inapoi dupa scriere.</li>
+
+        <li><code>nominalPower</code>: puterea nominala a invertorului folosita la conversia W in procent SunSpec.</li>
+
+        <li><code>nominalReactivePower</code>: puterea reactiva nominala folosita la conversia VAr in procent SunSpec.</li>
+
+        <li><code>rampType</code>: <code>none</code>, <code>time</code>, <code>gradient_pct</code>, <code>gradient_w</code> sau <code>gradient_var</code>.</li>
+
+        <li><code>rampTime</code>: durata fixa in secunde pentru <code>rampType = time</code>.</li>
+
+        <li><code>rampGradientPct</code>, <code>rampGradientWatts</code>, <code>rampGradientVars</code>: gradientele folosite pentru calculul timpului de rampa.</li>
+
+        <li><code>rampUpValue</code> si <code>rampDownValue</code>: valori directionale pentru crestere/scadere, in aceeasi unitate ca tipul de rampa selectat.</li>
+
+        <li><code>multiInverter</code>: activeaza filtrarea comenzii dupa ID din payload-ul <code>multi-inverter</code>.</li>
+
+        <li><code>inverterId</code>: ID-ul local cautat in mesajele multi-inverter.</li>
+
+    </ul>
+
+    <h3>Model recomandat pentru control-export</h3>
+
+<pre>
+control-export -> fronius-write
+
+msg.payload = {
+  site_limit_w: 10000,
+  grid_reference_w: -500,
+  timestamp_ms: 1776692400000
+}
+</pre>
+
+    <p>Seteaza <code>maxPower</code> ca limita operationala maxima permisa si <code>nominalPower</code> ca puterea reala nominala a invertorului. Aceste doua valori nu trebuie confundate.</p>
+
+
+</script>
+
+
+<style>
+
+    .fronius-write-editor {
+
+        --pr-border: #d7dde5;
+
+        --pr-muted: #667085;
+
+        --pr-surface: #f8fafc;
+
+    }
+
+
+    .fronius-write-editor .pr-section {
+
+        margin: 0 0 18px;
+
+        padding: 14px 16px 16px;
+
+        border: 1px solid var(--pr-border);
+
+        border-radius: 10px;
+
+        background: var(--pr-surface);
+
+    }
+
+
+    .fronius-write-editor .pr-section-title {
+
+        display: flex;
+
+        align-items: center;
+
+        gap: 8px;
+
+        margin: 0 0 4px;
+
+        font-size: 15px;
+
+        font-weight: 600;
+
+        color: #243447;
+
+    }
+
+
+    .fronius-write-editor .pr-section-note {
+
+        margin: 0 0 14px;
+
+        color: var(--pr-muted);
+
+        font-size: 12px;
+
+        line-height: 1.45;
+
+    }
+
+
+    .fronius-write-editor .pr-grid {
+
+        display: grid;
+
+        grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+
+        gap: 12px 16px;
+
+    }
+
+
+    .fronius-write-editor .pr-grid-2 {
+
+        grid-template-columns: repeat(2, minmax(320px, 1fr));
+
+    }
+
+
+    .fronius-write-editor .pr-span-2 {
+
+        grid-column: 1 / -1;
+
+    }
+
+
+    .fronius-write-editor .form-row {
+
+        margin-bottom: 12px;
+
+    }
+
+
+    .fronius-write-editor .pr-grid .form-row,
+
+    .fronius-write-editor .form-row:last-child {
+
+        margin-bottom: 0;
+
+    }
+
+
+    .fronius-write-editor .form-row > label {
+
+        width: 150px;
+
+        font-weight: 600;
+
+    }
+
+
+    .fronius-write-editor .form-row > input[type="text"],
+
+    .fronius-write-editor .form-row > input[type="number"],
+
+    .fronius-write-editor .form-row > select {
+
+        width: calc(100% - 160px);
+
+    }
+
+
+    .fronius-write-editor .pr-grid-2 .form-row > label {
+
+        width: 130px;
+
+    }
+
+
+    .fronius-write-editor .pr-grid-2 .form-row > input[type="text"],
+
+    .fronius-write-editor .pr-grid-2 .form-row > input[type="number"],
+
+    .fronius-write-editor .pr-grid-2 .form-row > select {
+
+        width: calc(100% - 140px);
+
+    }
+
+
+    .fronius-write-editor #row-ramp-nominal-power > label {
+
+        width: 160px;
+
+        white-space: nowrap;
+
+    }
+
+
+    .fronius-write-editor #row-nominal-reactive-power > label {
+
+        width: 210px;
+
+        white-space: nowrap;
+
+    }
+
+
+    .fronius-write-editor #row-ramp-nominal-power {
+
+        display: flex;
+
+        align-items: center;
+
+    }
+
+
+    .fronius-write-editor #row-ramp-nominal-power > input[type="text"] {
+
+        flex: 0 0 120px;
+
+        width: 120px;
+
+        margin-left: auto;
+
+    }
+
+
+
+
+    .fronius-write-editor #row-nominal-reactive-power > input[type="text"] {
+
+        width: 120px;
+
+    }
+
+
+    .fronius-write-editor .fw-validation-block {
+
+        border: 1px solid #f3c2c2;
+
+        border-radius: 6px;
+
+        background: #fdf2f2;
+
+        color: #a12626;
+
+        padding: 8px 10px;
+
+        line-height: 1.35;
+
+    }
+
+
+    .fronius-write-editor .fw-validation-block i {
+
+        margin-right: 6px;
+
+    }
+
+
+    .fronius-write-editor .pr-checkbox-row > input[type="checkbox"] {
+
+        width: auto;
+
+        display: inline-block;
+
+    }
+
+
+    .fronius-write-editor .pr-inline-note {
+
+        display: block;
+
+        margin-top: 5px;
+
+        color: var(--pr-muted);
+
+        font-size: 12px;
+
+        line-height: 1.35;
+
+    }
+
+
+    @media (max-width: 1100px) {
+
+        .fronius-write-editor .pr-grid-2 {
+
+            grid-template-columns: 1fr;
+
+        }
+
+
+    }
+
+</style>