@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/advantech-write/advantech-write.js

@@ -0,0 +1,338 @@
+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 toPositiveInt(value, fallback) {
+        const n = toInt(value, fallback);
+        return n > 0 ? n : fallback;
+    }
+
+    function toNonNegativeInt(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 manualAddressToOffset(address, area) {
+        const n = toInt(address, 0);
+        if (area === "holding" && n >= 40001) return n - 40001;
+        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 parseBooleanLike(value) {
+        if (typeof value === "boolean") return value;
+        if (typeof value === "number") {
+            if (value === 1) return true;
+            if (value === 0) return false;
+        }
+        if (typeof value === "string") {
+            const normalized = value.trim().toLowerCase();
+            if (["1", "true", "on", "enable", "enabled", "activ", "active"].includes(normalized)) return true;
+            if (["0", "false", "off", "disable", "disabled", "dezactiv", "inactive"].includes(normalized)) return false;
+        }
+        return null;
+    }
+
+    function toUnsigned16(value) {
+        let v = Math.round(Number(value) || 0);
+        if (v < 0) v = 0;
+        if (v > 65535) v = 65535;
+        return v;
+    }
+
+    function rawAoFromValue(value, scale, offset) {
+        const n = Number(value);
+        if (!Number.isFinite(n)) {
+            throw new Error("AO value trebuie sa fie numeric");
+        }
+        if (!Number.isFinite(scale) || scale === 0) {
+            throw new Error("AO scale trebuie sa fie diferit de 0");
+        }
+        return toUnsigned16((n - offset) / scale);
+    }
+
+    function normalizeDoCommands(payload, defaultChannel, allowMask) {
+        if (payload === null || payload === undefined) return [];
+
+        if (Array.isArray(payload)) {
+            return payload.map(function (value, index) {
+                const boolValue = parseBooleanLike(value);
+                if (boolValue === null) return null;
+                return { channel: index, value: boolValue };
+            }).filter(Boolean);
+        }
+
+        if (typeof payload === "object") {
+            if (Array.isArray(payload.do)) {
+                return normalizeDoCommands(payload.do, defaultChannel, allowMask);
+            }
+            if (payload.channel !== undefined || payload.value !== undefined) {
+                const boolValue = parseBooleanLike(payload.value);
+                if (boolValue === null) {
+                    throw new Error("DO value invalid");
+                }
+                return [{ channel: toNonNegativeInt(payload.channel, defaultChannel), value: boolValue }];
+            }
+            if (payload.do_channel !== undefined || payload.do_value !== undefined) {
+                const boolValue = parseBooleanLike(payload.do_value);
+                if (boolValue === null) {
+                    throw new Error("DO value invalid");
+                }
+                return [{ channel: toNonNegativeInt(payload.do_channel, defaultChannel), value: boolValue }];
+            }
+            if (allowMask && payload.do_mask !== undefined) {
+                return [{ mask: toUnsigned16(payload.do_mask) }];
+            }
+        }
+
+        const boolValue = parseBooleanLike(payload);
+        if (boolValue === null) {
+            throw new Error("Payload DO invalid");
+        }
+        return [{ channel: defaultChannel, value: boolValue }];
+    }
+
+    function normalizeAoCommands(payload, defaultChannel, scale, offset) {
+        if (!payload || typeof payload !== "object") return [];
+
+        if (Array.isArray(payload.ao)) {
+            return payload.ao.map(function (value, index) {
+                return { channel: index, raw: rawAoFromValue(value, scale, offset), value: Number(value) };
+            });
+        }
+
+        if (payload.ao_channel !== undefined || payload.ao_value !== undefined) {
+            return [{
+                channel: toNonNegativeInt(payload.ao_channel, defaultChannel),
+                raw: rawAoFromValue(payload.ao_value, scale, offset),
+                value: Number(payload.ao_value)
+            }];
+        }
+
+        if (payload.ao_raw !== undefined) {
+            return [{
+                channel: toNonNegativeInt(payload.ao_channel, defaultChannel),
+                raw: toUnsigned16(payload.ao_raw),
+                value: null
+            }];
+        }
+
+        return [];
+    }
+
+    function AdvantechWriteNode(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.addressMode = config.addressMode === "zero" ? "zero" : "manual";
+        node.moduleType = String(config.moduleType || "ADAM-6066").trim();
+        node.writeType = ["do", "ao", "both"].includes(config.writeType) ? config.writeType : "do";
+        node.doStart = toNonNegativeInt(config.doStart, 17);
+        node.aoStart = toNonNegativeInt(config.aoStart, 40011);
+        node.defaultChannel = toNonNegativeInt(config.defaultChannel, 0);
+        node.aoScale = toFinite(config.aoScale, 1);
+        node.aoOffset = toFinite(config.aoOffset, 0);
+        node.allowDoMask = !!config.allowDoMask;
+        node.doMaskRegister = toNonNegativeInt(config.doMaskRegister, 40303);
+        node.verifyWrite = config.verifyWrite !== false;
+
+        let client = new ModbusRTU();
+        let queue = Promise.resolve();
+
+        async function connect() {
+            if (!client.isOpen) {
+                await client.connectTCP(node.host, { port: node.port });
+            }
+            client.setID(node.unitId);
+            client.setTimeout(2500);
+        }
+
+        async function closeConnection() {
+            try {
+                if (client && client.isOpen) {
+                    await client.close();
+                }
+            } catch (e) {
+                // ignore close errors
+            }
+            client = new ModbusRTU();
+        }
+
+        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: 0,
+                doCount: 999,
+                aiCount: 0,
+                aoCount: 999,
+                detectedBy: "manual"
+            };
+        }
+
+        async function writeDo(command, profile) {
+            const doCount = toNonNegativeInt(profile.doCount, 0);
+            if (command.mask === undefined && command.channel >= doCount) {
+                throw new Error((profile.model || "ADAM") + " nu are DO channel " + command.channel + " (DO count: " + doCount + ")");
+            }
+
+            if (command.mask !== undefined && doCount <= 0) {
+                throw new Error((profile.model || "ADAM") + " nu are iesiri digitale detectate");
+            }
+
+            if (command.mask !== undefined) {
+                const addr = resolveAddress(node.doMaskRegister, "holding", node.addressMode);
+                await client.writeRegister(addr, command.mask);
+                return { type: "do_mask", register: node.doMaskRegister, raw: command.mask };
+            }
+
+            const manualAddress = node.doStart + command.channel;
+            const addr = resolveAddress(manualAddress, "coil", node.addressMode);
+            await client.writeCoil(addr, command.value);
+            if (node.verifyWrite) {
+                const readback = await client.readCoils(addr, 1);
+                const actual = !!(readback.data && readback.data[0]);
+                if (actual !== command.value) {
+                    throw new Error("DO channel " + command.channel + " nu a fost confirmat");
+                }
+            }
+            return { type: "do", channel: command.channel, address: manualAddress, value: command.value };
+        }
+
+        async function writeAo(command, profile) {
+            const aoCount = toNonNegativeInt(profile.aoCount, 0);
+            if (command.channel >= aoCount) {
+                throw new Error((profile.model || "ADAM") + " nu are AO channel " + command.channel + " (AO count: " + aoCount + ")");
+            }
+
+            const manualAddress = node.aoStart + command.channel;
+            const addr = resolveAddress(manualAddress, "holding", node.addressMode);
+            await client.writeRegister(addr, command.raw);
+            if (node.verifyWrite) {
+                const readback = await client.readHoldingRegisters(addr, 1);
+                const actual = readback.data && readback.data[0];
+                if (actual !== command.raw) {
+                    throw new Error("AO channel " + command.channel + " nu a fost confirmat");
+                }
+            }
+            return {
+                type: "ao",
+                channel: command.channel,
+                address: manualAddress,
+                value: command.value,
+                raw: command.raw
+            };
+        }
+
+        async function handleInput(msg) {
+            const payload = msg ? msg.payload : undefined;
+            const operations = [];
+
+            if (node.writeType === "do" || node.writeType === "both") {
+                normalizeDoCommands(payload, node.defaultChannel, node.allowDoMask).forEach(function (command) {
+                    operations.push({ kind: "do", command: command });
+                });
+            }
+
+            if (node.writeType === "ao" || node.writeType === "both") {
+                normalizeAoCommands(payload, node.defaultChannel, node.aoScale, node.aoOffset).forEach(function (command) {
+                    operations.push({ kind: "ao", command: command });
+                });
+            }
+
+            if (!operations.length) {
+                throw new Error("Nu exista comenzi DO/AO valide in payload");
+            }
+
+            await connect();
+            const profile = await getProfile();
+
+            const written = [];
+            for (let i = 0; i < operations.length; i += 1) {
+                const op = operations[i];
+                written.push(op.kind === "do" ? await writeDo(op.command, profile) : await writeAo(op.command, profile));
+            }
+
+            node.status({ fill: "green", shape: "dot", text: (profile.model || "ADAM") + " write ok" });
+            node.send({
+                topic: "advantech/write",
+                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: toNonNegativeInt(profile.diCount, 0),
+                        do: toNonNegativeInt(profile.doCount, 0),
+                        ai: toNonNegativeInt(profile.aiCount, 0),
+                        ao: toNonNegativeInt(profile.aoCount, 0)
+                    },
+                    written: written,
+                    ts: new Date().toISOString()
+                }
+            });
+        }
+
+        node.on("input", function (msg) {
+            queue = queue.then(function () {
+                return handleInput(msg);
+            }).catch(async function (error) {
+                node.status({ fill: "red", shape: "ring", text: "error" });
+                node.error(error.message || error, msg || {});
+                await closeConnection();
+            });
+        });
+
+        node.on("close", function (removed, done) {
+            closeConnection().then(function () {
+                done();
+            }).catch(function () {
+                done();
+            });
+        });
+    
+        });
+    }
+
+    RED.nodes.registerType("advantech-write", AdvantechWriteNode);
+};