@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/scada-server/lib/register-map.js

@@ -0,0 +1,288 @@
+"use strict";
+
+
+const { encodeMetricDetailed, typeWordLength } = require("./encoding");
+
+const VALID_TYPES = ["int16", "uint16", "int32", "uint32", "float32"];
+const VALID_BYTE_ORDERS = ["big_endian", "little_endian"];
+const VALID_WORD_ORDERS = ["msw_first", "lsw_first"];
+const MAX_REGISTER_ADDRESS = 65535;
+
+
+function toMetricConfig(metric) {
+
+    const config = metric || {};
+
+    return {
+
+        key: String(config.key || "").trim(),
+
+        label: String(config.label || config.key || "").trim(),
+
+        address: Math.max(0, Number(config.address || 0)),
+
+        type: String(config.type || "int32").trim(),
+
+        scale: Number.isFinite(Number(config.scale)) ? Number(config.scale) : 1,
+
+        path: String(config.path || "").trim(),
+
+        unit: String(config.unit || "").trim(),
+
+        signMode: String(config.signMode || "as_is").trim(),
+
+        byteOrder: String(config.byteOrder || "big_endian").trim(),
+
+        wordOrder: String(config.wordOrder || "msw_first").trim()
+
+    };
+
+}
+
+
+function normalizeMetricConfigs(metrics) {
+
+    return (Array.isArray(metrics) ? metrics : []).map(toMetricConfig).filter(function (metric) {
+
+        return metric.key && metric.path;
+
+    });
+
+}
+
+
+function metricRegisterRange(metric) {
+
+    const start = Math.max(0, Number(metric.address || 0));
+
+    return {
+        start: start,
+        end: start + typeWordLength(metric.type) - 1
+    };
+
+}
+
+
+function registerSpan(metrics) {
+
+    return metrics.reduce(function (max, metric) {
+
+        return Math.max(max, metric.address + typeWordLength(metric.type));
+
+    }, 0);
+
+}
+
+
+function buildRegisterImage(metrics, values, onIssue) {
+
+    const size = Math.max(registerSpan(metrics), 1);
+
+    const registers = new Uint16Array(size);
+
+
+    metrics.forEach(function (metric) {
+
+        const encoded = encodeMetricDetailed(values[metric.key], metric.type, metric.scale, {
+            byteOrder: metric.byteOrder,
+            wordOrder: metric.wordOrder
+        });
+        const words = encoded.words;
+
+        if (encoded.issues.length && typeof onIssue === "function") {
+            encoded.issues.forEach(function (issue) {
+                onIssue(Object.assign({
+                    key: metric.key,
+                    address: metric.address
+                }, issue));
+            });
+        }
+
+        for (let index = 0; index < words.length; index += 1) {
+
+            const address = metric.address + index;
+
+            if (address >= 0 && address < registers.length) {
+
+                registers[address] = words[index];
+
+            }
+
+        }
+
+    });
+
+
+    return registers;
+
+}
+
+
+function normalizeMetricValue(metric, value) {
+
+    const numeric = Number(value);
+
+    if (!Number.isFinite(numeric)) {
+
+        return null;
+
+    }
+
+
+    if (metric.signMode === "invert") {
+
+        return -numeric;
+
+    }
+
+
+    return numeric;
+
+}
+
+
+function validateMetricConfigs(metrics) {
+
+    const list = Array.isArray(metrics) ? metrics : [];
+    const issues = [];
+    const seenKeys = new Set();
+    const ranges = [];
+
+    if (!list.length) {
+
+        issues.push({
+            code: "empty",
+            message: "Configuratia SCADA trebuie sa contina cel putin un registru."
+        });
+
+        return issues;
+
+    }
+
+
+    list.forEach(function (metric, index) {
+
+        const rowLabel = "Randul " + (index + 1);
+
+        if (!metric.key) {
+
+            issues.push({ code: "missing_key", message: rowLabel + ": cheia registrului este obligatorie." });
+
+        } else if (seenKeys.has(metric.key)) {
+
+            issues.push({ code: "duplicate_key", message: rowLabel + ": cheia \"" + metric.key + "\" este duplicata." });
+
+        } else {
+
+            seenKeys.add(metric.key);
+
+        }
+
+
+        if (!metric.path) {
+
+            issues.push({ code: "missing_path", message: rowLabel + ": calea mesajului este obligatorie." });
+
+        }
+
+
+        if (!VALID_TYPES.includes(metric.type)) {
+
+            issues.push({ code: "invalid_type", message: rowLabel + ": tipul \"" + metric.type + "\" nu este suportat." });
+
+        }
+
+
+        if (!VALID_BYTE_ORDERS.includes(metric.byteOrder)) {
+
+            issues.push({ code: "invalid_byte_order", message: rowLabel + ": byte order \"" + metric.byteOrder + "\" nu este suportat." });
+
+        }
+
+
+        if (!VALID_WORD_ORDERS.includes(metric.wordOrder)) {
+
+            issues.push({ code: "invalid_word_order", message: rowLabel + ": word order \"" + metric.wordOrder + "\" nu este suportat." });
+
+        }
+
+
+        if (!Number.isFinite(Number(metric.scale)) || Number(metric.scale) === 0) {
+
+            issues.push({ code: "invalid_scale", message: rowLabel + ": scale trebuie sa fie un numar diferit de 0." });
+
+        }
+
+
+        if (!Number.isFinite(Number(metric.address)) || Number(metric.address) < 0) {
+
+            issues.push({ code: "invalid_address", message: rowLabel + ": adresa trebuie sa fie un numar >= 0." });
+            return;
+
+        }
+
+
+        const range = metricRegisterRange(metric);
+
+        if (range.end > MAX_REGISTER_ADDRESS) {
+
+            issues.push({
+                code: "address_out_of_range",
+                message: rowLabel + ": registrul depaseste limita Modbus " + MAX_REGISTER_ADDRESS + " (end=" + range.end + ")."
+            });
+
+        }
+
+        ranges.push({
+            key: metric.key || ("row_" + index),
+            start: range.start,
+            end: range.end
+        });
+
+    });
+
+
+    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) {
+
+            issues.push({
+                code: "overlap",
+                message: "Registrele \"" + previous.key + "\" si \"" + current.key + "\" se suprapun intre adresele " + current.start + " si " + previous.end + "."
+            });
+
+        }
+
+    }
+
+
+    return issues;
+
+}
+
+
+module.exports = {
+
+    buildRegisterImage,
+
+    normalizeMetricValue,
+
+    normalizeMetricConfigs,
+
+    registerSpan,
+
+    validateMetricConfigs,
+
+    MAX_REGISTER_ADDRESS
+
+};