smithtek-mako-rf 2.9.10 → 3.0.2

package/package.json

@@ -1,25 +1,25 @@
-{
-  "name": "smithtek-mako-rf",
-  "version": "2.9.10",
-  "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.2",
+  "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,7 +230,7 @@ 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);
 
@@ -251,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) {
@@ -343,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] || {};
@@ -359,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, "=>");
@@ -417,25 +411,37 @@ state._rssiCleanup = cleanup;
     return [5, 6, 15, 16].includes(fc) ? fc : 5;
   }
 
+  async function closeClientSafe(state) {
+    // Best-effort: close and wait a moment for the fd to actually drop
+    try {
+      await new Promise((resolve) => {
+        try {
+          state.client.close(() => resolve());
+        } catch (_e) {
+          resolve();
+        }
+      });
+    } catch (_e) {}
+
+    // tiny settle time helps on Pi serial
+    await sleep(50);
+  }
+
   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 settings changed, force reconnect
     if (state.connected && state.lastPortKey !== portKey) {
       state.connected = false;
-      try {
-        state.client.close(() => {});
-      } catch (_e) {}
+      await closeClientSafe(state);
     }
 
+    // Already connected
     if (state.connected) return;
 
-    // If another request is already connecting, wait for it
+    // If already connecting, wait for that attempt to finish
     if (state.connecting) {
       for (let i = 0; i < 200; i++) {
         if (state.connected) return;
@@ -457,10 +463,10 @@ state._rssiCleanup = cleanup;
         parity: cfg.parity || "none",
       };
 
-      try {
-        state.client.close(() => {});
-      } catch (_e) {}
+      // Always close cleanly before opening (and WAIT for it)
+      await closeClientSafe(state);
 
+      // Open
       await state.client.connectRTUBuffered(port, options);
 
       // UI uses seconds; library uses ms
@@ -805,18 +811,15 @@ try {
         if (busCfg) {
           const s = BUS.get(busCfg.id);
           if (s) {
-            // NEW: stop any in-flight queue processor from the old deploy
             s.queue = [];
             s.busy = false;
 
             if (typeof s._rssiCleanup === "function") {
               try { s._rssiCleanup(); } catch (_e) {}
             }
-            if (s.client) {
-              try { s.client.close(() => {}); } catch (_e) {}
-              s.connected = false;
-              s.client = new (require("modbus-serial"))();
-            }
+
+            s.connected = false;
+            try { s.client.close(() => {}); } catch (_e) {}
           }
         }
       } catch (_e) {}