smithtek-mako-rf 2.9.8 → 3.0.1

package/package.json

@@ -1,25 +1,25 @@
-{
-  "name": "smithtek-mako-rf",
-  "version": "2.9.8",
-  "description": "Smithtek dedicated node for communicating with the Mako PLC over RS485 or RF",
-  "keywords": [
-    "node-red",
-    "smithtek",
-    "modbus",
-    "rtu",
-    "rs485",
-    "lora"
-  ],
-  "license": "GPL-3.0-only",
-  "author": "Smithtek",
-  "homepage": "https://www.smithtek.com.au",
-"dependencies": {
-  "modbus-serial": "8.0.23-no-serial-port",
-  "serialport": "10.4.0"
-},
-  "node-red": {
-    "nodes": {
-      "smithtek-mako-rf": "smithtek-mako-rf.js"
-    }
-  }
-}
+{
+  "name": "smithtek-mako-rf",
+  "version": "3.0.1",
+  "description": "Smithtek dedicated node for communicating with the Mako PLC over RS485 or RF",
+  "keywords": [
+    "node-red",
+    "smithtek",
+    "modbus",
+    "rtu",
+    "rs485",
+    "lora"
+  ],
+  "license": "GPL-3.0-only",
+  "author": "Smithtek",
+  "homepage": "https://www.smithtek.com.au",
+"dependencies": {
+  "modbus-serial": "8.0.23-no-serial-port",
+  "serialport": "10.4.0"
+},
+  "node-red": {
+    "nodes": {
+      "smithtek-mako-rf": "smithtek-mako-rf.js"
+    }
+  }
+}

package/smithtek-mako-rf.js

@@ -185,12 +185,17 @@ state._rssiCleanup = cleanup;
   }
 
   // Scale supports:
-  // - numeric => multiply
-  // - operators like ">100", "<<2", "==1", etc.
+  // - numeric => multiply (including 0)
+  // - operators like "*2", "/10", "+5", "-7", ">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,
     "!=": (v, o) => v != o,
     "%": (v, o) => v % o,
     "<<": (v, o) => v << o,
@@ -198,16 +203,19 @@ state._rssiCleanup = cleanup;
     ">>>": (v, o) => v >>> o,
   };
 
-  const scalerRegex = /^\s*([<>!=%]{1,3}|<<|>>>|>>)\s*(-?\d+(\.\d+)?)\s*$/;
+  // allow optional leading operator, otherwise a plain number
+  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 (!s) return null;
 
-    if (!Number.isNaN(Number(s))) {
-      return { op: "*", val: Number(s) };
-    }
+    // Plain numeric means multiply (0 is valid!)
+    const asNum = Number(s);
+    if (!Number.isNaN(asNum)) return { op: "*", val: asNum };
+
+    // Operator form: "*2" "/10" "+5" etc
     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]) };
@@ -222,12 +230,21 @@ state._rssiCleanup = cleanup;
   // 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) {
+  function readTyped(regs, type, byteOffset, offsetBit) {
     const t = String(type || "").toLowerCase();
     const regIndex = Math.floor(byteOffset / 2);
 
     const w = (i) => (regs[i] & 0xffff);
+    const isBoolArray = (Array.isArray(regs) && typeof regs[0] === "boolean");
 
+    function coilWord(wordIndex) {
+      let out = 0;
+      const base = wordIndex * 16;
+      for (let b = 0; b < 16; b++) {
+        if (regs[base + b]) out |= (1 << b);
+      }
+      return out >>> 0;
+    }
     // 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]);
@@ -242,34 +259,11 @@ state._rssiCleanup = cleanup;
       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);
+      // LOCKED CDAB (matches your confirmed raw->decoded results)
+      return bytesCDAB(a, b);
     }
 
     switch (t) {
@@ -302,12 +296,25 @@ state._rssiCleanup = cleanup;
         return buf.readFloatBE(0);
       }
 
-      case "digital to unsigned binary encoder":
-        return w(regIndex) >>> 0;
+      case "digital to unsigned binary encoder": {
+        const word = w(regIndex) >>> 0;
+
+        // If the UI provided a bit (0–15), return that bit as TRUE/FALSE
+        const bit = clampInt(offsetBit, 0, 15, 0);
+        return ((word >> bit) & 1) === 1;
+      }
+
 
-      // optional internal bool support
       case "bool": {
         const bit = clampInt(offsetBit, 0, 15, 0);
+
+        // If this is FC1/FC2 data (boolean array), read bit directly
+        if (isBoolArray) {
+          const idx = (regIndex * 16) + bit;
+          return !!regs[idx];
+        }
+
+        // Otherwise treat as 16-bit register
         return ((w(regIndex) >> bit) & 1) === 1;
       }
 
@@ -321,7 +328,7 @@ state._rssiCleanup = cleanup;
     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 };
+  //  const state32 = { order: null };
 
     for (let i = 0; i < items.length; i++) {
       const it = items[i] || {};
@@ -337,18 +344,27 @@ state._rssiCleanup = cleanup;
 
       let val;
       try {
-        val = readTyped(regArray, type, byteOffset, offsetBit, state32);
+        val = readTyped(regArray, type, byteOffset, offsetBit);
       } catch (_e) {
         continue;
       }
 
+      // Read scale from multiple possible editor field names (prevents silent "never scales")
+      const scaleRaw = (it.scale != null) ? it.scale
+                    : (it.scaler != null) ? it.scaler
+                    : (it.scaleFactor != null) ? it.scaleFactor
+                    : null;
+
+      // Apply mask ONLY if value is an integer (otherwise it will trash floats)
       const mask = parseMask(it.mask);
-      if (mask && typeof val === "number") val = val & mask;
+      if (mask && typeof val === "number" && Number.isInteger(val)) {
+        val = (val & mask) >>> 0; // keep it sane as unsigned
+      }
 
-      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);
+      const scaler = parseScaler(scaleRaw);
+      if (scaler && typeof val === "number") {
+        const fn = scalingOps[scaler.op] || scalingOps["*"];
+        val = fn(val, scaler.val);
       }
 
       setObjectProperty(decoded, name, val, "=>");