@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/scada-server/scada-server.html

@@ -0,0 +1,1419 @@
+
+<style>
+    .scada-editor {
+        --scada-border: #d7dde5;
+        --scada-muted: #667085;
+        --scada-surface: #f8fafc;
+        --scada-head: #edf4fb;
+        --scada-accent: #22577a;
+        --scada-danger-bg: #fff4f2;
+        --scada-danger-border: #f3c2bd;
+        --scada-danger-text: #b54745;
+    }
+
+    .scada-editor .scada-section {
+        margin: 0 0 18px;
+        padding: 14px 16px 16px;
+        border: 1px solid var(--scada-border);
+        border-radius: 10px;
+        background: var(--scada-surface);
+    }
+
+    .scada-editor .scada-section-title {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        margin: 0 0 4px;
+        font-size: 15px;
+        font-weight: 600;
+        color: #243447;
+    }
+
+    .scada-editor .scada-section-note {
+        margin: 0 0 14px;
+        color: var(--scada-muted);
+        font-size: 12px;
+        line-height: 1.45;
+    }
+
+    .scada-editor .scada-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+        gap: 12px 16px;
+    }
+
+    .scada-editor .form-row {
+        margin-bottom: 12px;
+    }
+
+    .scada-editor .form-row:last-child,
+    .scada-editor .scada-grid .form-row {
+        margin-bottom: 0;
+    }
+
+    .scada-editor .form-row > label {
+        width: 140px;
+        font-weight: 600;
+    }
+
+    .scada-editor .form-row > input[type="text"],
+    .scada-editor .form-row > input[type="number"],
+    .scada-editor .form-row > select {
+        width: calc(100% - 150px);
+    }
+
+    .scada-editor .scada-toolbar {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 10px;
+        align-items: center;
+        margin-bottom: 12px;
+    }
+
+    .scada-editor .scada-toolbar .button,
+    .scada-editor .scada-toolbar button {
+        min-width: 0;
+    }
+
+    .scada-editor .scada-toolbar .button-group {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 8px;
+    }
+
+    .scada-editor .scada-toolbar .button-group input[type="file"] {
+        display: none;
+    }
+
+    .scada-editor .scada-toolbar .scada-filter {
+        flex: 1 1 220px;
+        min-width: 220px;
+    }
+
+    .scada-editor .scada-summary {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 10px;
+        margin-bottom: 12px;
+        color: #344054;
+    }
+
+    .scada-editor .scada-pill {
+        display: inline-flex;
+        align-items: center;
+        gap: 8px;
+        padding: 7px 12px;
+        border: 1px solid var(--scada-border);
+        border-radius: 999px;
+        background: #fff;
+        font-size: 12px;
+        font-weight: 600;
+    }
+
+    .scada-editor .scada-table-wrap {
+        overflow-x: auto;
+        border: 1px solid var(--scada-border);
+        border-radius: 10px;
+        background: #fff;
+    }
+
+    .scada-editor .scada-table {
+        width: 100%;
+        min-width: 760px;
+        border-collapse: collapse;
+        table-layout: fixed;
+    }
+
+    /* Keep the short values compact and reserve flexible space for message paths. */
+    .scada-editor .scada-col-key {
+        width: 145px;
+    }
+
+    .scada-editor .scada-col-address {
+        width: 110px;
+    }
+
+    .scada-editor .scada-col-label {
+        width: 150px;
+    }
+
+    .scada-editor.scada-show-advanced .scada-table {
+        min-width: 1380px;
+    }
+
+    .scada-editor .scada-table th,
+    .scada-editor .scada-table td {
+        padding: 8px;
+        border-bottom: 1px solid #e6ebf2;
+        vertical-align: middle;
+    }
+
+    .scada-editor .scada-table th {
+        position: sticky;
+        top: 0;
+        background: var(--scada-head);
+        text-align: left;
+        font-size: 12px;
+        text-transform: uppercase;
+        letter-spacing: 0.03em;
+        color: #455468;
+        z-index: 1;
+    }
+
+    .scada-editor .scada-table tbody tr:nth-child(even) {
+        background: #fbfdff;
+    }
+
+    .scada-editor .scada-table tbody tr.scada-hidden {
+        display: none;
+    }
+
+    .scada-editor .scada-table td input,
+    .scada-editor .scada-table td select {
+        width: 100%;
+        margin: 0;
+        box-sizing: border-box;
+    }
+
+    .scada-editor .scada-col-index {
+        width: 38px;
+        text-align: center;
+        color: var(--scada-muted);
+        font-weight: 600;
+    }
+
+    .scada-editor .scada-col-actions {
+        width: 92px;
+    }
+
+    .scada-editor .scada-row-actions {
+        display: flex;
+        gap: 6px;
+    }
+
+    .scada-editor .scada-row-actions .button {
+        padding-left: 8px;
+        padding-right: 8px;
+    }
+
+    .scada-editor .scada-advanced {
+        display: none;
+    }
+
+    .scada-editor.scada-show-advanced .scada-advanced {
+        display: table-cell;
+    }
+
+    .scada-editor .scada-validation {
+        display: none;
+        margin-top: 12px;
+        padding: 10px 12px;
+        border: 1px solid var(--scada-danger-border);
+        border-radius: 8px;
+        background: var(--scada-danger-bg);
+        color: var(--scada-danger-text);
+        font-weight: 600;
+        white-space: pre-line;
+    }
+
+    .scada-editor .scada-empty {
+        padding: 18px;
+        text-align: center;
+        color: var(--scada-muted);
+    }
+</style>
+
+<script type="text/javascript">
+
+    (function () {
+
+        const ADVANCED_CLASS = "scada-show-advanced";
+
+        function defaultMetricOptions(extra) {
+
+            return Object.assign({
+                byteOrder: "big_endian",
+                wordOrder: "msw_first"
+            }, extra || {});
+
+        }
+
+
+        function defaultMetrics() {
+
+            return [
+                defaultMetricOptions({ key: "p", label: "P", address: 0, type: "int32", scale: 1, path: "payload.active_power_w", unit: "W", signMode: "as_is" }),
+                defaultMetricOptions({ key: "q", label: "Q", address: 2, type: "int32", scale: 1, path: "payload.reactive_power_var", unit: "VAr", signMode: "as_is" }),
+                defaultMetricOptions({ key: "f", label: "F", address: 4, type: "uint32", scale: 100, path: "payload.frequency_hz", unit: "Hz" }),
+                defaultMetricOptions({ key: "u12", label: "U12", address: 6, type: "uint32", scale: 10, path: "payload.voltage_l1_l2_v", unit: "V" }),
+                defaultMetricOptions({ key: "u23", label: "U23", address: 8, type: "uint32", scale: 10, path: "payload.voltage_l2_l3_v", unit: "V" }),
+                defaultMetricOptions({ key: "u13", label: "U13", address: 10, type: "uint32", scale: 10, path: "payload.voltage_l1_l3_v", unit: "V" }),
+                defaultMetricOptions({ key: "cef_pos", label: "CEF", address: 12, type: "uint16", scale: 1, path: "payload.cef_breaker_position", unit: "" }),
+                defaultMetricOptions({ key: "bess_soc", label: "SOC", address: 13, type: "uint16", scale: 10, path: "payload.bess_soc_pct", unit: "%" }),
+                defaultMetricOptions({ key: "bess_p", label: "BP", address: 14, type: "int32", scale: 1, path: "payload.bess_power_w", unit: "W", signMode: "as_is" }),
+                defaultMetricOptions({ key: "bess_ext", label: "BEX", address: 16, type: "uint16", scale: 1, path: "payload.bess_external_control", unit: "" })
+            ];
+
+        }
+
+
+        const AGGREGATOR_VOLTAGE_PROFILES = {
+            compact: ["u_ln_avg", "u_ll_avg"],
+            three_phase: ["u_l1n", "u_l2n", "u_l3n", "u_l12", "u_l23", "u_l31"],
+            complete: ["u_l1n", "u_l2n", "u_l3n", "u_ln_avg", "u_l12", "u_l23", "u_l31", "u_ll_avg"]
+        };
+
+        const AGGREGATOR_SIGNALS = {
+            p: ["P", "W"], q: ["Q", "VAr"], f: ["F", "Hz"],
+            u_l1n: ["U L1-N", "V"], u_l2n: ["U L2-N", "V"], u_l3n: ["U L3-N", "V"], u_ln_avg: ["U L-N medie", "V"],
+            u_l12: ["U L1-L2", "V"], u_l23: ["U L2-L3", "V"], u_l31: ["U L3-L1", "V"], u_ll_avg: ["U L-L medie", "V"]
+        };
+
+        function aggregatorGroupsFromEditor() {
+            const groups = [];
+            $("#node-scada-aggregator-groups .scada-aggregator-group").each(function (index) {
+                const row = $(this);
+                const id = String(row.find(".scada-aggregator-group-id").val() || "").trim().toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || ("group_" + (index + 1));
+                const label = String(row.find(".scada-aggregator-group-label").val() || id).trim() || id;
+                const count = Math.max(0, Math.min(99, Math.round(Number(row.find(".scada-aggregator-group-count").val()) || 0)));
+                groups.push({ id: id, label: label, count: count });
+            });
+            return groups.length ? groups : [{ id: "grid_meter", label: "Grid meter", count: 3 }, { id: "pv_inverter", label: "PV inverter", count: 13 }, { id: "bess", label: "BESS", count: 1 }];
+        }
+
+        function buildAggregatorMetricsFromEditor() {
+            const prefix = String($("#node-input-aggregatorPrefix").val() || "payload.scada").trim().replace(/\.+$/, "") || "payload.scada";
+            const profile = $("#node-input-aggregatorVoltageProfile").val();
+            const signals = ["p", "q"].concat(AGGREGATOR_VOLTAGE_PROFILES[profile] || AGGREGATOR_VOLTAGE_PROFILES.complete, ["f"]);
+            const groups = aggregatorGroupsFromEditor();
+            const sources = [];
+            groups.forEach(function (group) { for (let index = 1; index <= group.count; index += 1) sources.push([group.id, group.count === 1 ? group.id : group.id + "_" + String(index).padStart(2, "0"), group.count === 1 ? group.label : group.label + " " + String(index).padStart(2, "0")]); });
+            const metrics = [];
+            const addBlock = function (group, id, label, address, total) {
+                signals.forEach(function (signal, index) {
+                    const info = AGGREGATOR_SIGNALS[signal];
+                    metrics.push(defaultMetricOptions({ key: (total ? "total_" + group : id) + "_" + signal, label: (total ? "Total " + group : label) + " " + info[0], address: address + (index * 2), type: "float32", scale: 1, path: prefix + "." + (total ? "totals." + group : group + "." + id) + "." + signal, unit: info[1], signMode: "as_is" }));
+                });
+                metrics.push(defaultMetricOptions({ key: (total ? "total_" + group : id) + "_" + (total ? "active" : "online"), label: (total ? "Total " + group : label) + " " + (total ? "active" : "online"), address: address + 28, type: "uint16", scale: 1, path: prefix + "." + (total ? "totals." + group : group + "." + id) + "." + (total ? "active" : "online"), unit: "" }));
+                if (!total) metrics.push(defaultMetricOptions({ key: id + "_age_s", label: label + " age", address: address + 29, type: "uint16", scale: 1, path: prefix + "." + group + "." + id + ".age_s", unit: "s" }));
+            };
+            sources.forEach(function (source, index) { addBlock(source[0], source[1], source[2], index * 32, false); });
+            const totalsAddress = sources.length * 32;
+            groups.forEach(function (group, index) { addBlock(group.id, "", group.label, totalsAddress + (index * 32), true); });
+            addBlock("site", "", "Site", totalsAddress + (groups.length * 32), true);
+            return metrics;
+        }
+
+
+        function makeFloatMetrics(items) {
+
+            return items.map(function (item, index) {
+                return defaultMetricOptions({
+                    key: item[0],
+                    label: item[1],
+                    address: index * 2,
+                    type: "float32",
+                    scale: item[3] || 1,
+                    path: item[2],
+                    unit: item[4] || "",
+                    signMode: "as_is"
+                });
+            });
+
+        }
+
+
+        function froniusInverterMetrics() {
+
+            return makeFloatMetrics([
+                ["p_ac", "P AC", "payload.summary.ac.power_w", 1, "W"],
+                ["p_dc", "P DC", "payload.summary.dc.dc_total_power_w", 1, "W"],
+                ["f", "F", "payload.summary.ac.frequency_hz", 1, "Hz"],
+                ["u1", "U1", "payload.summary.ac.voltage_l1_v", 1, "V"],
+                ["u2", "U2", "payload.summary.ac.voltage_l2_v", 1, "V"],
+                ["u3", "U3", "payload.summary.ac.voltage_l3_v", 1, "V"],
+                ["i_total", "I total", "payload.summary.ac.current_total_a", 1, "A"],
+                ["i1", "I1", "payload.summary.ac.current_l1_a", 1, "A"],
+                ["i2", "I2", "payload.summary.ac.current_l2_a", 1, "A"],
+                ["i3", "I3", "payload.summary.ac.current_l3_a", 1, "A"]
+            ]);
+
+        }
+
+
+        function froniusSmartMeterMetrics() {
+
+            return makeFloatMetrics([
+                ["p", "P", "payload.summary.meter.power_w", 1, "W"],
+                ["p1", "P1", "payload.summary.meter.power_l1_w", 1, "W"],
+                ["p2", "P2", "payload.summary.meter.power_l2_w", 1, "W"],
+                ["p3", "P3", "payload.summary.meter.power_l3_w", 1, "W"],
+                ["q", "Q", "payload.summary.meter.reactive_power_var", 1, "var"],
+                ["s", "S", "payload.summary.meter.apparent_power_va", 1, "VA"],
+                ["f", "F", "payload.summary.meter.frequency_hz", 1, "Hz"],
+                ["u_ln", "U L-N", "payload.summary.meter.voltage_ln_avg_v", 1, "V"],
+                ["u_ll", "U L-L", "payload.summary.meter.voltage_ll_avg_v", 1, "V"],
+                ["i_total", "I total", "payload.summary.meter.current_total_a", 1, "A"],
+                ["pf", "PF", "payload.summary.meter.power_factor", 1, ""],
+                ["e_imp", "E imp", "payload.summary.meter.energy_import_wh", 1, "Wh"],
+                ["e_exp", "E exp", "payload.summary.meter.energy_export_wh", 1, "Wh"]
+            ]);
+
+        }
+
+
+        function janitzaMetrics() {
+
+            return makeFloatMetrics([
+                ["p", "P", "payload.summary.power.total_w", 1, "W"],
+                ["p1", "P1", "payload.summary.quick.power.l1_w", 1, "W"],
+                ["p2", "P2", "payload.summary.quick.power.l2_w", 1, "W"],
+                ["p3", "P3", "payload.summary.quick.power.l3_w", 1, "W"],
+                ["q", "Q", "payload.summary.reactive.total_var", 1, "var"],
+                ["f", "F", "payload.summary.frequency_hz", 1, "Hz"],
+                ["u12", "U12", "payload.summary.voltage.l1_l2_v", 1, "V"],
+                ["u23", "U23", "payload.summary.voltage.l2_l3_v", 1, "V"],
+                ["u31", "U31", "payload.summary.voltage.l3_l1_v", 1, "V"],
+                ["i1", "I1", "payload.summary.current.l1_a", 1, "A"],
+                ["i2", "I2", "payload.summary.current.l2_a", 1, "A"],
+                ["i3", "I3", "payload.summary.current.l3_a", 1, "A"]
+            ]);
+
+        }
+
+
+        function carloGavazziMetrics() {
+
+            return makeFloatMetrics([
+                ["p", "P", "payload.summary.power.total_w", 1, "W"],
+                ["p1", "P1", "payload.summary.power.l1_w", 1, "W"],
+                ["p2", "P2", "payload.summary.power.l2_w", 1, "W"],
+                ["p3", "P3", "payload.summary.power.l3_w", 1, "W"],
+                ["q", "Q", "payload.summary.reactive.total_var", 1, "var"],
+                ["f", "F", "payload.summary.frequency_hz", 1, "Hz"],
+                ["u12", "U12", "payload.summary.voltage.l1_l2_v", 1, "V"],
+                ["u23", "U23", "payload.summary.voltage.l2_l3_v", 1, "V"],
+                ["u31", "U31", "payload.summary.voltage.l3_l1_v", 1, "V"],
+                ["i1", "I1", "payload.summary.current.l1_a", 1, "A"],
+                ["i2", "I2", "payload.summary.current.l2_a", 1, "A"],
+                ["i3", "I3", "payload.summary.current.l3_a", 1, "A"]
+            ]);
+
+        }
+
+
+        function presetMetrics(name) {
+
+            if (name === "grid") {
+                return defaultMetrics().filter(function (metric) {
+                    return ["p", "q", "f", "u12", "u23", "u13", "cef_pos"].includes(metric.key);
+                });
+            }
+
+            if (name === "bess") {
+                return defaultMetrics().filter(function (metric) {
+                    return ["bess_soc", "bess_p", "bess_ext"].includes(metric.key);
+                });
+            }
+
+            if (name === "fronius_inverter") {
+                return froniusInverterMetrics();
+            }
+
+            if (name === "fronius_meter") {
+                return froniusSmartMeterMetrics();
+            }
+
+            if (name === "janitza") {
+                return janitzaMetrics();
+            }
+
+            if (name === "carlo_gavazzi") {
+                return carloGavazziMetrics();
+            }
+
+            return defaultMetrics();
+
+        }
+
+
+        function escapeAttribute(value) {
+
+            return String(value == null ? "" : value)
+                .replace(/&/g, "&amp;")
+                .replace(/"/g, "&quot;")
+                .replace(/</g, "&lt;")
+                .replace(/>/g, "&gt;");
+
+        }
+
+
+        function toMetric(metric, index) {
+
+            const value = metric || {};
+
+            return {
+                key: String(value.key || "").trim(),
+                label: String(value.label || value.key || "").trim(),
+                address: Math.max(0, Number(value.address || 0)),
+                type: String(value.type || "int32").trim(),
+                scale: Number.isFinite(Number(value.scale)) ? Number(value.scale) : 1,
+                path: String(value.path || "").trim(),
+                unit: String(value.unit || "").trim(),
+                signMode: String(value.signMode || "as_is").trim(),
+                byteOrder: String(value.byteOrder || "big_endian").trim(),
+                wordOrder: String(value.wordOrder || "msw_first").trim()
+            };
+
+        }
+
+
+        function wordLength(type) {
+
+            return (type === "int16" || type === "uint16") ? 1 : 2;
+
+        }
+
+
+        function readMetricRows() {
+
+            const metrics = [];
+
+            $("#node-input-metrics-container .scada-metric-row").each(function (index) {
+
+                const row = $(this);
+
+                metrics.push(toMetric({
+                    key: row.find(".scada-metric-key").val(),
+                    label: row.find(".scada-metric-label").val(),
+                    address: row.find(".scada-metric-address").val(),
+                    type: row.find(".scada-metric-type").val(),
+                    scale: row.find(".scada-metric-scale").val(),
+                    path: row.find(".scada-metric-path").val(),
+                    unit: row.find(".scada-metric-unit").val(),
+                    signMode: row.find(".scada-metric-sign").val(),
+                    byteOrder: row.find(".scada-metric-byte-order").val(),
+                    wordOrder: row.find(".scada-metric-word-order").val()
+                }, index));
+
+            });
+
+            return metrics;
+
+        }
+
+
+        function validateMetrics(metrics) {
+
+            const errors = [];
+            const warnings = [];
+            const seenKeys = new Set();
+            const ranges = [];
+            const validByteOrders = ["big_endian", "little_endian"];
+            const validWordOrders = ["msw_first", "lsw_first"];
+
+            if (!metrics.length) {
+                errors.push("Adauga cel putin un registru.");
+                return { errors: errors, warnings: warnings };
+            }
+
+            metrics.forEach(function (metric, index) {
+
+                const rowLabel = "Randul " + (index + 1);
+
+                if (!metric.key) {
+                    errors.push(rowLabel + ": cheia este obligatorie.");
+                } else if (seenKeys.has(metric.key)) {
+                    errors.push(rowLabel + ': cheia "' + metric.key + '" este duplicata.');
+                } else {
+                    seenKeys.add(metric.key);
+                }
+
+                if (!metric.path) {
+                    errors.push(rowLabel + ": calea mesajului este obligatorie.");
+                }
+
+                if (!Number.isFinite(Number(metric.address)) || Number(metric.address) < 0) {
+                    errors.push(rowLabel + ": adresa trebuie sa fie >= 0.");
+                    return;
+                }
+
+                if (!Number.isFinite(Number(metric.scale)) || Number(metric.scale) === 0) {
+                    errors.push(rowLabel + ": scale trebuie sa fie un numar diferit de 0.");
+                }
+
+                if (!validByteOrders.includes(metric.byteOrder)) {
+                    errors.push(rowLabel + ": byte order invalid.");
+                }
+
+                if (!validWordOrders.includes(metric.wordOrder)) {
+                    errors.push(rowLabel + ": word order invalid.");
+                }
+
+                ranges.push({
+                    key: metric.key || ("row_" + index),
+                    start: Number(metric.address),
+                    end: Number(metric.address) + wordLength(metric.type) - 1
+                });
+
+                if ((Number(metric.address) + wordLength(metric.type) - 1) > 65535) {
+                    errors.push(rowLabel + ": registrul depaseste limita Modbus 65535.");
+                }
+
+            });
+
+            ranges.sort(function (left, right) {
+                return left.start - right.start;
+            });
+
+            for (let index = 1; index < ranges.length; index += 1) {
+                const previous = ranges[index - 1];
+                const current = ranges[index];
+
+                if (current.start <= previous.end) {
+                    errors.push('Conflicte de adrese intre "' + previous.key + '" si "' + current.key + '".');
+                } else if (current.start > (previous.end + 1)) {
+                    warnings.push('Gap intre "' + previous.key + '" si "' + current.key + '" (adrese libere: ' + (previous.end + 1) + ".." + (current.start - 1) + ").");
+                }
+            }
+
+            return { errors: errors, warnings: warnings };
+        }
+
+
+        function updateSummary(metrics) {
+
+            const registerCount = metrics.reduce(function (sum, metric) {
+                return sum + wordLength(metric.type);
+            }, 0);
+
+            $("#node-scada-metric-count").text(String(metrics.length));
+            $("#node-scada-register-count").text(String(registerCount));
+        }
+
+
+        function applyFilter() {
+
+            const query = String($("#node-input-metrics-filter").val() || "").trim().toLowerCase();
+
+            $("#node-input-metrics-container .scada-metric-row").each(function () {
+
+                const row = $(this);
+                const text = row.text().toLowerCase() + " " + row.find("input,select").map(function () {
+                    return $(this).val();
+                }).get().join(" ").toLowerCase();
+
+                row.toggleClass("scada-hidden", Boolean(query) && text.indexOf(query) === -1);
+
+            });
+        }
+
+
+        function validateServerSettings() {
+
+            const errors = [];
+            const port = Number($("#node-input-port").val());
+            const unitId = Number($("#node-input-unitId").val());
+            const maxConnections = Number($("#node-input-maxConnections").val());
+            const idleTimeoutMs = Number($("#node-input-socketIdleTimeoutMs").val());
+            const rateLimit = Number($("#node-input-rateLimitPerSecond").val());
+            const diagIntervalMs = Number($("#node-input-diagIntervalMs").val());
+            const host = String($("#node-input-host").val() || "").trim();
+
+            if (!Number.isFinite(port) || port < 1 || port > 65535) {
+                errors.push("Port trebuie sa fie intre 1 si 65535.");
+            }
+
+            if (!host) {
+                errors.push("Bind host este obligatoriu.");
+            }
+
+            if (!Number.isFinite(unitId) || unitId < 0 || unitId > 255) {
+                errors.push("Unit ID trebuie sa fie intre 0 si 255.");
+            }
+
+            if (!Number.isFinite(maxConnections) || maxConnections < 1 || maxConnections > 2000) {
+                errors.push("Max Clients trebuie sa fie intre 1 si 2000.");
+            }
+
+            if (!Number.isFinite(idleTimeoutMs) || idleTimeoutMs < 500) {
+                errors.push("Idle timeout trebuie sa fie >= 500 ms.");
+            }
+
+            if (!Number.isFinite(rateLimit) || rateLimit < 0) {
+                errors.push("Rate limit trebuie sa fie >= 0.");
+            }
+
+            if (!Number.isFinite(diagIntervalMs) || diagIntervalMs < 500) {
+                errors.push("Diag interval trebuie sa fie >= 500 ms.");
+            }
+
+            return errors;
+
+        }
+
+
+        function validateAndRefresh() {
+
+            const metrics = readMetricRows();
+            const validation = validateMetrics(metrics);
+            const serverErrors = validateServerSettings();
+            const validationBox = $("#node-scada-validation");
+            const lines = [];
+
+            updateSummary(metrics);
+            applyFilter();
+
+            if (serverErrors.length) {
+                lines.push("Erori server:");
+                serverErrors.forEach(function (line) {
+                    lines.push(" - " + line);
+                });
+            }
+
+            if (validation.errors.length) {
+                lines.push("Erori mapare:");
+                validation.errors.forEach(function (line) {
+                    lines.push(" - " + line);
+                });
+            }
+
+            if (validation.warnings.length) {
+                lines.push("Avertismente:");
+                validation.warnings.forEach(function (line) {
+                    lines.push(" - " + line);
+                });
+            }
+
+            validationBox.text(lines.join("\n")).toggle(lines.length > 0);
+            return !serverErrors.length && !validation.errors.length;
+        }
+
+
+        function createRow(metric, index) {
+
+            const row = $(`
+                <tr class="scada-metric-row">
+                    <td class="scada-col-index">${index + 1}</td>
+                    <td class="scada-col-key"><input type="text" class="scada-metric-key" value="${escapeAttribute(metric.key)}" aria-label="Key"></td>
+                    <td class="scada-col-address"><input type="number" class="scada-metric-address" value="${escapeAttribute(metric.address)}" aria-label="Address"></td>
+                    <td><input type="text" class="scada-metric-path" value="${escapeAttribute(metric.path)}"></td>
+                    <td class="scada-col-label"><input type="text" class="scada-metric-label" value="${escapeAttribute(metric.label)}" aria-label="Label"></td>
+                    <td class="scada-advanced">
+                        <select class="scada-metric-type">
+                            <option value="int16" ${metric.type === "int16" ? "selected" : ""}>int16</option>
+                            <option value="uint16" ${metric.type === "uint16" ? "selected" : ""}>uint16</option>
+                            <option value="int32" ${metric.type === "int32" ? "selected" : ""}>int32</option>
+                            <option value="uint32" ${metric.type === "uint32" ? "selected" : ""}>uint32</option>
+                            <option value="float32" ${metric.type === "float32" ? "selected" : ""}>float32</option>
+                        </select>
+                    </td>
+                    <td class="scada-advanced"><input type="number" class="scada-metric-scale" step="0.01" value="${escapeAttribute(metric.scale)}"></td>
+                    <td class="scada-advanced">
+                        <select class="scada-metric-sign">
+                            <option value="as_is" ${metric.signMode === "as_is" ? "selected" : ""}>as_is</option>
+                            <option value="invert" ${metric.signMode === "invert" ? "selected" : ""}>invert</option>
+                        </select>
+                    </td>
+                    <td class="scada-advanced">
+                        <select class="scada-metric-word-order">
+                            <option value="msw_first" ${metric.wordOrder === "msw_first" ? "selected" : ""}>MSW first</option>
+                            <option value="lsw_first" ${metric.wordOrder === "lsw_first" ? "selected" : ""}>LSW first</option>
+                        </select>
+                    </td>
+                    <td class="scada-advanced">
+                        <select class="scada-metric-byte-order">
+                            <option value="big_endian" ${metric.byteOrder === "big_endian" ? "selected" : ""}>Big endian</option>
+                            <option value="little_endian" ${metric.byteOrder === "little_endian" ? "selected" : ""}>Little endian</option>
+                        </select>
+                    </td>
+                    <td class="scada-advanced"><input type="text" class="scada-metric-unit" value="${escapeAttribute(metric.unit)}"></td>
+                    <td class="scada-col-actions">
+                        <div class="scada-row-actions">
+                            <a href="#" class="button scada-duplicate-row"><i class="fa fa-copy"></i></a>
+                            <a href="#" class="button scada-delete-row"><i class="fa fa-trash"></i></a>
+                        </div>
+                    </td>
+                </tr>
+            `);
+
+            row.find("input, select").on("keyup change", validateAndRefresh);
+
+            row.find(".scada-duplicate-row").on("click", function (event) {
+                event.preventDefault();
+                const metrics = readMetricRows();
+                metrics.splice(index + 1, 0, Object.assign({}, metrics[index], {
+                    key: metrics[index].key ? (metrics[index].key + "_copy") : ""
+                }));
+                buildMetricRows(metrics);
+            });
+
+            row.find(".scada-delete-row").on("click", function (event) {
+                event.preventDefault();
+                const metrics = readMetricRows().filter(function (_, itemIndex) {
+                    return itemIndex !== index;
+                });
+                buildMetricRows(metrics);
+            });
+
+            return row;
+        }
+
+
+        function autoPackAddresses() {
+
+            const metrics = readMetricRows();
+            let nextAddress = 0;
+
+            metrics.forEach(function (metric) {
+                metric.address = nextAddress;
+                nextAddress += wordLength(metric.type);
+            });
+
+            buildMetricRows(metrics);
+        }
+
+
+        function csvEscape(value) {
+
+            const text = String(value == null ? "" : value);
+
+            if (/[",\r\n]/.test(text)) {
+                return '"' + text.replace(/"/g, '""') + '"';
+            }
+
+            return text;
+
+        }
+
+
+        function metricsToCsv(metrics) {
+
+            const headers = ["key", "label", "address", "type", "scale", "path", "unit", "signMode", "wordOrder", "byteOrder"];
+
+            return [headers.join(",")].concat(metrics.map(function (metric) {
+                return headers.map(function (header) {
+                    return csvEscape(metric[header]);
+                }).join(",");
+            })).join("\n");
+
+        }
+
+        function registerExportToCsv(exportData) {
+            const headers = ["key", "label", "address", "type", "scale", "path", "unit", "value", "active", "access", "last_update_ts", "last_publish_ts"];
+            return [headers.join(",")].concat((exportData.rows || []).map(function (row) {
+                return headers.map(function (header) { return csvEscape(row[header]); }).join(",");
+            })).join("\n");
+        }
+
+
+        function parseCsvLine(line) {
+
+            const values = [];
+            let current = "";
+            let quoted = false;
+
+            for (let index = 0; index < line.length; index += 1) {
+                const ch = line[index];
+
+                if (quoted && ch === '"' && line[index + 1] === '"') {
+                    current += '"';
+                    index += 1;
+                    continue;
+                }
+
+                if (ch === '"') {
+                    quoted = !quoted;
+                    continue;
+                }
+
+                if (!quoted && ch === ",") {
+                    values.push(current);
+                    current = "";
+                    continue;
+                }
+
+                current += ch;
+            }
+
+            values.push(current);
+            return values;
+
+        }
+
+
+        function csvToMetrics(text) {
+
+            const lines = String(text || "").split(/\r?\n/).filter(function (line) {
+                return line.trim();
+            });
+
+            if (!lines.length) {
+                return [];
+            }
+
+            const headers = parseCsvLine(lines[0]).map(function (header) {
+                return String(header || "").trim();
+            });
+
+            return lines.slice(1).map(function (line) {
+                const values = parseCsvLine(line);
+                const metric = {};
+                headers.forEach(function (header, index) {
+                    metric[header] = values[index];
+                });
+                return toMetric(metric);
+            });
+
+        }
+
+
+        function downloadText(filename, text, type) {
+
+            const blob = new Blob([text], { type: type || "text/plain" });
+            const url = URL.createObjectURL(blob);
+            const link = document.createElement("a");
+            link.href = url;
+            link.download = filename;
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+            URL.revokeObjectURL(url);
+
+        }
+
+
+        function importMetricText(text, filename) {
+
+            let metrics;
+            const name = String(filename || "").toLowerCase();
+            const trimmed = String(text || "").trim();
+
+            if (!trimmed) {
+                return;
+            }
+
+            if (name.endsWith(".csv") || (!trimmed.startsWith("[") && !trimmed.startsWith("{"))) {
+                metrics = csvToMetrics(trimmed);
+            } else {
+                const parsed = JSON.parse(trimmed);
+                metrics = Array.isArray(parsed) ? parsed : parsed.metrics;
+            }
+
+            buildMetricRows(metrics);
+
+        }
+
+
+        function buildMetricRows(metrics) {
+
+            const list = (Array.isArray(metrics) && metrics.length ? metrics : defaultMetrics()).map(toMetric);
+            const container = $("#node-input-metrics-container");
+            const table = $(`
+                <div class="scada-table-wrap">
+                    <table class="scada-table">
+                        <thead>
+                            <tr>
+                                <th class="scada-col-index">#</th>
+                                <th class="scada-col-key">Key</th>
+                                <th class="scada-col-address">Addr</th>
+                                <th>Message path</th>
+                                <th class="scada-col-label">Label</th>
+                                <th class="scada-advanced">Type</th>
+                                <th class="scada-advanced">Scale</th>
+                                <th class="scada-advanced">Sign</th>
+                                <th class="scada-advanced">Word</th>
+                                <th class="scada-advanced">Byte</th>
+                                <th class="scada-advanced">Unit</th>
+                                <th>Actions</th>
+                            </tr>
+                        </thead>
+                        <tbody></tbody>
+                    </table>
+                </div>
+            `);
+
+            const tbody = table.find("tbody");
+
+            if (!list.length) {
+                container.html('<div class="scada-empty">Nu exista registre configurate.</div>');
+                validateAndRefresh();
+                return;
+            }
+
+            list.forEach(function (metric, index) {
+                tbody.append(createRow(metric, index));
+            });
+
+            container.empty().append(table);
+            validateAndRefresh();
+        }
+
+
+        RED.nodes.registerType("scada-server", {
+
+            category: "Atelierul de Tehnologii",
+            color: "#cfe2f3",
+
+            defaults: {
+            license: { value: "", type: "atelier-license", required: true },
+                name: { value: "SCADA Server" },
+                host: {
+                value: "0.0.0.0",
+                    validate: function (value) {
+                        return !!String(value || "").trim();
+                    }
+                },
+                port: {
+                    value: 1502,
+                    validate: function (value) {
+                        const n = Number(value);
+                        return Number.isFinite(n) && n >= 1 && n <= 65535;
+                    }
+                },
+                unitId: {
+                    value: 1,
+                    validate: function (value) {
+                        const n = Number(value);
+                        return Number.isFinite(n) && n >= 0 && n <= 255;
+                    }
+                },
+                plantId: { value: "" },
+                publishIntervalMs: { value: 500, validate: function (value) { return Number(value) >= 100; } },
+                publishOnInput: { value: false },
+                maxReadLogEntries: { value: 100, validate: function (value) { return Number(value) >= 10; } },
+                maxConnections: { value: 20, validate: function (value) { return Number(value) >= 1; } },
+                socketIdleTimeoutMs: { value: 30000, validate: function (value) { return Number(value) >= 500; } },
+                rateLimitPerSecond: { value: 0, validate: function (value) { return Number(value) >= 0; } },
+                diagIntervalMs: { value: 2000, validate: function (value) { return Number(value) >= 500; } },
+                outOfRangeMode: { value: "zeros" },
+                addressingMode: { value: "zero_based" },
+                mapMode: { value: "direct" },
+                aggregatorPrefix: { value: "payload.scada" },
+                aggregatorGroups: { value: '[{"id":"grid_meter","label":"Grid meter","count":3},{"id":"pv_inverter","label":"PV inverter","count":13},{"id":"bess","label":"BESS","count":1}]' },
+                aggregatorCategories: { value: '[{"id":"grid_meter","label":"Grid meter","base":256,"slots":16},{"id":"pv_inverter","label":"PV inverter","base":768,"slots":64},{"id":"bess","label":"BESS","base":2816,"slots":16}]' },
+                aggregatorVoltageProfile: { value: "complete" },
+                metrics: { value: defaultMetrics() }
+            },
+
+            inputs: 1,
+            outputs: 2,
+            icon: "font-awesome/fa-server",
+
+            outputLabels: function (index) {
+                return index === 0 ? "state" : "diagnostics";
+            },
+
+            label: function () {
+                return "SCADA Server";
+            },
+
+            oneditprepare: function () {
+
+                const editor = $("#node-dialog-form").closest(".red-ui-editor, .red-ui-tray, body");
+                const root = $(".scada-editor");
+                const nodeId = this.id;
+                $("#node-input-name").val("SCADA Server").prop("readonly", true);
+                const manualMetrics = (Array.isArray(this.metrics) && this.metrics.length ? this.metrics : defaultMetrics());
+
+                function addAggregatorGroup(group) {
+                    const value = group || { id: "custom_group", label: "Custom group", count: 1 };
+                    const row = $("<div class='scada-aggregator-group scada-toolbar'></div>");
+                    row.append("<input type='text' class='scada-aggregator-group-id' placeholder='id' aria-label='ID grup'>").find("input:last").val(value.id);
+                    row.append("<input type='text' class='scada-aggregator-group-label' placeholder='Denumire' aria-label='Denumire grup'>").find("input:last").val(value.label);
+                    row.append("<input type='number' class='scada-aggregator-group-count' min='0' aria-label='Numar surse'>").find("input:last").val(value.count);
+                    row.append("<a href='#' class='button scada-remove-aggregator-group'><i class='fa fa-trash'></i></a>");
+                    row.find(".scada-remove-aggregator-group").on("click", function (event) { event.preventDefault(); row.remove(); });
+                    $("#node-scada-aggregator-groups").append(row);
+                }
+                let savedAggregatorGroups;
+                try { savedAggregatorGroups = JSON.parse(this.aggregatorGroups); } catch (_) { savedAggregatorGroups = null; }
+                (Array.isArray(savedAggregatorGroups) && savedAggregatorGroups.length ? savedAggregatorGroups : [{ id: "grid_meter", label: "Grid meter", count: 3 }, { id: "pv_inverter", label: "PV inverter", count: 13 }, { id: "bess", label: "BESS", count: 1 }]).forEach(addAggregatorGroup);
+                $("#node-scada-add-aggregator-group").off(".scada").on("click.scada", function (event) { event.preventDefault(); addAggregatorGroup(); });
+
+                function refreshMapMode() {
+                    const mode = $("#node-input-mapMode").val();
+                    const aggregator = mode === "aggregator";
+                    const auto = mode === "aggregator_auto";
+                    $("#node-scada-aggregator-config").toggle(aggregator);
+                    $("#node-scada-auto-info").toggle(auto);
+                    $("#node-scada-direct-tools").toggle(mode === "direct");
+                    if (aggregator) buildMetricRows(buildAggregatorMetricsFromEditor());
+                    else if (auto) $("#node-input-metrics-container").html('<div class="scada-empty">Harta se populeaza automat dupa deploy, cand scada-aggregator publica surse noi. Adresele alocate raman stabile pana la redeploy.</div>');
+                    else buildMetricRows(manualMetrics);
+                }
+
+                buildMetricRows(this.mapMode === "aggregator" ? buildAggregatorMetricsFromEditor() : this.metrics);
+                $("#node-input-mapMode").off(".scada").on("change.scada", refreshMapMode);
+                $("#node-scada-generate-aggregator-map").off(".scada").on("click.scada", function (event) { event.preventDefault(); buildMetricRows(buildAggregatorMetricsFromEditor()); });
+                refreshMapMode();
+
+                $("#node-scada-download-active-json, #node-scada-download-active-csv").off(".scada").on("click.scada", function (event) {
+                    event.preventDefault();
+                    const format = this.id.endsWith("csv") ? "csv" : "json";
+                    if (!nodeId) { $("#node-scada-validation").text("Salveaza si da deploy nodului inainte de exportul live.").show(); return; }
+                    $.getJSON("scada-server/register-map/" + encodeURIComponent(nodeId) + "?activeOnly=true").done(function (result) {
+                        const text = format === "csv" ? registerExportToCsv(result) : JSON.stringify(result, null, 2);
+                        downloadText("scada-active-registers." + format, text, format === "csv" ? "text/csv" : "application/json");
+                    }).fail(function () { $("#node-scada-validation").text("Nu pot citi harta live. Verifica daca nodul este deployat si a primit date.").show(); });
+                });
+
+                $("#node-input-metrics-filter").off(".scada").on("keyup.scada change.scada", applyFilter);
+
+                $("#node-scada-toggle-advanced").off(".scada").on("click.scada", function (event) {
+                    event.preventDefault();
+                    root.toggleClass(ADVANCED_CLASS);
+                    $(this).text(root.hasClass(ADVANCED_CLASS) ? "Ascunde avansate" : "Arata avansate");
+                });
+
+                $("#node-scada-add-metric").off(".scada").on("click.scada", function (event) {
+                    event.preventDefault();
+                    const metrics = readMetricRows();
+                    const nextAddress = metrics.reduce(function (max, metric) {
+                        return Math.max(max, Number(metric.address || 0) + wordLength(metric.type));
+                    }, 0);
+
+                    metrics.push({
+                        key: "",
+                        label: "",
+                        address: nextAddress,
+                        type: "int32",
+                        scale: 1,
+                        path: "",
+                        unit: "",
+                        signMode: "as_is",
+                        byteOrder: "big_endian",
+                        wordOrder: "msw_first"
+                    });
+
+                    buildMetricRows(metrics);
+                });
+
+                $("#node-scada-sort-metrics").off(".scada").on("click.scada", function (event) {
+                    event.preventDefault();
+                    const metrics = readMetricRows().sort(function (left, right) {
+                        return Number(left.address || 0) - Number(right.address || 0);
+                    });
+                    buildMetricRows(metrics);
+                });
+
+                $("#node-scada-autopack-metrics").off(".scada").on("click.scada", function (event) {
+                    event.preventDefault();
+                    autoPackAddresses();
+                });
+
+                $("#node-scada-reset-defaults").off(".scada").on("click.scada", function (event) {
+                    event.preventDefault();
+                    buildMetricRows(defaultMetrics());
+                    $("#node-input-scada-preset").val("default");
+                });
+
+                $("#node-input-scada-preset").off(".scada").on("change.scada", function () {
+                    const value = $(this).val();
+                    if (value) {
+                        buildMetricRows(presetMetrics(value));
+                    }
+                });
+
+                $("#node-scada-export-json").off(".scada").on("click.scada", function (event) {
+                    event.preventDefault();
+                    downloadText("scada-register-map.json", JSON.stringify(readMetricRows(), null, 2), "application/json");
+                });
+
+                $("#node-scada-export-csv").off(".scada").on("click.scada", function (event) {
+                    event.preventDefault();
+                    downloadText("scada-register-map.csv", metricsToCsv(readMetricRows()), "text/csv");
+                });
+
+                $("#node-scada-import-map").off(".scada").on("click.scada", function (event) {
+                    event.preventDefault();
+                    $("#node-input-scada-import-file").val("").trigger("click");
+                });
+
+                $("#node-input-scada-import-file").off(".scada").on("change.scada", function () {
+                    const file = this.files && this.files[0];
+                    if (!file) {
+                        return;
+                    }
+
+                    const reader = new FileReader();
+                    reader.onload = function () {
+                        try {
+                            importMetricText(reader.result, file.name);
+                        } catch (error) {
+                            $("#node-scada-validation").text("Import invalid: " + error.message).show();
+                        }
+                    };
+                    reader.readAsText(file);
+                });
+
+                if (editor.length) {
+                    editor.off(".scadaValidate").on("keyup.scadaValidate change.scadaValidate", ".scada-editor input, .scada-editor select", validateAndRefresh);
+                }
+            },
+
+            oneditsave: function () {
+                this.aggregatorGroups = JSON.stringify(aggregatorGroupsFromEditor());
+                this.metrics = $("#node-input-mapMode").val() === "aggregator" ? buildAggregatorMetricsFromEditor() : readMetricRows();
+                $("#node-input-name").val("SCADA Server");
+            },
+
+            oneditcancel: function () {
+                $("#node-input-name").prop("readonly", false);
+            }
+
+        });
+
+    })();
+
+</script>
+
+
+<script type="text/html" data-template-name="scada-server">
+    <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="scada-editor">
+
+        <div class="scada-section">
+            <div class="scada-section-title"><i class="fa fa-server"></i> Server</div>
+            <p class="scada-section-note">Setarile de conectivitate sunt separate de harta de registre, ca sa poti lucra rapid chiar si cu configuratii mari.</p>
+
+            <div class="scada-grid">
+                <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="scada-server">
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-plantId"><i class="fa fa-industry"></i> Plant ID</label>
+                    <input type="text" id="node-input-plantId" placeholder="optional">
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-host"><i class="fa fa-globe"></i> Bind host</label>
+    <input type="text" id="node-input-host" placeholder="0.0.0.0">
+                </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="1502">
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-unitId"><i class="fa fa-hashtag"></i> Unit ID</label>
+                    <input type="text" id="node-input-unitId" placeholder="1">
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-publishIntervalMs"><i class="fa fa-refresh"></i> Publish (ms)</label>
+                    <input type="text" id="node-input-publishIntervalMs" placeholder="500">
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-maxReadLogEntries"><i class="fa fa-book"></i> Read log</label>
+                    <input type="text" id="node-input-maxReadLogEntries" placeholder="100">
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-maxConnections"><i class="fa fa-users"></i> Max Clients</label>
+                    <input type="text" id="node-input-maxConnections" placeholder="20">
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-socketIdleTimeoutMs"><i class="fa fa-hourglass-half"></i> Idle timeout (ms)</label>
+                    <input type="text" id="node-input-socketIdleTimeoutMs" placeholder="30000">
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-rateLimitPerSecond"><i class="fa fa-tachometer"></i> Rate limit (req/s)</label>
+                    <input type="text" id="node-input-rateLimitPerSecond" placeholder="0">
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-diagIntervalMs"><i class="fa fa-area-chart"></i> Diag interval (ms)</label>
+                    <input type="text" id="node-input-diagIntervalMs" placeholder="2000">
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-outOfRangeMode"><i class="fa fa-exclamation-triangle"></i> Out of range</label>
+                    <select id="node-input-outOfRangeMode">
+                        <option value="zeros">Return 0</option>
+                        <option value="exception">Modbus exception</option>
+                    </select>
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-addressingMode"><i class="fa fa-map-signs"></i> Addressing docs</label>
+                    <select id="node-input-addressingMode">
+                        <option value="zero_based">0-based (0, 1, 2...)</option>
+                        <option value="modbus_40001">40001-style docs</option>
+                    </select>
+                </div>
+
+                <div class="form-row">
+                    <label for="node-input-publishOnInput"><i class="fa fa-bolt"></i> Publish input</label>
+                    <input type="checkbox" id="node-input-publishOnInput" style="width:auto;">
+                </div>
+            </div>
+        </div>
+
+        <div class="scada-section">
+            <div class="scada-section-title"><i class="fa fa-table"></i> Register Map</div>
+            <p class="scada-section-note">Modul direct pastreaza harta manuala. Modul Aggregator genereaza harta pentru mesajele normalizate de nodul scada-aggregator.</p>
+
+            <div class="form-row">
+                <label for="node-input-mapMode"><i class="fa fa-sitemap"></i> Mod harta</label>
+                <select id="node-input-mapMode">
+                    <option value="direct">Direct (manual)</option>
+                    <option value="aggregator">Aggregator (generat)</option>
+                    <option value="aggregator_auto">Aggregator (auto-discovery)</option>
+                </select>
+            </div>
+
+            <div id="node-scada-auto-info" class="scada-validation" style="display:none; border-color:#b8d7c0; background:#f3fbf5; color:#26633a;">Conecteaza scada-aggregator. Acesta decide ce valori publica; scada-server aloca automat registre pentru datele primite. Dupa ce apar date, foloseste descarcarea JSON sau CSV pentru harta efectiv descoperita.</div>
+
+            <div class="scada-toolbar"><a href="#" class="button" id="node-scada-download-active-json"><i class="fa fa-download"></i> Registre active JSON</a><a href="#" class="button" id="node-scada-download-active-csv"><i class="fa fa-download"></i> Registre active CSV</a></div>
+
+            <div id="node-scada-aggregator-config" class="scada-section" style="display:none; margin-top:12px;">
+                <div class="scada-section-title"><i class="fa fa-object-group"></i> Aggregator map</div>
+                <p class="scada-section-note">Fiecare sursa ocupa 32 registre. Grupele sunt editabile si se folosesc identic in scada-aggregator; sunt generate si totalurile fiecarei grupe plus site.</p>
+                <div class="scada-grid">
+                    <div class="form-row"><label for="node-input-aggregatorPrefix">Prefix mesaj</label><input type="text" id="node-input-aggregatorPrefix" placeholder="payload.scada"></div>
+                    <div class="form-row"><label for="node-input-aggregatorVoltageProfile">Tensiuni</label><select id="node-input-aggregatorVoltageProfile"><option value="compact">Compact: U L-N/U L-L medie</option><option value="three_phase">Trifazat: L-N si L-L pe faze</option><option value="complete">Complet: faze si medii</option></select></div>
+                </div>
+                <div id="node-scada-aggregator-groups"></div>
+                <div class="form-row"><label for="node-input-aggregatorCategories">Categorii auto</label><textarea id="node-input-aggregatorCategories" rows="4" style="width:calc(100% - 150px); font-family:monospace;"></textarea></div>
+                <div class="scada-toolbar"><a href="#" class="button" id="node-scada-add-aggregator-group"><i class="fa fa-plus"></i> Adauga grupa</a><a href="#" class="button" id="node-scada-generate-aggregator-map"><i class="fa fa-magic"></i> Genereaza harta</a></div>
+            </div>
+
+            <div id="node-scada-direct-tools" class="scada-toolbar">
+                <select id="node-input-scada-preset">
+                    <option value="">Preset rapid</option>
+                    <option value="default">Default complet</option>
+                    <option value="grid">Doar grid</option>
+                    <option value="bess">Doar BESS</option>
+                    <option value="fronius_inverter">Fronius inverter</option>
+                    <option value="fronius_meter">Fronius Smart Meter</option>
+                    <option value="janitza">Janitza</option>
+                    <option value="carlo_gavazzi">Carlo Gavazzi</option>
+                </select>
+
+                <input type="text" id="node-input-metrics-filter" class="scada-filter" placeholder="Filtreaza dupa key, path sau label">
+
+                <div class="button-group">
+                    <a href="#" class="button" id="node-scada-add-metric"><i class="fa fa-plus"></i> Add row</a>
+                    <a href="#" class="button" id="node-scada-sort-metrics"><i class="fa fa-sort-numeric-asc"></i> Sort</a>
+                    <a href="#" class="button" id="node-scada-autopack-metrics"><i class="fa fa-magic"></i> Auto-pack</a>
+                    <a href="#" class="button" id="node-scada-toggle-advanced">Arata avansate</a>
+                    <a href="#" class="button" id="node-scada-import-map"><i class="fa fa-upload"></i> Import</a>
+                    <a href="#" class="button" id="node-scada-export-json"><i class="fa fa-download"></i> JSON</a>
+                    <a href="#" class="button" id="node-scada-export-csv"><i class="fa fa-download"></i> CSV</a>
+                    <a href="#" class="button" id="node-scada-reset-defaults"><i class="fa fa-repeat"></i> Reset</a>
+                    <input type="file" id="node-input-scada-import-file" accept=".json,.csv,application/json,text/csv">
+                </div>
+            </div>
+
+            <div class="scada-summary">
+                <div class="scada-pill">Metrici: <span id="node-scada-metric-count">0</span></div>
+                <div class="scada-pill">Registre ocupate: <span id="node-scada-register-count">0</span></div>
+            </div>
+
+            <div id="node-input-metrics-container"></div>
+            <div class="scada-validation" id="node-scada-validation"></div>
+        </div>
+
+    </div>
+
+</script>
+
+
+<script type="text/html" data-help-name="scada-server">
+
+    <p>
+        Nodul <b>scada-server</b> colecteaza valori din flow si le expune intr-un server Modbus TCP virtual read-only.
+    </p>
+
+    <h3>Editor</h3>
+    <ul>
+        <li>mod compact pentru configurari rapide</li>
+        <li>coloane pentru <code>type</code>, <code>scale</code>, <code>sign</code> si <code>unit</code></li>
+        <li>validare live pentru chei duplicate, path lipsa, conflicte de adrese si depasirea limitei 65535</li>
+        <li>preseturi rapide pentru <b>default</b>, <b>grid</b>, <b>BESS</b>, <b>Fronius</b>, <b>Janitza</b> si <b>Carlo Gavazzi</b></li>
+        <li>import/export harta registre in format JSON sau CSV</li>
+        <li>mod <b>Aggregator</b> care genereaza automat harta pentru grupe de surse si totaluri</li>
+    </ul>
+
+    <h3>Mod Aggregator</h3>
+    <p>Conecteaza iesirea nodului <b>scada-aggregator</b> la acest nod si alege <b>Mod harta: Aggregator</b>. Prefixul implicit este <code>payload.scada</code>.</p>
+    <ul>
+        <li>fiecare sursa are un bloc stabil de 32 registre: P, Q, tensiuni, frecventa, <code>online</code> si <code>age_s</code></li>
+        <li>profilul tensiunilor poate fi compact (medii L-N/L-L), trifazat (L1-N, L2-N, L3-N, L1-L2, L2-L3, L3-L1) sau complet</li>
+        <li>grupele implicite sunt <code>grid_meter</code>, <code>pv_inverter</code> si <code>bess</code>; le poti redenumi, modifica numarul de surse sau adauga grupe noi</li>
+        <li>totalurile fiecarei grupe si <code>site</code> sunt generate dupa blocurile surselor</li>
+        <li>in modul Aggregator harta este generata la deploy; nu edita manual randurile rezultate</li>
+    </ul>
+
+    <h3>Auto-discovery</h3>
+    <p>Cu <b>Mod hartă: Aggregator (auto-discovery)</b>, nu configurezi numărul de echipamente sau valorile publicate: acestea sunt stabilite în scada-aggregator. Fiecare sursă nouă primește următorul bloc liber de 32 registre. Folosește butoanele <b>Registre active JSON/CSV</b>, după deploy, pentru a descărca harta efectivă.</p>
+
+    <h3>Functii</h3>
+    <ul>
+        <li>colecteaza mesaje multiple si publica snapshot-uri atomice la un interval stabil sau imediat la fiecare input</li>
+        <li>expune Modbus TCP pentru telemetrie read-only și pentru blocul de comandă R/W, pe host și port configurabile</li>
+        <li>output 1 = stare server si snapshot curent, output 2 = diagnostic periodic (uptime, req/s, ultim client, contoare erori)</li>
+        <li>hardening: limita clienti simultani, inchidere socket-uri la redeploy, idle timeout per socket si rate-limit per IP</li>
+        <li>accepta tipuri <code>int16</code>, <code>uint16</code>, <code>int32</code>, <code>uint32</code> si <code>float32</code></li>
+        <li>pentru valori pe 32 biti poti alege <code>word order</code> si <code>byte order</code></li>
+        <li>citirile in afara hartii pot returna zero sau Modbus exception, in functie de setarea <b>Out of range</b></li>
+        <li>o configuratie invalida nu mai porneste serverul, ca sa evite suprapuneri de registre</li>
+        <li>bloc R/W SCADA la inceputul hărții automate, adresele 0–9; în harta directă/manuală, același bloc este la 128–137. Valorile sunt sincronizate bidirecțional cu variabilele globale cu aceleași nume.</li>
+    </ul>
+
+    <h3>Registre de control R/W</h3>
+    <p>La pornire, nodul creează cheile globale care lipsesc cu valoarea <code>0</code>; cheile existente își păstrează valoarea. Aceste registre apar în output-ul <code>scada-server/state</code> în <code>rw_registers</code>, <code>metrics</code> și <code>values_live</code>.</p>
+    <ul>
+        <li><code>0–1</code> / <code>128–129</code> — <code>scada_nominal_active_power</code>, <code>float32</code>, W. Domeniul de lucru este <code>0…P_nominal</code> al instalației.</li>
+        <li><code>2–3</code> / <code>130–131</code> — <code>scada_nominal_reactive_power</code>, <code>float32</code>, VAr semnat. Domeniul de lucru este <code>-Q_nominal…+Q_nominal</code>. Dacă un consumator din aval lucrează cu referință procentuală Q, acesta trebuie limitat la <code>-100…+100 %</code>.</li>
+        <li><code>4</code> / <code>132</code> — <code>scada_ramp_type</code>, <code>uint16</code>: <code>0</code> = fără rampă; cele trei moduri de rampă sunt <code>1</code> = timp fix (s), <code>2</code> = gradient procentual (%/s), <code>3</code> = gradient absolut (W/s pentru P, VAr/s pentru Q).</li>
+        <li><code>6–7</code> / <code>134–135</code> — <code>scada_ramp_up_value</code>, <code>float32</code>; <code>8–9</code> / <code>136–137</code> — <code>scada_ramp_down_value</code>, <code>float32</code>. Valorile sunt mărimi pozitive; direcția este dată de registrul Up/Down. Pentru tipul <code>2</code>, domeniul permis este <code>0…100 %/s</code>. Pentru tipul <code>1</code>, valoarea este durata în secunde (≥ 0); pentru tipul <code>3</code>, este gradientul absolut (≥ 0).</li>
+    </ul>
+    <p>Scrierile Modbus cu FC6 sau FC16 sunt permise exclusiv în acest bloc. O scriere acceptată actualizează variabilele globale și produce mesajul <code>scada-server/commands</code> pe ieșirea 1.</p>
+
+    <h3>Interoperabilitate adrese</h3>
+    <ul>
+        <li><code>0-based</code>: documentatia afiseaza adresele exact ca in request-ul Modbus (ex: 0, 2, 4)</li>
+        <li><code>40001-style docs</code>: documentatia afiseaza 40001+offset (ex: 40001, 40003, 40005), dar request-ul ramane tot 0-based</li>
+        <li>exemplu metrica <code>p</code> la adresa interna 0: in docs 0-based = <code>0</code>, in docs 40001-style = <code>40001</code></li>
+    </ul>
+
+    <h3>Referinta completa parametri</h3>
+    <ul>
+        <li><code>host</code>, <code>port</code>, <code>unitId</code>: interfata si identitatea serverului Modbus TCP virtual.</li>
+        <li><code>plantId</code>: identificatorul instalatiei inclus in diagnostic.</li>
+        <li><code>publishIntervalMs</code>: intervalul de publicare snapshot.</li>
+        <li><code>publishOnInput</code>: publica snapshot imediat la fiecare mesaj de intrare.</li>
+        <li><code>maxReadLogEntries</code>: cate citiri Modbus recente sunt pastrate in diagnostic.</li>
+        <li><code>maxConnections</code>: numarul maxim de clienti simultani.</li>
+        <li><code>socketIdleTimeoutMs</code>: inchide conexiunile inactive dupa acest timp.</li>
+        <li><code>rateLimitPerSecond</code>: limita de request-uri pe secunda per client.</li>
+        <li><code>diagIntervalMs</code>: intervalul iesirii de diagnostic.</li>
+        <li><code>outOfRangeMode</code>: zero sau Modbus exception pentru citiri in afara hartii.</li>
+        <li><code>addressingMode</code>: modul in care se afiseaza adresele in documentatie.</li>
+        <li><code>metrics</code>: harta completa de registre: key, path, address, type, scale, sign, word/byte order si unit.</li>
+        <li><code>scada-preset</code>: selectorul de preset rapid din editor.</li>
+        <li><code>metrics-filter</code>: filtrul text pentru randurile din harta de registre.</li>
+        <li><code>scada-import-file</code>: input-ul de fisier folosit la import JSON/CSV.</li>
+        <li><code>metrics-container</code>: zona editorului in care sunt randate randurile din <code>metrics</code>.</li>
+    </ul>
+
+    <h3>Exemplu metrica</h3>
+    <pre>{
+  "key": "grid_power_w",
+  "path": "payload.power_w",
+  "address": 0,
+  "type": "int32",
+  "scale": 1,
+  "unit": "W"
+}</pre>
+
+</script>