smithtek-mako-rf 0.0.1

package/smithtek-mako-rf.js

@@ -0,0 +1,581 @@
+// smithtek-mako-rf.js
+module.exports = function (RED) {
+  "use strict";
+
+  const ModbusRTU = require("modbus-serial");
+
+  // Shared bus state across all node instances (keyed by config node id)
+  const BUS = new Map();
+
+  function toNum(v, fallback) {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : fallback;
+  }
+
+  function toInt(v, fallback) {
+    const n = parseInt(v, 10);
+    return Number.isFinite(n) ? n : fallback;
+  }
+
+  function clampInt(v, min, max, fallback) {
+    let n = toInt(v, fallback);
+    if (!Number.isFinite(n)) n = fallback;
+    if (n < min) n = min;
+    if (n > max) n = max;
+    return n;
+  }
+
+  function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  // Nested property setter using delimiter "=>"
+  function setObjectProperty(obj, path, value, delimiter) {
+    if (!path || typeof path !== "string") {
+      obj[path] = value;
+      return;
+    }
+    const parts = path
+      .split(delimiter || "=>")
+      .map((s) => s.trim())
+      .filter(Boolean);
+
+    if (!parts.length) return;
+
+    let ref = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const k = parts[i];
+      if (ref[k] == null || typeof ref[k] !== "object") ref[k] = {};
+      ref = ref[k];
+    }
+    ref[parts[parts.length - 1]] = value;
+  }
+
+  // Mask supports hex "0x0F", decimal "15", or blank
+  function parseMask(mask) {
+    if (mask == null) return 0;
+    const s = String(mask).trim();
+    if (!s) return 0;
+    if (s.startsWith("0x") || s.startsWith("0X")) {
+      const n = parseInt(s, 16);
+      return Number.isFinite(n) ? n : 0;
+    }
+    const n = parseInt(s, 10);
+    return Number.isFinite(n) ? n : 0;
+  }
+
+  // Scale supports:
+  // - numeric => multiply
+  // - operators like ">100", "<<2", "==1", etc.
+  const scalingOps = {
+    ">": (v, o) => v > o,
+    "<": (v, o) => v < o,
+    "==": (v, o) => v == o,
+    "!=": (v, o) => v != o,
+    "%": (v, o) => v % o,
+    "<<": (v, o) => v << o,
+    ">>": (v, o) => v >> o,
+    ">>>": (v, o) => v >>> o,
+  };
+
+  const scalerRegex = /^\s*([<>!=%]{1,3}|<<|>>>|>>)\s*(-?\d+(\.\d+)?)\s*$/;
+
+  function parseScaler(scale) {
+    if (scale == null) return null;
+    const s = String(scale).trim();
+    if (!s || s === "0" || s === "1") return null;
+
+    if (!Number.isNaN(Number(s))) {
+      return { op: "*", val: Number(s) };
+    }
+    const m = s.match(scalerRegex);
+    if (m && m[1] && !Number.isNaN(Number(m[2])) && scalingOps[m[1]]) {
+      return { op: m[1], val: Number(m[2]) };
+    }
+    return null;
+  }
+
+  // ==========================
+  // Decoder (auto 32-bit order)
+  // ==========================
+
+  // Read a typed value using your Mako dropdown names.
+  // Offset is BYTES (0,2,4...) like your original decoder.
+  // For 32-bit values, auto-detect word/byte order once per decode pass.
+  function readTyped(regs, type, byteOffset, offsetBit, state32) {
+    const t = String(type || "").toLowerCase();
+    const regIndex = Math.floor(byteOffset / 2);
+
+    const w = (i) => (regs[i] & 0xffff);
+
+    // 4 bytes from two 16-bit words in common Modbus orders
+    function bytesABCD(a, b) {
+      return Buffer.from([(a >> 8) & 0xff, a & 0xff, (b >> 8) & 0xff, b & 0xff]);
+    }
+    function bytesCDAB(a, b) {
+      return Buffer.from([(b >> 8) & 0xff, b & 0xff, (a >> 8) & 0xff, a & 0xff]);
+    }
+    function bytesBADC(a, b) {
+      return Buffer.from([a & 0xff, (a >> 8) & 0xff, b & 0xff, (b >> 8) & 0xff]);
+    }
+    function bytesDCBA(a, b) {
+      return Buffer.from([b & 0xff, (b >> 8) & 0xff, a & 0xff, (a >> 8) & 0xff]);
+    }
+
+    function pick32OrderIfNeeded(a, b) {
+      if (state32.order) return state32.order;
+
+      const candidates = [
+        { o: "ABCD", v: bytesABCD(a, b).readFloatBE(0) },
+        { o: "CDAB", v: bytesCDAB(a, b).readFloatBE(0) },
+        { o: "BADC", v: bytesBADC(a, b).readFloatBE(0) },
+        { o: "DCBA", v: bytesDCBA(a, b).readFloatBE(0) },
+      ];
+
+      // Sane heuristic: finite, not denormal-tiny, not insane huge
+      for (const c of candidates) {
+        if (Number.isFinite(c.v) && Math.abs(c.v) > 1e-6 && Math.abs(c.v) < 1e9) {
+          state32.order = c.o;
+          return c.o;
+        }
+      }
+
+      state32.order = "ABCD";
+      return state32.order;
+    }
+
+    function get32Bytes(a, b) {
+      const order = pick32OrderIfNeeded(a, b);
+      if (order === "ABCD") return bytesABCD(a, b);
+      if (order === "CDAB") return bytesCDAB(a, b);
+      if (order === "BADC") return bytesBADC(a, b);
+      return bytesDCBA(a, b);
+    }
+
+    switch (t) {
+      case "16 bit integer": {
+        const v = w(regIndex);
+        return v & 0x8000 ? v - 0x10000 : v;
+      }
+
+      case "16 bit unsigned":
+        return w(regIndex);
+
+      case "32 bit integer": {
+        const a = w(regIndex),
+          b = w(regIndex + 1);
+        const buf = get32Bytes(a, b);
+        return buf.readInt32BE(0);
+      }
+
+      case "32 bit unsigned": {
+        const a = w(regIndex),
+          b = w(regIndex + 1);
+        const buf = get32Bytes(a, b);
+        return buf.readUInt32BE(0);
+      }
+
+      case "32 bit float": {
+        const a = w(regIndex),
+          b = w(regIndex + 1);
+        const buf = get32Bytes(a, b);
+        return buf.readFloatBE(0);
+      }
+
+      case "digital to unsigned binary encoder":
+        return w(regIndex) >>> 0;
+
+      // optional internal bool support
+      case "bool": {
+        const bit = clampInt(offsetBit, 0, 15, 0);
+        return ((w(regIndex) >> bit) & 1) === 1;
+      }
+
+      default:
+        return w(regIndex);
+    }
+  }
+
+  function decodeWithItems(regArray, items) {
+    const decoded = {};
+    if (!Array.isArray(regArray) || !Array.isArray(items) || !items.length) return decoded;
+
+    // Auto-detect 32-bit order on first 32-bit value, then reuse for all
+    const state32 = { order: null };
+
+    for (let i = 0; i < items.length; i++) {
+      const it = items[i] || {};
+      const name =
+        it.name && String(it.name).trim() ? String(it.name).trim() : `item${i + 1}`;
+
+      const type = it.type || "16 bit integer";
+      const byteOffset = clampInt(it.offset, 0, 10000000, 0); // BYTES
+      const offsetBit = clampInt(it.offsetbit, 0, 15, 0);
+
+      const regIndex = Math.floor(byteOffset / 2);
+      if (regIndex < 0 || regIndex >= regArray.length) continue;
+
+      let val;
+      try {
+        val = readTyped(regArray, type, byteOffset, offsetBit, state32);
+      } catch (_e) {
+        continue;
+      }
+
+      const mask = parseMask(it.mask);
+      if (mask && typeof val === "number") val = val & mask;
+
+      const scaler = parseScaler(it.scale);
+      if (scaler) {
+        if (scaler.op === "*" && typeof val === "number") val = val * scaler.val;
+        else if (scaler.op && scalingOps[scaler.op]) val = scalingOps[scaler.op](val, scaler.val);
+      }
+
+      setObjectProperty(decoded, name, val, "=>");
+    }
+
+    return decoded;
+  }
+
+  // ==========================
+  // Modbus bus + queue engine
+  // ==========================
+
+  function ensureBusState(busConfig) {
+    const key = busConfig.id;
+    let s = BUS.get(key);
+    if (!s) {
+      s = {
+        id: key,
+        client: new ModbusRTU(),
+        connecting: false,
+        connected: false,
+        queue: [],
+        busy: false,
+        lastPortKey: "",
+      };
+      BUS.set(key, s);
+    }
+    return s;
+  }
+
+  function getFreshBusConfig(busId) {
+    return RED.nodes.getNode(busId) || null;
+  }
+
+  function makePortKey(cfg) {
+    return [cfg.serialPort || "", String(cfg.baudRate ?? ""), String(cfg.parity ?? ""), String(cfg.stopBits ?? "")].join(
+      "|"
+    );
+  }
+
+  function enforceFcForMode(mode, fc) {
+    if (mode === "read") return [1, 2, 3, 4].includes(fc) ? fc : 3;
+    return [5, 6, 15, 16].includes(fc) ? fc : 5;
+  }
+
+  async function connectIfNeeded(cfg, state) {
+    if (!cfg) throw new Error("Bus config missing");
+
+    // NOTE: we will hard-lock /dev/ttyAMA2 later (PassPort mode)
+    // if (process.env.SMITHTEK_PASSPORT === "1") cfg.serialPort = "/dev/ttyAMA2";
+
+    const portKey = makePortKey(cfg);
+
+    // If port settings changed, force reconnect
+    if (state.connected && state.lastPortKey !== portKey) {
+      state.connected = false;
+      try {
+        state.client.close(() => {});
+      } catch (_e) {}
+    }
+
+    if (state.connected) return;
+
+    // If another request is already connecting, wait for it
+    if (state.connecting) {
+      for (let i = 0; i < 200; i++) {
+        if (state.connected) return;
+        if (!state.connecting) break;
+        await sleep(50);
+      }
+    }
+
+    state.connecting = true;
+
+    try {
+      const port = cfg.serialPort;
+      if (!port) throw new Error("No serial port configured");
+
+      const options = {
+        baudRate: clampInt(cfg.baudRate, 1200, 921600, 9600),
+        dataBits: 8,
+        stopBits: clampInt(cfg.stopBits, 1, 2, 1),
+        parity: cfg.parity || "none",
+      };
+
+      try {
+        state.client.close(() => {});
+      } catch (_e) {}
+
+      await state.client.connectRTUBuffered(port, options);
+
+      // UI uses seconds; library uses ms
+      const timeout_s = Math.max(1, toNum(cfg.timeout_s, 8));
+      state.client.setTimeout(Math.max(1000, Math.floor(timeout_s * 1000)));
+
+      state.connected = true;
+      state.lastPortKey = portKey;
+    } finally {
+      state.connecting = false;
+    }
+  }
+
+  async function doRequest(cfg, state, req) {
+    await connectIfNeeded(cfg, state);
+
+    state.client.setID(req.unitid);
+
+    const fc = req.fc;
+    const addr = req.address;
+
+    switch (fc) {
+      // READS
+      case 1:
+        return state.client.readCoils(addr, req.quantity);
+      case 2:
+        return state.client.readDiscreteInputs(addr, req.quantity);
+      case 3:
+        return state.client.readHoldingRegisters(addr, req.quantity);
+      case 4:
+        return state.client.readInputRegisters(addr, req.quantity);
+
+      // WRITES
+      case 5:
+        return state.client.writeCoil(addr, !!req.value);
+
+      case 6:
+        return state.client.writeRegister(addr, clampInt(req.value, 0, 65535, 0));
+
+      case 15: {
+        if (!Array.isArray(req.value)) throw new Error("FC15 requires an array value");
+        const arr = req.value.map((v) => !!v);
+        return state.client.writeCoils(addr, arr);
+      }
+
+      case 16: {
+        if (!Array.isArray(req.value)) throw new Error("FC16 requires an array value");
+        const arr = req.value.map((v) => clampInt(v, 0, 65535, 0));
+        return state.client.writeRegisters(addr, arr);
+      }
+
+      default:
+        throw new Error(`Unsupported function code: ${fc}`);
+    }
+  }
+
+  function scheduleProcess(state, busId) {
+    if (state.busy) return;
+    state.busy = true;
+
+    (async () => {
+      while (state.queue.length > 0) {
+        const item = state.queue.shift();
+        const { node, msg, send, done, req, items } = item;
+
+        const cfg = getFreshBusConfig(busId);
+        if (!cfg) {
+          node.status({ fill: "red", shape: "ring", text: "bus config missing" });
+          msg.payload = { ok: false, error: "Bus config missing", req };
+          msg.modbus = { ok: false, error: "Bus config missing", req };
+          send(msg);
+          done();
+          continue;
+        }
+
+        const busName = (cfg.busName || "smithtek mako rf").trim();
+
+        // retries=0 means exactly 1 attempt
+        const retries = clampInt(cfg.retries, 0, 10, 2);
+        const totalTries = retries + 1;
+
+        const timeout_s = Math.max(1, toNum(cfg.timeout_s, 8));
+        const gap_s = Math.max(0, toNum(cfg.gap_s, 0));
+
+        let attempt = 0;
+        let lastErr = null;
+        let res = null;
+
+        while (attempt < totalTries) {
+          attempt += 1;
+          try {
+            node.status({
+              fill: "blue",
+              shape: "dot",
+              text: `${busName}: fc${req.fc} uid${req.unitid} @${req.address} (try ${attempt}/${totalTries})`,
+            });
+
+            // apply timeout every time
+            try {
+              state.client.setTimeout(Math.max(1000, Math.floor(timeout_s * 1000)));
+            } catch (_e) {}
+
+            res = await doRequest(cfg, state, req);
+            lastErr = null;
+            break;
+          } catch (err) {
+            lastErr = err;
+
+            // Force reconnect next attempt
+            state.connected = false;
+            try {
+              state.client.close(() => {});
+            } catch (_e) {}
+
+            if (attempt < totalTries && gap_s > 0) {
+              await sleep(Math.floor(gap_s * 1000));
+            }
+          }
+        }
+
+        if (gap_s > 0) await sleep(Math.floor(gap_s * 1000));
+
+        if (lastErr) {
+          node.status({ fill: "red", shape: "ring", text: `${busName}: fail fc${req.fc} uid${req.unitid}` });
+
+          msg.modbus = msg.modbus || {};
+          msg.modbus.ok = false;
+          msg.modbus.bus = busName;
+          msg.modbus.req = req;
+          msg.modbus.error = lastErr && lastErr.message ? lastErr.message : String(lastErr);
+
+          msg.payload = { ok: false, error: msg.modbus.error, req };
+          send(msg);
+          done();
+          continue;
+        }
+
+        node.status({ fill: "green", shape: "dot", text: `${busName}: ok fc${req.fc} uid${req.unitid}` });
+
+        msg.modbus = msg.modbus || {};
+        msg.modbus.ok = true;
+        msg.modbus.bus = busName;
+        msg.modbus.req = req;
+        msg.modbus.raw = res;
+
+        if (req.mode === "read" && res && Array.isArray(res.data)) {
+          msg.payload = decodeWithItems(res.data, items);
+        } else {
+          msg.payload = res;
+        }
+
+        send(msg);
+        done();
+      }
+    })().finally(() => {
+      state.busy = false;
+    });
+  }
+
+  // =========================
+  // Config Node: smithtek-mako-rf-bus
+  // =========================
+  function SmithtekMakoRfBusConfig(n) {
+    RED.nodes.createNode(this, n);
+
+    this.busName = (n.busName || "smithtek mako rf").trim();
+    this.serialPort = n.serialPort || "";
+    this.baudRate = toNum(n.baudRate, 9600);
+    this.stopBits = toNum(n.stopBits, 1);
+    this.parity = n.parity || "none";
+
+    this.timeout_s = toNum(n.timeout_s, 8);
+    this.retries = toNum(n.retries, 2);
+    this.gap_s = toNum(n.gap_s, 0);
+
+    ensureBusState(this);
+
+    this.on("close", (removed, done) => {
+      if (removed) {
+        const s = BUS.get(this.id);
+        if (s) {
+          try {
+            s.client.close(() => {});
+          } catch (_e) {}
+          BUS.delete(this.id);
+        }
+      }
+      done();
+    });
+  }
+  RED.nodes.registerType("smithtek-mako-rf-bus", SmithtekMakoRfBusConfig);
+
+  // =========================
+  // Runtime Node: smithtek-mako-rf
+  // =========================
+  function SmithtekMakoRfNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+
+    node.on("input", function (msg, send, done) {
+      send = send || function () { node.send.apply(node, arguments); };
+
+      const busCfg = RED.nodes.getNode(config.bus);
+      if (!busCfg) {
+        node.status({ fill: "red", shape: "ring", text: "no bus config" });
+        done(new Error("No Smithtek Mako RF bus configured"));
+        return;
+      }
+
+      const state = ensureBusState(busCfg);
+
+      const mode = (config.mode || "read").toLowerCase();
+
+      let fc = clampInt(config.fc, 1, 16, 3);
+      fc = enforceFcForMode(mode, fc);
+
+      const unitid = clampInt(config.unitid, 1, 247, 1);
+      const address = clampInt(config.address, 0, 100000, 0);
+      const quantity = clampInt(config.quantity, 1, 2000, 1);
+
+      // Decoder items from UI
+      const items = Array.isArray(config.items) ? config.items : [];
+
+      const req = { mode, fc, unitid, address };
+
+      if (mode === "read") {
+        req.quantity = quantity;
+      } else {
+        const valueSource = (config.valueSource || "msg.payload").toLowerCase();
+        let value;
+
+        if (valueSource === "fixed") {
+          const vt = (config.valueType || "bool").toLowerCase();
+          const raw = config.valueText ?? "";
+
+          if (vt === "bool") value = String(raw).trim().toLowerCase() === "true";
+          else if (vt === "number") value = toNum(raw, 0);
+          else if (vt === "json") {
+            try { value = JSON.parse(String(raw)); } catch (_e) { value = String(raw); }
+          } else value = String(raw);
+        } else {
+          value = msg.payload;
+        }
+
+        req.value = value;
+
+        if (config.includeWriteQuantity) req.quantity = quantity;
+      }
+
+      state.queue.push({ node, msg, send, done, req, items });
+      scheduleProcess(state, busCfg.id);
+    });
+
+    node.on("close", function (_removed, done) {
+      node.status({});
+      done();
+    });
+  }
+
+  RED.nodes.registerType("smithtek-mako-rf", SmithtekMakoRfNode);
+};