@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/advantech-read/advantech-read.js

@@ -0,0 +1,449 @@
+module.exports = function (RED) {
+    "use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+    const ModbusRTU = require("modbus-serial");
+    const {
+        profileForModel,
+        normalizeModel
+    } = require("../lib/adam-6000-profiles");
+
+    function toInt(value, fallback) {
+        const n = Math.round(Number(value));
+        return Number.isFinite(n) ? n : fallback;
+    }
+
+    function toNonNegativeInt(value, fallback) {
+        const n = toInt(value, fallback);
+        return n >= 0 ? n : fallback;
+    }
+
+    function toPositiveInt(value, fallback) {
+        const n = toInt(value, fallback);
+        return n > 0 ? n : fallback;
+    }
+
+    function toFinite(value, fallback) {
+        const n = Number(value);
+        return Number.isFinite(n) ? n : fallback;
+    }
+
+    function toPollInterval(value, fallback) {
+        if (String(value || "").trim().toLowerCase() === "off") return 0;
+        const n = toInt(value, fallback);
+        return n > 0 ? n : 0;
+    }
+
+    function manualAddressToOffset(address, area) {
+        const n = toInt(address, 0);
+        if (area === "holding" && n >= 40001) return n - 40001;
+        if (area === "input" && n >= 30001) return n - 30001;
+        if (area === "coil" && n >= 1) return n - 1;
+        return Math.max(0, n);
+    }
+
+    function resolveAddress(address, area, addressMode) {
+        if (addressMode === "zero") {
+            return Math.max(0, toInt(address, 0));
+        }
+        return manualAddressToOffset(address, area);
+    }
+
+    function boolArray(values, count) {
+        const result = [];
+        for (let i = 0; i < count; i += 1) {
+            result.push(!!values[i]);
+        }
+        return result;
+    }
+
+    function buildChannelMessages(node, payload, triggerMsg, kind) {
+        const key = ["di", "do", "ai", "ao"].includes(kind) ? kind : "di";
+        const startKey = key + "_start";
+        const values = Array.isArray(payload[key]) ? payload[key] : [];
+        return values.map(function (value, index) {
+            const channel = index + 1;
+            return {
+                topic: (node.name || node.host || "advantech-read") + "/" + key + "/" + channel,
+                payload: key === "di" || key === "do" ? !!value : value,
+                channel: channel,
+                channel_index: index,
+                channel_type: key,
+                address: (payload[startKey] || node[key + "Start"]) + index,
+                module_model: payload.module_model,
+                module_model_code: payload.module_model_code,
+                detected_by: payload.detected_by,
+                format: key === "ai" ? payload.ai_format : undefined,
+                ts: payload.ts,
+                input: triggerMsg
+            };
+        });
+    }
+
+    function buildDigitalMessages(node, payload, triggerMsg, kind) {
+        return buildChannelMessages(node, payload, triggerMsg, kind);
+    }
+
+    function buildFamilyPayload(payload, kind) {
+        const values = Array.isArray(payload[kind]) ? payload[kind] : [];
+        const out = {};
+        values.forEach(function (value, index) {
+            out[kind + (index + 1)] = kind === "di" || kind === "do" ? !!value : value;
+        });
+        return out;
+    }
+
+    function buildFamilyAggregateMessage(node, payload, triggerMsg, kind) {
+        return {
+            topic: (node.name || node.host || "advantech-read") + "/" + kind,
+            payload: buildFamilyPayload(payload, kind),
+            channel_type: kind,
+            module_model: payload.module_model,
+            module_model_code: payload.module_model_code,
+            detected_by: payload.detected_by,
+            channel_count: Array.isArray(payload[kind]) ? payload[kind].length : 0,
+            start_address: payload[kind + "_start"],
+            format: kind === "ai" ? payload.ai_format : undefined,
+            ts: payload.ts,
+            input: triggerMsg
+        };
+    }
+
+    function cloneAggregatePayload(payload, include) {
+        const out = {
+            status: payload.status,
+            host: payload.host,
+            port: payload.port,
+            unit_id: payload.unit_id,
+            module_model: payload.module_model,
+            module_model_code: payload.module_model_code,
+            detected_by: payload.detected_by,
+            channel_counts: payload.channel_counts,
+            ts: payload.ts
+        };
+
+        ["di", "do", "ai", "ao"].forEach(function (key) {
+            if (!include[key]) return;
+            if (payload[key] === undefined) return;
+            out[key] = payload[key];
+            if (payload[key + "_start"] !== undefined) {
+                out[key + "_start"] = payload[key + "_start"];
+            }
+            if (key === "di" && payload.di_global_names !== undefined) {
+                out.di_global_names = payload.di_global_names;
+            }
+            if (key === "do" && payload.do_global_names !== undefined) {
+                out.do_global_names = payload.do_global_names;
+            }
+            if (key === "ai" && payload.ai_global_names !== undefined) {
+                out.ai_global_names = payload.ai_global_names;
+            }
+            if (key === "ao" && payload.ao_global_names !== undefined) {
+                out.ao_global_names = payload.ao_global_names;
+            }
+            if (key === "ai" && payload.ai_format !== undefined) {
+                out.ai_format = payload.ai_format;
+            }
+        });
+
+        return out;
+    }
+
+    function buildOutputMessages(node, payload, triggerMsg) {
+        const messages = [];
+        const families = [
+            { kind: "di", enabled: node.readDi, mode: node.diOutputMode },
+            { kind: "do", enabled: node.readDo, mode: node.doOutputMode },
+            { kind: "ai", enabled: node.readAi, mode: node.aiOutputMode },
+            { kind: "ao", enabled: node.readAo, mode: node.aoOutputMode }
+        ];
+
+        families.forEach(function (family) {
+            if (!family.enabled || payload[family.kind] === undefined) return;
+            if (family.mode === "split") {
+                buildChannelMessages(node, payload, triggerMsg, family.kind).forEach(function (message) {
+                    messages.push(message);
+                });
+            } else {
+                messages.push(buildFamilyAggregateMessage(node, payload, triggerMsg, family.kind));
+            }
+        });
+
+        if (node.debugOutput) {
+            messages.push({
+                topic: (node.name || node.host || "advantech-read") + "/debug",
+                payload: cloneAggregatePayload(payload, { di: true, do: true, ai: true, ao: true }),
+                channel_type: "debug",
+                input: triggerMsg
+            });
+        }
+
+        if (!messages.length) return null;
+        return messages;
+    }
+
+    function safeGlobalPart(value, fallback) {
+        const text = String(value || fallback || "adam")
+            .trim()
+            .toLowerCase()
+            .replace(/^adam-/, "adam_")
+            .replace(/[^a-z0-9_]+/g, "_")
+            .replace(/^_+|_+$/g, "");
+        return text || String(fallback || "adam");
+    }
+
+    function parseGlobalNames(value) {
+        return String(value || "")
+            .split(/[\n,;]+/)
+            .map(function (item) {
+                return item.trim();
+            });
+    }
+
+    function defaultGlobalName(node, profile, kind, index) {
+        const base = node[kind + "GlobalPrefix"] || "advantech";
+        return safeGlobalPart(base, "advantech") + "_" + kind + (index + 1);
+    }
+
+    function saveChannelGlobals(node, profile, values, kind) {
+        const enabled = !!node["save" + kind.toUpperCase()[0] + kind.slice(1) + "Globals"];
+        if (!enabled || !Array.isArray(values)) return [];
+        const globalCtx = node.context().global;
+        const customNames = parseGlobalNames(node[kind + "GlobalNames"]);
+        const names = [];
+
+        values.forEach(function (value, index) {
+            const name = customNames[index] || defaultGlobalName(node, profile, kind, index);
+            globalCtx.set(name, kind === "di" || kind === "do" ? !!value : value);
+            names.push(name);
+        });
+
+        return names;
+    }
+
+    function saveDigitalGlobals(node, profile, values, kind) {
+        return saveChannelGlobals(node, profile, values, kind);
+    }
+
+    function scaleRegister(value, scale, offset) {
+        const signed = value > 32767 ? value - 65536 : value;
+        const scaled = signed * scale + offset;
+        return Number.isFinite(scaled) ? Number(scaled.toFixed(6)) : signed;
+    }
+
+    function decodeFloat32(words, index, wordOrder) {
+        const buffer = Buffer.alloc(4);
+        const hi = wordOrder === "lsw_first" ? words[index + 1] : words[index];
+        const lo = wordOrder === "lsw_first" ? words[index] : words[index + 1];
+        buffer.writeUInt16BE(hi || 0, 0);
+        buffer.writeUInt16BE(lo || 0, 2);
+        return Number(buffer.readFloatBE(0).toFixed(6));
+    }
+
+    function AdvantechReadNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+
+        node.name = String(config.name || "").trim();
+        node.host = String(config.host || "").trim();
+        node.port = toPositiveInt(config.port, 502);
+        node.unitId = toPositiveInt(config.unitId, 1);
+        node.pollInterval = toPollInterval(config.pollInterval, 5000);
+        node.addressMode = config.addressMode === "zero" ? "zero" : "manual";
+        node.moduleType = String(config.moduleType || "ADAM-6066").trim();
+        node.outputCount = toPositiveInt(config.outputs, 1);
+        node.diOutputMode = config.diOutputMode === "split"
+            || (config.diOutputMode === undefined && node.outputCount > 1) ? "split" : "aggregate";
+        node.doOutputMode = config.doOutputMode === "split" ? "split" : "aggregate";
+        node.aiOutputMode = config.aiOutputMode === "split" ? "split" : "aggregate";
+        node.aoOutputMode = config.aoOutputMode === "split" ? "split" : "aggregate";
+        node.saveDiGlobals = !!config.saveDiGlobals;
+        node.saveDoGlobals = !!config.saveDoGlobals;
+        node.saveAiGlobals = !!config.saveAiGlobals;
+        node.saveAoGlobals = !!config.saveAoGlobals;
+        node.debugOutput = !!config.debugOutput;
+        node.diGlobalPrefix = String(config.diGlobalPrefix || "").trim();
+        node.doGlobalPrefix = String(config.doGlobalPrefix || "").trim();
+        node.aiGlobalPrefix = String(config.aiGlobalPrefix || "").trim();
+        node.aoGlobalPrefix = String(config.aoGlobalPrefix || "").trim();
+        node.diGlobalNames = String(config.diGlobalNames || "").trim();
+        node.doGlobalNames = String(config.doGlobalNames || "").trim();
+        node.aiGlobalNames = String(config.aiGlobalNames || "").trim();
+        node.aoGlobalNames = String(config.aoGlobalNames || "").trim();
+        node.readDi = config.readDi !== false;
+        node.readDo = config.readDo !== false;
+        node.readAi = config.readAi !== false;
+        node.readAo = config.readAo !== false;
+        node.diStart = toNonNegativeInt(config.diStart, 1);
+        node.doStart = toNonNegativeInt(config.doStart, 17);
+        node.aiStart = toNonNegativeInt(config.aiStart, 40001);
+        node.aoStart = toNonNegativeInt(config.aoStart, 40011);
+        node.diCount = toNonNegativeInt(config.diCount, 12);
+        node.doCount = toNonNegativeInt(config.doCount, 6);
+        node.aiCount = toNonNegativeInt(config.aiCount, 0);
+        node.aoCount = toNonNegativeInt(config.aoCount, 0);
+        node.aiFormat = config.aiFormat === "float32" ? "float32" : "int16";
+        node.aiScale = toFinite(config.aiScale, 1);
+        node.aiOffset = toFinite(config.aiOffset, 0);
+        node.aoScale = toFinite(config.aoScale, 1);
+        node.aoOffset = toFinite(config.aoOffset, 0);
+        node.wordOrder = config.wordOrder === "lsw_first" ? "lsw_first" : "msw_first";
+
+        let timer = null;
+        let busy = false;
+        let closing = false;
+        let client = new ModbusRTU();
+
+        async function connect() {
+            if (!client.isOpen) {
+                await client.connectTCP(node.host, { port: node.port });
+            }
+            client.setID(node.unitId);
+            client.setTimeout(2500);
+        }
+
+        async function closeConnection(done) {
+            try {
+                if (client && client.isOpen) {
+                    client.close(done || function () {});
+                    return;
+                }
+            } catch (e) {
+                // ignore close errors
+            }
+            client = new ModbusRTU();
+            if (done) done();
+        }
+
+        async function getProfile() {
+            const configured = profileForModel(node.moduleType);
+            if (configured) {
+                configured.detectedBy = "manual";
+                configured.modelCode = normalizeModel(node.moduleType);
+                return configured;
+            }
+
+            return {
+                model: node.moduleType && node.moduleType !== "auto" ? node.moduleType : "Manual",
+                modelCode: "",
+                diCount: node.diCount,
+                doCount: node.doCount,
+                aiCount: node.aiCount,
+                aoCount: node.aoCount,
+                detectedBy: "manual"
+            };
+        }
+
+        async function pollOnce(triggerMsg) {
+            if (busy || closing) return;
+            busy = true;
+
+            try {
+                await connect();
+                const profile = await getProfile();
+                const diCount = toNonNegativeInt(profile.diCount, 0);
+                const doCount = toNonNegativeInt(profile.doCount, 0);
+                const aiCount = toNonNegativeInt(profile.aiCount, 0);
+                const aoCount = toNonNegativeInt(profile.aoCount, 0);
+
+                const payload = {
+                    status: "ok",
+                    host: node.host,
+                    port: node.port,
+                    unit_id: node.unitId,
+                    module_model: profile.model || null,
+                    module_model_code: profile.modelCode || null,
+                    detected_by: profile.detectedBy || null,
+                    channel_counts: {
+                        di: diCount,
+                        do: doCount,
+                        ai: aiCount,
+                        ao: aoCount
+                    },
+                    ts: new Date().toISOString()
+                };
+
+                if ((node.readDi || node.diOutputMode === "split" || node.saveDiGlobals) && diCount > 0) {
+                    const start = resolveAddress(node.diStart, "coil", node.addressMode);
+                    const response = await client.readCoils(start, diCount);
+                    payload.di = boolArray(response.data || [], diCount);
+                    payload.di_start = node.diStart;
+                    payload.di_global_names = saveChannelGlobals(node, profile, payload.di, "di");
+                }
+
+                if ((node.readDo || node.doOutputMode === "split" || node.saveDoGlobals) && doCount > 0) {
+                    const start = resolveAddress(node.doStart, "coil", node.addressMode);
+                    const response = await client.readCoils(start, doCount);
+                    payload.do = boolArray(response.data || [], doCount);
+                    payload.do_start = node.doStart;
+                    payload.do_global_names = saveChannelGlobals(node, profile, payload.do, "do");
+                }
+
+                if ((node.readAi || node.aiOutputMode === "split" || node.saveAiGlobals) && aiCount > 0) {
+                    const start = resolveAddress(node.aiStart, "holding", node.addressMode);
+                    const count = node.aiFormat === "float32" ? aiCount * 2 : aiCount;
+                    const response = await client.readHoldingRegisters(start, count);
+                    const words = response.data || [];
+                    payload.ai = [];
+                    for (let i = 0; i < aiCount; i += 1) {
+                        payload.ai.push(
+                            node.aiFormat === "float32"
+                                ? decodeFloat32(words, i * 2, node.wordOrder)
+                                : scaleRegister(words[i] || 0, node.aiScale, node.aiOffset)
+                        );
+                    }
+                    payload.ai_start = node.aiStart;
+                    payload.ai_format = node.aiFormat;
+                    payload.ai_global_names = saveChannelGlobals(node, profile, payload.ai, "ai");
+                }
+
+                if ((node.readAo || node.aoOutputMode === "split" || node.saveAoGlobals) && aoCount > 0) {
+                    const start = resolveAddress(node.aoStart, "holding", node.addressMode);
+                    const response = await client.readHoldingRegisters(start, aoCount);
+                    payload.ao = (response.data || []).slice(0, aoCount).map(function (value) {
+                        return scaleRegister(value, node.aoScale, node.aoOffset);
+                    });
+                    payload.ao_start = node.aoStart;
+                    payload.ao_global_names = saveChannelGlobals(node, profile, payload.ao, "ao");
+                }
+
+                node.status({ fill: "green", shape: "dot", text: (profile.model || "ADAM") + " read ok" });
+                const messages = buildOutputMessages(node, payload, triggerMsg);
+                if (messages) node.send(messages);
+            } catch (error) {
+                node.status({ fill: "red", shape: "ring", text: "error" });
+                node.error(error.message || error, triggerMsg || {});
+                await closeConnection();
+            } finally {
+                busy = false;
+            }
+        }
+
+        if (node.pollInterval > 0) {
+            timer = setInterval(function () {
+                pollOnce();
+            }, node.pollInterval);
+            pollOnce();
+        }
+
+        node.on("input", function (msg) {
+            pollOnce(msg);
+        });
+
+        node.on("close", function (removed, done) {
+            closing = true;
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+            closeConnection(done);
+        });
+    
+        });
+    }
+
+    RED.nodes.registerType("advantech-read", AdvantechReadNode);
+};