@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/scada-server/scada-server.js

@@ -0,0 +1,704 @@
+module.exports = function (RED) {
+
+    "use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+
+    const { getByPath } = require("./lib/object-path");
+    const { buildRegisterImage, normalizeMetricConfigs, normalizeMetricValue, validateMetricConfigs } = require("./lib/register-map");
+    const { buildAggregatorMetrics, SIGNALS, VOLTAGE_PROFILES, normalizeProfile } = require("./lib/aggregator-map");
+    const { createModbusServer } = require("./lib/modbus-server");
+
+    const BIND_HOST = "0.0.0.0";
+    const COMMAND_BASE = 128;
+    const COMMAND_DEFS = [
+        { key: "scada_nominal_active_power", address: 128, type: "float32" },
+        { key: "scada_nominal_reactive_power", address: 130, type: "float32" },
+        { key: "scada_ramp_type", address: 132, type: "uint16" },
+        { key: "scada_ramp_up_value", address: 134, type: "float32" },
+        { key: "scada_ramp_down_value", address: 136, type: "float32" }
+    ];
+    const COMMAND_KEYS = COMMAND_DEFS.map(function (definition) { return definition.key; });
+    const runtimeStates = new Map();
+    const DEFAULT_AUTO_CATEGORIES = [
+        { 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 }
+    ];
+
+    function autoCategories(config) {
+        let value;
+        try { value = typeof config.aggregatorCategories === "string" ? JSON.parse(config.aggregatorCategories) : config.aggregatorCategories; } catch (_) { value = null; }
+        const source = Array.isArray(value) && value.length ? value : DEFAULT_AUTO_CATEGORIES;
+        return source.map(function (category, index) {
+            const id = String(category.id || ("category_" + index)).toLowerCase().replace(/[^a-z0-9_]+/g, "_") || ("category_" + index);
+            const base = Math.max(0, Math.round(Number(category.base) || 0));
+            const slots = Math.max(2, Math.min(1024, Math.round(Number(category.slots) || 16)));
+            return { id: id, label: String(category.label || id), base: base, slots: slots };
+        });
+    }
+
+
+    function defaultMetrics() {
+
+        return [
+
+            { key: "p", label: "P", address: 0, type: "int32", scale: 1, path: "payload.active_power_w", unit: "W", signMode: "as_is" },
+            { key: "q", label: "Q", address: 2, type: "int32", scale: 1, path: "payload.reactive_power_var", unit: "VAr", signMode: "as_is" },
+            { key: "f", label: "F", address: 4, type: "uint32", scale: 100, path: "payload.frequency_hz", unit: "Hz" },
+            { key: "u12", label: "U12", address: 6, type: "uint32", scale: 10, path: "payload.voltage_l1_l2_v", unit: "V" },
+            { key: "u23", label: "U23", address: 8, type: "uint32", scale: 10, path: "payload.voltage_l2_l3_v", unit: "V" },
+            { key: "u13", label: "U13", address: 10, type: "uint32", scale: 10, path: "payload.voltage_l1_l3_v", unit: "V" },
+            { key: "cef_pos", label: "CEF", address: 12, type: "uint16", scale: 1, path: "payload.cef_breaker_position", unit: "" },
+            { key: "bess_soc", label: "SOC", address: 13, type: "uint16", scale: 10, path: "payload.bess_soc_pct", unit: "%" },
+            { key: "bess_p", label: "BP", address: 14, type: "int32", scale: 1, path: "payload.bess_power_w", unit: "W", signMode: "as_is" },
+            { key: "bess_ext", label: "BEX", address: 16, type: "uint16", scale: 1, path: "payload.bess_external_control", unit: "" }
+
+        ];
+
+    }
+
+
+    function toIntInRange(value, fallback, min, max) {
+
+        const numeric = Number(value);
+
+        if (!Number.isFinite(numeric)) {
+            return fallback;
+        }
+
+        return Math.min(max, Math.max(min, Math.round(numeric)));
+
+    }
+
+
+    function cleanHost(value) {
+
+        const host = String(value || "").trim();
+
+        return host || BIND_HOST;
+
+    }
+
+
+    function buildAddressingInfo(addressingMode) {
+
+        const normalized = addressingMode === "modbus_40001" ? "modbus_40001" : "zero_based";
+        const offset = normalized === "modbus_40001" ? 40001 : 0;
+
+        return {
+            mode: normalized,
+            docs_offset: offset,
+            hint: normalized === "modbus_40001"
+                ? "Documentatia afiseaza adrese 40001+, protocolul Modbus TCP foloseste offset 0 in request."
+                : "Documentatia foloseste aceleasi adrese ca request-ul Modbus TCP (offset 0)."
+        };
+
+    }
+
+
+    function ScadaServerNode(config) {
+
+        RED.nodes.createNode(this, config);
+
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+
+        node.name = "SCADA Server";
+        node.host = cleanHost(config.host || BIND_HOST);
+        node.port = toIntInRange(config.port, 1502, 1, 65535);
+        node.unitId = toIntInRange(config.unitId, 1, 0, 255);
+        node.plantId = String(config.plantId || "").trim();
+        node.publishIntervalMs = toIntInRange(config.publishIntervalMs, 500, 100, 60000);
+        node.publishOnInput = !!config.publishOnInput;
+        node.maxReadLogEntries = toIntInRange(config.maxReadLogEntries, 100, 10, 2000);
+        node.maxConnections = toIntInRange(config.maxConnections, 20, 1, 2000);
+        node.socketIdleTimeoutMs = toIntInRange(config.socketIdleTimeoutMs, 30000, 500, 3600000);
+        node.rateLimitPerSecond = toIntInRange(config.rateLimitPerSecond, 0, 0, 10000);
+        node.diagIntervalMs = toIntInRange(config.diagIntervalMs, 2000, 500, 60000);
+        node.outOfRangeMode = config.outOfRangeMode === "exception" ? "exception" : "zeros";
+        node.addressingMode = String(config.addressingMode || "zero_based").trim();
+        node.addressingInfo = buildAddressingInfo(node.addressingMode);
+        node.mapMode = config.mapMode === "aggregator_auto" ? "aggregator_auto" : (config.mapMode === "aggregator" ? "aggregator" : "direct");
+        node.commandBase = node.mapMode === "aggregator_auto" ? 0 : COMMAND_BASE;
+        node.aggregatorPrefix = String(config.aggregatorPrefix || "payload.scada").trim().replace(/\.+$/, "") || "payload.scada";
+        node.aggregatorVoltageProfile = normalizeProfile(config.aggregatorVoltageProfile);
+        const savedAutoMetrics = node.mapMode === "aggregator_auto" && node.context ? node.context().get("scadaAutoMetrics") : null;
+
+        node.metrics = normalizeMetricConfigs(node.mapMode === "aggregator_auto" ? (Array.isArray(savedAutoMetrics) ? savedAutoMetrics : []) : (node.mapMode === "aggregator"
+            ? buildAggregatorMetrics(config)
+            : (config.metrics && config.metrics.length ? config.metrics : defaultMetrics())));
+        node.validationIssues = validateMetricConfigs(node.metrics);
+        if (node.mapMode === "aggregator_auto" && !node.metrics.length) node.validationIssues = [];
+
+        let liveValues = {};
+        let pendingValues = {};
+        let registerImage = new Uint16Array(1);
+        let lastUpdateTs = null;
+        let lastPublishTs = null;
+        let clientCount = 0;
+        let readLog = [];
+        let publishTimer = null;
+        let diagnosticsTimer = null;
+        let startedAtMs = Date.now();
+        let lastClientConnected = null;
+        let lastClientDisconnected = null;
+        let lastRead = null;
+        let lastEncodingIssues = [];
+        let autoCategoryList = node.mapMode === "aggregator_auto" ? (node.context().get("scadaAutoCategories") || autoCategories(config)) : [];
+        let autoSlots = node.mapMode === "aggregator_auto" ? (node.context().get("scadaAutoSlots") || []) : [];
+        const readTimelineMs = [];
+        const protocolIssues = {};
+        const nodeContext = node.context();
+        const globalContext = nodeContext && nodeContext.global && typeof nodeContext.global.get === "function"
+            ? nodeContext.global
+            : (nodeContext && typeof nodeContext.global === "function" ? nodeContext.global() : null);
+        let commandWords = new Uint16Array(10);
+
+        function commandValue(key) { const value = Number(globalContext && globalContext.get ? globalContext.get(key) : 0); return Number.isFinite(value) ? value : 0; }
+        function setCommandValue(key, value) { if (globalContext && globalContext.set) globalContext.set(key, value); }
+        function initializeCommandGlobals() {
+            if (!globalContext || typeof globalContext.get !== "function" || typeof globalContext.set !== "function") {
+                node.warn("scada-server: contextul global Node-RED nu este disponibil; registrele R/W folosesc valoarea temporară 0.");
+                return;
+            }
+            COMMAND_KEYS.forEach(function (key) {
+                if (typeof globalContext.get(key) === "undefined") globalContext.set(key, 0);
+            });
+        }
+        function writeFloat(words, offset, value) { const buffer = Buffer.allocUnsafe(4); buffer.writeFloatBE(value, 0); words[offset] = buffer.readUInt16BE(0); words[offset + 1] = buffer.readUInt16BE(2); }
+        function readFloat(words, offset) { const buffer = Buffer.allocUnsafe(4); buffer.writeUInt16BE(words[offset], 0); buffer.writeUInt16BE(words[offset + 1], 2); return buffer.readFloatBE(0); }
+        function syncCommandRegisters() {
+            const next = new Uint16Array(10);
+            writeFloat(next, 0, commandValue("scada_nominal_active_power")); writeFloat(next, 2, commandValue("scada_nominal_reactive_power"));
+            next[4] = Math.max(0, Math.min(65535, Math.round(commandValue("scada_ramp_type"))));
+            writeFloat(next, 6, commandValue("scada_ramp_up_value")); writeFloat(next, 8, commandValue("scada_ramp_down_value"));
+            commandWords = next;
+        }
+        function applyCommandWrite() {
+            setCommandValue("scada_nominal_active_power", readFloat(commandWords, 0)); setCommandValue("scada_nominal_reactive_power", readFloat(commandWords, 2));
+            setCommandValue("scada_ramp_type", commandWords[4]); setCommandValue("scada_ramp_up_value", readFloat(commandWords, 6)); setCommandValue("scada_ramp_down_value", readFloat(commandWords, 8));
+            syncCommandRegisters(); registerImage = rebuildRegisterImage();
+            node.send([{ topic: "scada-server/commands", payload: { scada_nominal_active_power: commandValue("scada_nominal_active_power"), scada_nominal_reactive_power: commandValue("scada_nominal_reactive_power"), scada_ramp_type: commandValue("scada_ramp_type"), scada_ramp_up_value: commandValue("scada_ramp_up_value"), scada_ramp_down_value: commandValue("scada_ramp_down_value") } }, null]);
+        }
+
+        function incrementIssueCounter(code) {
+            const key = String(code || "unknown");
+            protocolIssues[key] = (protocolIssues[key] || 0) + 1;
+        }
+
+        function rebuildRegisterImage() {
+            const issues = [];
+            const image = buildRegisterImage(node.metrics, liveValues, function (issue) {
+                issues.push(issue);
+                incrementIssueCounter(issue.code);
+            });
+            lastEncodingIssues = issues.slice(-50);
+            const result = image.length >= (node.commandBase + commandWords.length) ? image : new Uint16Array(node.commandBase + commandWords.length);
+            if (result !== image) result.set(image);
+            result.set(commandWords, node.commandBase);
+            return result;
+        }
+
+        initializeCommandGlobals();
+        syncCommandRegisters();
+        registerImage = rebuildRegisterImage();
+
+        function trimReadTimeline(nowMs) {
+            while (readTimelineMs.length && (nowMs - readTimelineMs[0]) > 1000) {
+                readTimelineMs.shift();
+            }
+        }
+
+        function reqPerSecond() {
+            const now = Date.now();
+            trimReadTimeline(now);
+            return Number((readTimelineMs.length).toFixed(1));
+        }
+
+        function appendReadLog(entry) {
+
+            readLog.unshift(entry);
+            if (readLog.length > node.maxReadLogEntries) {
+                readLog = readLog.slice(0, node.maxReadLogEntries);
+            }
+
+        }
+
+        function buildDiagnosticsPayload(reason) {
+
+            return {
+                status: node.validationIssues.length ? "invalid_configuration" : "ok",
+                reason: reason || "snapshot",
+                uptime_ms: Math.max(0, Date.now() - startedAtMs),
+                plant_id: node.plantId || null,
+                bind_host: node.host,
+                port: node.port,
+                unit_id: node.unitId,
+                clients: clientCount,
+                req_per_sec: reqPerSecond(),
+                last_read: lastRead,
+                last_client_connected: lastClientConnected,
+                last_client_disconnected: lastClientDisconnected,
+                protocol_issue_counters: Object.assign({}, protocolIssues),
+                hardening: {
+                    max_connections: node.maxConnections,
+                    socket_idle_timeout_ms: node.socketIdleTimeoutMs,
+                    rate_limit_per_sec: node.rateLimitPerSecond,
+                    out_of_range_mode: node.outOfRangeMode,
+                    publish_on_input: node.publishOnInput
+                },
+                addressing: node.addressingInfo,
+                read_log_size: readLog.length,
+                metrics_count: COMMAND_DEFS.length + node.metrics.length,
+                map_mode: node.mapMode,
+                register_count: registerImage.length,
+                encoding_issues: lastEncodingIssues,
+                issues: node.validationIssues
+            };
+
+        }
+
+        function diagnosticsMessage(reason) {
+            return {
+                topic: "scada-server/diagnostics",
+                payload: buildDiagnosticsPayload(reason)
+            };
+        }
+
+        function commandValues() {
+            return COMMAND_KEYS.reduce(function (values, key) {
+                values[key] = commandValue(key);
+                return values;
+            }, {});
+        }
+
+        function commandRegisters() {
+            return COMMAND_DEFS.map(function (definition) {
+                return {
+                    key: definition.key,
+                    label: "SCADA command · " + definition.key,
+                    address: node.commandBase + (definition.address - COMMAND_BASE),
+                    type: definition.type,
+                    scale: 1,
+                    path: "global." + definition.key,
+                    unit: "",
+                    value: commandValue(definition.key),
+                    active: true,
+                    access: "R/W",
+                    last_update_ts: null,
+                    last_publish_ts: lastPublishTs
+                };
+            });
+        }
+
+        function refreshStatus() {
+
+            if (node.validationIssues.length) {
+
+                node.status({
+                    fill: "red",
+                    shape: "ring",
+                    text: "config invalida | " + node.validationIssues.length + " probleme"
+                });
+
+                return;
+
+            }
+
+            const rps = reqPerSecond();
+            const lastReadText = lastRead ? (lastRead.startAddress + "/" + lastRead.quantity) : "-";
+
+            node.status({
+                fill: "green",
+                shape: "dot",
+                text: "p " + node.port + " | c " + clientCount + " | rps " + rps + " | last " + lastReadText
+            });
+
+        }
+
+        function commitSnapshot(force) {
+
+            const pendingKeys = Object.keys(pendingValues);
+            const changed = force || pendingKeys.length > 0;
+
+            syncCommandRegisters();
+            registerImage = rebuildRegisterImage();
+            if (!changed) {
+                return false;
+            }
+
+            liveValues = Object.assign({}, liveValues, pendingValues);
+            pendingValues = {};
+            lastPublishTs = Date.now();
+            registerImage = rebuildRegisterImage();
+            refreshStatus();
+            return true;
+
+        }
+
+        function updateRegistersFromMessage(msg) {
+
+            let changed = false;
+
+            node.metrics.forEach(function (metric) {
+
+                const rawValue = getByPath(msg, metric.path);
+                const nextValue = rawValue === null || rawValue === undefined ? NaN : Number(rawValue);
+
+                if (Number.isFinite(nextValue)) {
+                    pendingValues[metric.key] = normalizeMetricValue(metric, nextValue);
+                    changed = true;
+                }
+
+            });
+
+            if (changed) {
+                lastUpdateTs = Date.now();
+            }
+
+            return changed;
+
+        }
+
+        function rebuildAutoMetrics(signals) {
+            const metrics = [];
+            const addBlock = function (category, source, slot, total) {
+                const base = total ? category.base : category.base + (slot * 32);
+                const prefix = total ? "total_" + category.id : category.id + "_" + source;
+                const path = total ? node.aggregatorPrefix + ".totals." + category.id : node.aggregatorPrefix + "." + category.id + "." + source;
+                signals.forEach(function (signal, index) { const info = SIGNALS[signal]; metrics.push({ key: prefix + "_" + signal, label: (total ? "Total " : "") + category.label + " " + (source || "") + " " + info.label, address: base + (index * 2), type: "float32", scale: 1, path: path + "." + signal, unit: info.unit, signMode: "as_is", byteOrder: "big_endian", wordOrder: "msw_first" }); });
+                metrics.push({ key: prefix + "_" + (total ? "active" : "online"), label: prefix + " " + (total ? "active" : "online"), address: base + 28, type: "uint16", scale: 1, path: path + "." + (total ? "active" : "online"), unit: "", signMode: "as_is", byteOrder: "big_endian", wordOrder: "msw_first" });
+                if (!total) metrics.push({ key: prefix + "_age_s", label: prefix + " age", address: base + 29, type: "uint16", scale: 1, path: path + ".age_s", unit: "s", signMode: "as_is", byteOrder: "big_endian", wordOrder: "msw_first" });
+            };
+            const addSiteSummary = function () {
+                ["grid", "pv"].forEach(function (reference, referenceIndex) {
+                    signals.forEach(function (signal, signalIndex) {
+                        const info = SIGNALS[signal];
+                        metrics.push({ key: "site_" + reference + "_" + signal, label: "Site " + reference.toUpperCase() + " " + info.label, address: 64 + (referenceIndex * 24) + (signalIndex * 2), type: "float32", scale: 1, path: node.aggregatorPrefix + ".totals.site." + reference + "." + signal, unit: info.unit, signMode: "as_is", byteOrder: "big_endian", wordOrder: "msw_first" });
+                    });
+                    metrics.push({ key: "site_" + reference + "_active", label: "Site " + reference.toUpperCase() + " active", address: 124 + referenceIndex, type: "uint16", scale: 1, path: node.aggregatorPrefix + ".totals.site." + reference + ".active", unit: "", signMode: "as_is", byteOrder: "big_endian", wordOrder: "msw_first" });
+                });
+            };
+            addSiteSummary();
+            autoCategoryList.forEach(function (category) { addBlock(category, "", 0, true); });
+            autoSlots.forEach(function (item) { const category = autoCategoryList.find(function (value) { return value.id === item.category; }); if (category) addBlock(category, item.source, item.slot, false); });
+            node.metrics = normalizeMetricConfigs(metrics);
+            node.validationIssues = validateMetricConfigs(node.metrics);
+            node.context().set("scadaAutoMetrics", node.metrics);
+            node.context().set("scadaAutoSlots", autoSlots);
+            node.context().set("scadaAutoCategories", autoCategoryList);
+        }
+
+        if (node.mapMode === "aggregator_auto" && autoSlots.length) {
+            rebuildAutoMetrics(["p", "q"].concat(VOLTAGE_PROFILES[node.aggregatorVoltageProfile], ["f"]));
+        }
+
+        function discoverAggregatorSources(msg) {
+            if (node.mapMode !== "aggregator_auto") return false;
+            const parts = node.aggregatorPrefix.split(".");
+            let root = msg;
+            parts.forEach(function (part) { root = root == null ? undefined : root[part]; });
+            if (!root || typeof root !== "object") return false;
+            const signals = ["p", "q"].concat(VOLTAGE_PROFILES[node.aggregatorVoltageProfile], ["f"]);
+            let changed = false;
+            Object.keys(root).filter(function (group) { return group !== "totals"; }).forEach(function (group) {
+                const sources = root[group];
+                if (!sources || typeof sources !== "object") return;
+                Object.keys(sources).forEach(function (source) {
+                    if (!sources[source] || typeof sources[source] !== "object") return;
+                    const key = group + "." + source;
+                    if (autoSlots.some(function (item) { return item.key === key; })) return;
+                    let category = autoCategoryList.find(function (item) { return item.id === group; });
+                    if (!category) {
+                        const nextBase = Math.ceil(autoCategoryList.reduce(function (max, item) { return Math.max(max, item.base + (item.slots * 32)); }, 3328) / 512) * 512;
+                        category = { id: group, label: group, base: nextBase, slots: 16 };
+                        autoCategoryList.push(category);
+                    }
+                    const used = new Set(autoSlots.filter(function (item) { return item.category === category.id; }).map(function (item) { return item.slot; }));
+                    let slot = 1;
+                    while (used.has(slot) && slot < category.slots) slot += 1;
+                    if (slot >= category.slots) { node.warn("scada-server: categoria " + category.id + " este plina"); return; }
+                    autoSlots.push({ key: key, group: group, source: source, category: category.id, slot: slot });
+                    changed = true;
+                });
+            });
+            if (changed) rebuildAutoMetrics(signals);
+            return changed;
+        }
+
+        function buildStatePayload(changed) {
+
+            return {
+                status: "ok",
+                plant_id: node.plantId || null,
+                host: node.host,
+                port: node.port,
+                unit_id: node.unitId,
+                clients: clientCount,
+                req_per_sec: reqPerSecond(),
+                last_read: lastRead,
+                updated: changed,
+                last_update_ts: lastUpdateTs,
+                last_publish_ts: lastPublishTs,
+                uptime_ms: Math.max(0, Date.now() - startedAtMs),
+                values_live: Object.assign({}, commandValues(), liveValues),
+                values_pending: Object.assign({}, pendingValues),
+                rw_registers: commandRegisters(),
+                metrics: commandRegisters().concat(node.metrics),
+                issues: node.validationIssues,
+                read_log: readLog,
+                diagnostics: {
+                    last_client_connected: lastClientConnected,
+                    last_client_disconnected: lastClientDisconnected,
+                    protocol_issue_counters: Object.assign({}, protocolIssues)
+                },
+                hardening: {
+                    max_connections: node.maxConnections,
+                    socket_idle_timeout_ms: node.socketIdleTimeoutMs,
+                    rate_limit_per_sec: node.rateLimitPerSecond,
+                    out_of_range_mode: node.outOfRangeMode,
+                    publish_on_input: node.publishOnInput
+                },
+                encoding_issues: lastEncodingIssues,
+                addressing: node.addressingInfo
+            };
+
+        }
+
+        function buildRegisterExport(activeOnly) {
+            const hasValue = function (key) { return Object.prototype.hasOwnProperty.call(liveValues, key); };
+            const commandRows = commandRegisters();
+            const rows = commandRows.concat(node.metrics.filter(function (metric) { return !activeOnly || hasValue(metric.key); }).map(function (metric) {
+                return {
+                    key: metric.key,
+                    label: metric.label,
+                    address: metric.address,
+                    type: metric.type,
+                    scale: metric.scale,
+                    path: metric.path,
+                    unit: metric.unit,
+                    value: hasValue(metric.key) ? liveValues[metric.key] : null,
+                    active: hasValue(metric.key), access: "R",
+                    last_update_ts: lastUpdateTs,
+                    last_publish_ts: lastPublishTs
+                };
+            }));
+            return { node_id: node.id, generated_at: new Date().toISOString(), active_only: !!activeOnly, map_mode: node.mapMode, rows: rows };
+        }
+
+        node.getRegisterExport = buildRegisterExport;
+        runtimeStates.set(node.id, node);
+
+        function emitDiagnostics(reason) {
+            node.send([null, diagnosticsMessage(reason)]);
+        }
+
+        const server = createModbusServer({
+
+            host: node.host,
+            port: node.port,
+            unitId: node.unitId,
+            maxConnections: node.maxConnections,
+            socketIdleTimeoutMs: node.socketIdleTimeoutMs,
+            rateLimitPerSecond: node.rateLimitPerSecond,
+
+            readHoldingRegisters: function (startAddress, quantity) {
+
+                const result = [];
+                const endAddress = startAddress + quantity - 1;
+
+                if (startAddress < 0 || endAddress >= registerImage.length) {
+                    if (node.outOfRangeMode === "exception") {
+                        return {
+                            exceptionCode: 2,
+                            issueCode: "read_out_of_range"
+                        };
+                    }
+                    incrementIssueCounter("read_out_of_range");
+                }
+
+                for (let offset = 0; offset < quantity; offset += 1) {
+                    const address = startAddress + offset;
+                    result.push(address >= 0 && address < registerImage.length ? registerImage[address] : 0);
+                }
+
+                return result;
+
+            },
+
+            writeSingleRegister: function (address, value) {
+                return this.writeHoldingRegisters(address, [value]);
+            },
+
+            writeHoldingRegisters: function (startAddress, values) {
+                const endAddress = startAddress + values.length - 1;
+                if (startAddress < node.commandBase || endAddress >= (node.commandBase + commandWords.length)) return { exceptionCode: 2, issueCode: "write_read_only" };
+                values.forEach(function (value, index) { commandWords[startAddress - node.commandBase + index] = value & 0xFFFF; });
+                applyCommandWrite();
+                return null;
+            },
+
+            onClientChange: function (nextCount) {
+                clientCount = nextCount;
+                refreshStatus();
+            },
+
+            onClientConnected: function (entry) {
+                lastClientConnected = entry;
+                refreshStatus();
+            },
+
+            onClientDisconnected: function (entry) {
+                lastClientDisconnected = entry;
+                refreshStatus();
+            },
+
+            onRead: function (entry) {
+                lastRead = entry;
+                readTimelineMs.push(entry.timestampMs || Date.now());
+                trimReadTimeline(Date.now());
+                appendReadLog(entry);
+                refreshStatus();
+            },
+
+            onProtocolIssue: function (issue) {
+                incrementIssueCounter(issue.code);
+            },
+
+            onError: function (err) {
+                incrementIssueCounter("server_error");
+                node.error(err.message);
+                node.status({ fill: "red", shape: "ring", text: "server error" });
+            }
+
+        });
+
+
+        if (node.validationIssues.length) {
+
+            node.error("scada-server: configuratie invalida: " + node.validationIssues.map(function (issue) {
+                return issue.message;
+            }).join(" | "));
+
+            refreshStatus();
+
+        } else {
+
+            server.start().then(function () {
+
+                startedAtMs = Date.now();
+
+                publishTimer = setInterval(function () {
+                    commitSnapshot(false);
+                }, node.publishIntervalMs);
+
+                diagnosticsTimer = setInterval(function () {
+                    emitDiagnostics("interval");
+                }, node.diagIntervalMs);
+
+                refreshStatus();
+
+            }).catch(function (err) {
+
+                incrementIssueCounter("bind_error");
+                node.error(err.message);
+                node.status({ fill: "red", shape: "ring", text: "bind error" });
+
+            });
+
+        }
+
+
+        node.on("input", function (msg, send, done) {
+
+            try {
+
+                if (node.validationIssues.length) {
+
+                    send([
+                        {
+                            topic: "scada-server/state",
+                            payload: {
+                                status: "invalid_configuration",
+                                issues: node.validationIssues
+                            }
+                        },
+                        diagnosticsMessage("invalid_configuration")
+                    ]);
+
+                    done(new Error("scada-server: configuratie invalida"));
+                    return;
+
+                }
+
+                discoverAggregatorSources(msg);
+                const changed = updateRegistersFromMessage(msg);
+
+                if (
+                    (node.publishOnInput && changed) ||
+                    (msg && (msg.scadaFlush === true || (msg.payload && msg.payload.scada_flush === true)))
+                ) {
+                    commitSnapshot(true);
+                }
+
+                send([
+                    {
+                        topic: "scada-server/state",
+                        payload: buildStatePayload(changed)
+                    },
+                    diagnosticsMessage("input")
+                ]);
+
+                done();
+
+            } catch (err) {
+
+                incrementIssueCounter("input_error");
+                node.status({ fill: "red", shape: "ring", text: err.message });
+                done(err);
+
+            }
+
+        });
+
+
+        node.on("close", function (done) {
+
+            if (publishTimer) {
+                clearInterval(publishTimer);
+                publishTimer = null;
+            }
+
+            if (diagnosticsTimer) {
+                clearInterval(diagnosticsTimer);
+                diagnosticsTimer = null;
+            }
+
+            server.stop().finally(done);
+            runtimeStates.delete(node.id);
+
+        });
+
+    
+        });
+    }
+
+
+    if (RED.httpAdmin && typeof RED.httpAdmin.get === "function") {
+        RED.httpAdmin.get("/scada-server/register-map/:id", function (req, res) {
+            const node = runtimeStates.get(req.params.id);
+            if (!node || typeof node.getRegisterExport !== "function") {
+                res.status(404).json({ ok: false, error: "SCADA server runtime indisponibil" });
+                return;
+            }
+            const activeOnly = String(req.query && req.query.activeOnly || "").toLowerCase() !== "false";
+            res.json(Object.assign({ ok: true }, node.getRegisterExport(activeOnly)));
+        });
+    }
+
+    RED.nodes.registerType("scada-server", ScadaServerNode);
+
+};