smithtek-mako-rf 3.1.0 → 3.3.2

package/smithtek-mako-rf.js

@@ -3,11 +3,9 @@ module.exports = function (RED) {
   "use strict";
 
   const ModbusRTU = require("modbus-serial");
+  const rangeScaling = require('./range-scaling');
 
-  // Shared bus state across all node instances (keyed by config node id)
-  const BUS = new Map();
-
-  function toNum(v, fallback) {
+function toNum(v, fallback) {
     const n = Number(v);
     return Number.isFinite(n) ? n : fallback;
   }
@@ -69,7 +67,7 @@ module.exports = function (RED) {
           f[7] === 0x01 &&
           f[10] === 0x0D && f[11] === 0x0A;
 
-        if (!ok) continue;
+        if (!ok || ((f.slice(0,9).reduce((a,b) => a+b,0) & 0xff) !== f[9])) continue;
 
         const xx = f[8];
         const rssiDbm = -xx; // Manufacturer rule
@@ -79,78 +77,8 @@ module.exports = function (RED) {
     return null;
   }
 
-  async function queryRssiOnSamePort(state, guardMs, timeoutMs) {
-    // modbus-serial keeps the underlying serialport here in most builds:
-    // state.client._port or state.client._client (varies by version)
-    const p0 = state?.client?._port;
-  const port =
-    (p0 && (p0._client || p0.port || p0._port)) ||   // unwrap common wrappers
-    state?.client?._client ||
-    p0;
-
-    if (!port || typeof port.write !== "function" || typeof port.on !== "function") {
-      throw new Error("No underlying serial port handle found (modbus-serial port not accessible)");
-    }
-
-    if (guardMs > 0) await sleep(guardMs);
-
-    const cmd = buildRssiCommandBuffer();
-
-    // Optional: flush any buffered junk (some serialport builds support this)
-    try { if (typeof port.flush === "function") port.flush(() => {}); } catch (_e) {}
-
-    let rx = Buffer.alloc(0);
-
-    return await new Promise((resolve, reject) => {
-      let finished = false;
-
-      const timer = setTimeout(() => {
-        cleanup();
-        reject(new Error("RSSI timeout"));
-      }, Math.max(10, timeoutMs | 0));
-
-      function cleanup() {
-        if (finished) return;
-        finished = true;
-        clearTimeout(timer);
-        try { port.off("data", onData); } catch (_e) {
-          try { port.removeListener("data", onData); } catch (_e2) {}
-        }
-        try { if (typeof port.flush === "function") port.flush(() => {}); } catch (_e) {}
-        if (state._rssiCleanup === cleanup) delete state._rssiCleanup;
-      }
-state._rssiCleanup = cleanup;
-
-      function onData(chunk) {
-        rx = Buffer.concat([rx, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
-        const parsed = tryParseRssiAck(rx);
-        if (parsed) {
-          cleanup();
-          resolve(parsed.rssiDbm);
-        } else {
-          // keep rx from growing forever
-          if (rx.length > 512) rx = rx.slice(-128);
-        }
-      }
-
-      port.on("data", onData);
-
-      port.write(cmd, (err) => {
-        if (err) {
-          cleanup();
-          reject(err);
-          return;
-        }
-        // ensure bytes actually leave the building
-        try {
-          if (typeof port.drain === "function") port.drain(() => {});
-        } catch (_e) {}
-      });
-    });
-  }
-
   // Nested property setter using delimiter "=>"
-  function setObjectProperty(obj, path, value, delimiter) {
+  function setObjectProperty(obj, path, value, delimiter, prefix) {
     if (!path || typeof path !== "string") {
       obj[path] = value;
       return;
@@ -162,6 +90,10 @@ state._rssiCleanup = cleanup;
 
     if (!parts.length) return;
 
+    if (parts.some(k => ["__proto__","prototype","constructor"].includes(k))) throw new Error("Invalid decoder property path");
+    // Prefix is literal text, even if it contains the nesting delimiter.
+    const labelPrefix = String(prefix == null ? '' : prefix).trim();
+    if (labelPrefix) parts[0] = labelPrefix + ' ' + parts[0];
     let ref = obj;
     for (let i = 0; i < parts.length - 1; i++) {
       const k = parts[i];
@@ -213,7 +145,7 @@ state._rssiCleanup = cleanup;
 
     // Plain numeric means multiply (0 is valid!)
     const asNum = Number(s);
-    if (!Number.isNaN(asNum)) return { op: "*", val: asNum };
+    if (Number.isFinite(asNum) && !/^[+-]/.test(s)) return { op: "*", val: asNum };
 
     // Operator form: "*2" "/10" "+5" etc
     const m = s.match(scalerRegex);
@@ -297,7 +229,7 @@ state._rssiCleanup = cleanup;
       }
 
       case "digital to unsigned binary encoder": {
-        const word = w(regIndex) >>> 0;
+        const word = (isBoolArray ? coilWord(regIndex) : w(regIndex)) >>> 0;
 
         // If the UI provided a bit (0–15), return that bit as TRUE/FALSE
         const bit = clampInt(offsetBit, 0, 15, 0);
@@ -323,7 +255,7 @@ state._rssiCleanup = cleanup;
     }
   }
 
-  function decodeWithItems(regArray, items) {
+  function decodeWithItems(regArray, items, prefix) {
     const decoded = {};
     if (!Array.isArray(regArray) || !Array.isArray(items) || !items.length) return decoded;
 
@@ -342,6 +274,7 @@ state._rssiCleanup = cleanup;
       const regIndex = Math.floor(byteOffset / 2);
       if (regIndex < 0 || regIndex >= regArray.length) continue;
 
+      if (String(type).startsWith("32 bit") && regIndex + 1 >= regArray.length) throw new Error("Incomplete 32-bit register pair: " + name);
       let val;
       try {
         val = readTyped(regArray, type, byteOffset, offsetBit);
@@ -361,498 +294,196 @@ state._rssiCleanup = cleanup;
         val = (val & mask) >>> 0; // keep it sane as unsigned
       }
 
-      const scaler = parseScaler(scaleRaw);
-      if (scaler && typeof val === "number") {
-        const fn = scalingOps[scaler.op] || scalingOps["*"];
-        val = fn(val, scaler.val);
+      if (it.scaleMode === 'range') {
+        try { val = rangeScaling.scale(val, it); }
+        catch (err) { throw new Error(name + ': ' + err.message); }
+      } else if (it.scaleMode !== 'none') {
+        const scaler = parseScaler(scaleRaw);
+        if (scaler && typeof val === "number") {
+          const fn = scalingOps[scaler.op] || scalingOps["*"];
+          val = fn(val, scaler.val);
+        }
       }
 
-      setObjectProperty(decoded, name, val, "=>");
+      // Digital points are numeric at the output boundary. Keep the internal
+      // boolean until here so saved math/masks cannot change a bit into another value.
+      if (typeof val === 'boolean') val = val ? 1 : 0;
+      setObjectProperty(decoded, name, val, "=>", prefix);
     }
 
     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: "",
-        maxQueue: 50
-      };
-      BUS.set(key, s);
-    }
-    return s;
-  }
-
-  function getFreshBusConfig(busId) {
-    return RED.nodes.getNode(busId) || null;
-  }
+  const engine = require('./bus-engine')(ModbusRTU);
 
-  function makePortKey(cfg) {
-    return [cfg.serialPort || "", String(cfg.baudRate ?? ""), String(cfg.parity ?? ""), String(cfg.stopBits ?? "")].join(
-      "|"
-    );
+  function SmithtekMakoRfBusConfig(config) {
+    RED.nodes.createNode(this, config);
+    Object.assign(this, {
+      busName: config.busName || 'Mako', serialPort: config.serialPort || '',
+      baudRate: toNum(config.baudRate,9600), parity: config.parity || 'none', stopBits: toNum(config.stopBits,1),
+      timeout_s: toNum(config.timeout_s,8), retries: toNum(config.retries,2), gap_s: toNum(config.gap_s,0),
+      // Preserve FIFO semantics. Removed experimental settings from earlier
+      // releases are intentionally ignored, including values in saved flows.
+      maxQueue: toNum(config.maxQueue,50),
+      appendRssi: config.appendRssi === true, rssiGuardMs: toNum(config.rssiGuardMs,10), rssiTimeoutMs: toNum(config.rssiTimeoutMs,100)
+    });
+    this._makoState = engine.create(this);
+    this.on('close', (removed, done) => {
+      engine.close(this._makoState).then(() => done(), err => {this.error(err);done();});
+    });
   }
+  RED.nodes.registerType('smithtek-mako-rf-bus', SmithtekMakoRfBusConfig);
 
-  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;
+  function integer(value, min, max, label) {
+    const n = Number(value);
+    if (value === '' || value == null || !Number.isInteger(n) || n < min || n > max) throw new Error(label+' must be an integer from '+min+' to '+max);
+    return n;
   }
-
-  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);
+  function bool(value) {
+    if (value === true || value === 1 || value === 'true' || value === '1') return true;
+    if (value === false || value === 0 || value === 'false' || value === '0') return false;
+    throw new Error('Coil values must be true/false or 1/0');
   }
-  async function connectIfNeeded(cfg, state) {
-    if (!cfg) throw new Error("Bus config missing");
-
-    const portKey = makePortKey(cfg);
-
-    // If serial settings have actually changed, reconnect.
-    if (state.lastPortKey && state.lastPortKey !== portKey) {
-      state.connected = false;
-
-      if (state.client.isOpen) {
-        await closeClientSafe(state);
-      }
-    }
-
-    // Trust the actual modbus-serial port state.
-    // If the serial port is already open, reuse it.
-    if (state.client.isOpen) {
-      state.connected = true;
-      state.lastPortKey = portKey;
-      return;
-    }
-
-    if (state.connected) {
-      state.connected = false;
-    }
-
-    // If another request is already opening the port, wait.
-    if (state.connecting) {
-      for (let i = 0; i < 200; i++) {
-        if (state.client.isOpen) {
-          state.connected = true;
-          state.lastPortKey = portKey;
-          return;
-        }
-
-        if (!state.connecting) break;
-        await sleep(50);
+  function requestFor(config, msg) {
+    const mode = config.mode || 'read';
+    if (!['read','write'].includes(mode)) throw new Error('Invalid request mode');
+    const fc = integer(config.fc == null ? (mode === 'read' ? 3 : 5) : config.fc,1,16,'Function');
+    if (!(mode === 'read' ? [1,2,3,4] : [5,6,15,16]).includes(fc)) throw new Error('Function does not match request mode');
+    const req = {mode,fc,unitid:integer(config.unitid == null ? 1 : config.unitid,1,247,'Device ID'),address:integer(config.address == null ? 0 : config.address,0,65535,'Address')};
+    if(mode === 'read') req.quantity = integer(config.quantity == null ? 1 : config.quantity,1,fc <= 2 ? 2000 : 125,'Quantity');
+    else {
+      let value = msg.payload;
+      if(config.valueSource === 'fixed') {
+        const raw = config.valueText;
+        if(config.valueType === 'json') value = JSON.parse(raw);
+        else if(config.valueType === 'number') value = raw;
+        else if(config.valueType === 'bool') value = bool(raw);
+        else value = raw;
       }
-    }
-
-    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",
-      };
-
-      // Only close if the library says the port is actually open.
-      if (state.client.isOpen) {
-        await closeClientSafe(state);
+      if(fc === 5) req.value = bool(value);
+      if(fc === 6) req.value = integer(value,0,65535,'Register value');
+      if(fc === 15 || fc === 16) {
+        if(!Array.isArray(value)) throw new Error('Multiple write requires an array');
+        integer(value.length,1,fc === 15 ? 1968 : 123,'Write length');
+        req.value = value.map(v => fc === 15 ? bool(v) : integer(v,0,65535,'Register value'));
       }
-
-      // Allow Linux/serialport time to release any previous lock.
-      await sleep(200);
-
-      await state.client.connectRTUBuffered(port, options);
-
-      // UI uses seconds; library uses milliseconds.
-      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;
-
-    } catch (err) {
-      state.connected = false;
-      throw err;
-
-    } finally {
-      state.connecting = false;
     }
+    const length = req.quantity || (Array.isArray(req.value) ? req.value.length : 1);
+    if(req.address + length > 65536) throw new Error('Request extends beyond register address 65535');
+    return req;
   }
 
-
-  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 faultInfo(err, config, cfg, req) {
+    const code = err.code || (err.modbusCode ? 'MODBUS_EXCEPTION_'+err.modbusCode : 'ECOMM');
+    const message = String(err.message || err);
+    const labels = {ECONFIG:'Configuration error',EDECODE:'Decode error',EQUEUEFULL:'Queue full',
+      EQUEUEEXPIRED:'Queue expired',EOFFLINE:'Offline',EPORTBUSY:'Port busy',ECLOSE:'Serial close failure',
+      EDISCONNECT:'Serial disconnected',EIO:'Serial error',ENOENT:'Serial port unavailable',EACCES:'Serial permission denied'};
+    let reason = labels[code];
+    if (!reason && err.modbusCode) reason = 'Modbus exception '+err.modbusCode;
+    if (!reason && (code === 'ETIMEDOUT' || /timed?\s*out|timeout/i.test(message))) reason = 'Timeout';
+    if (!reason && code === 'EDEADLINE') reason = /request/i.test(message) ? 'Timeout' : 'Operation deadline';
+    if (!reason && /crc/i.test(message)) reason = 'CRC error';
+    if (!reason) reason = 'Communication error';
+    const port = cfg && cfg.serialPort;
+    const channel = {'/dev/ttyAMA2':'RF','/dev/ttyAMA0':'RS485-1','/dev/ttyAMA1':'RS485-2'}[port] || (cfg && cfg.busName) || 'Bus';
+    const prefix = String(config.prefix == null ? '' : config.prefix).trim();
+    const label = prefix || String(config.name || '').trim();
+    const unitid = req ? req.unitid : (config.unitid == null ? 1 : config.unitid);
+    const link = channel === 'RF' ? 'RF' : /^RS485/.test(channel) ? 'RS485 wiring' : 'connection';
+    const advice = {
+      'Timeout':'Not communicating — check power/'+link+'; disable if out of service',
+      'Configuration error':'Setup error — check node settings',
+      'Decode error':'Data format error — check register map/scaling',
+      'Queue full':'Polling overloaded — reduce polling rate',
+      'Queue expired':'Polling delayed — reduce polling rate',
+      'Offline':'Polling paused — check device availability',
+      'Port busy':'Bus in use — check duplicate bus settings',
+      'Serial close failure':'Gateway port fault — check bus connection',
+      'Serial disconnected':'Gateway disconnected — check bus connection',
+      'Serial error':'Gateway port fault — check bus connection',
+      'Serial port unavailable':'Gateway port missing — check bus settings',
+      'Serial permission denied':'Gateway port blocked — check access permissions',
+      'Operation deadline':'Gateway operation stalled — check bus connection',
+      'CRC error':'Invalid reply — check '+link+' link'
+    };
+    const summary = advice[reason] || (err.modbusCode ? 'Request rejected — check function/register settings' : 'Communication fault — check power/'+link);
+    const key = [label,channel,'ID'+unitid,summary].filter(Boolean).join(' ');
+    return {key,code,message,reason,summary,channel,unitid,prefix,node:config.name || '',timestamp:new Date().toISOString()};
   }
 
-  function scheduleProcess(state, busId) {
-    if (state.busy) return;
-    state.busy = true;
-
-    (async () => {
-        await sleep(20);
-      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 || "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
+  function SmithtekMakoRfNode(config) {
+    RED.nodes.createNode(this,config);
+    const node = this;
+    node._makoClosed = false;
+    const states = new Set();
+    node.on('input',(msg,send,done) => {
+      send = send || (m => node.send(m));
+      done = done || (err => {if(err)node.error(err,msg);});
+      let completed = false;
+      const completeOnce = err => {if(!completed){completed=true;done(err);}};
+      const cfg = RED.nodes.getNode(config.bus);
+      let req;
+      const complete = (err,res) => {
+        let failure = err;
+        try {
+          if(node._makoClosed || (failure && failure.code === 'ECANCELLED')) return;
+          let payload;
+          if (!failure) {
             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;
-
-            node.warn(`${busName}: RF error fc${req.fc} uid${req.unitid} try ${attempt}/${totalTries}: ${err.message || err}`);
-
-            if (attempt < totalTries && gap_s > 0) {
-              await sleep(Math.floor(gap_s * 1000));
+              payload = req.mode === 'read' && res && Array.isArray(res.data) ? decodeWithItems(res.data,config.items || [],config.prefix) : res;
+            } catch (decodeError) {
+              failure = decodeError;
+              failure.code = 'EDECODE';
             }
           }
-        }
-
-        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;
-        }
-
-        // ---- OPTIONAL RSSI APPEND (after successful Modbus) ----
-
-        try {
-          const appendRssi = !!cfg.appendRssi;
-          if (appendRssi && req.mode === "read" && cfg.serialPort === "/dev/ttyAMA2") {
-            const guardMs = toNum(cfg.rssiGuardMs, 10);
-            const timeoutMs = toNum(cfg.rssiTimeoutMs, 100);
-
-
-            const rssiDbm = await queryRssiOnSamePort(state, guardMs, timeoutMs);
-            await sleep(30);
-            state.connected = false;
-try {
-  await new Promise((resolve) => state.client.close(() => resolve()));
-} catch (_e) {}
-
-
-
-            const nodeKeyBase = sanitizeKey(node.name || busName || "mako_rf");
-            const key = `${nodeKeyBase}_rssi_dbm`;
-
-            if (msg.payload && typeof msg.payload === "object" && !Array.isArray(msg.payload)) {
-              msg.payload[key] = rssiDbm;
-            } else {
-              msg.rssi_dbm = rssiDbm;
-            }
+          msg.modbus = {ok:!failure,bus:cfg && cfg.busName,req};
+          if(res) msg.modbus.raw = res;
+          if(failure) {
+            const fault = faultInfo(failure,config,cfg,req);
+            msg.modbus.error = fault.message;
+            msg.modbus.code = fault.code;
+            msg.modbus.fault = fault;
+            msg.payload = {[fault.key]:1};
+            node.status({fill:failure.code === 'EOFFLINE' ? 'yellow' : 'red',shape:'ring',text:fault.message});
+          } else {
+            msg.payload = payload;
+            if(msg._makoRssi != null) {msg.payload[sanitizeKey(node.name || config.name || cfg.busName)+'_rssi_dbm']=msg._makoRssi;delete msg._makoRssi;}
+            node.status({fill:'green',shape:'dot',text:'ok uid'+req.unitid});
           }
-        } catch (e) {
-          msg.rssi_error = (e && e.message) ? e.message : String(e);
-        }
-        // -------------------------------------------------------
-
-        send(msg);
-        done();
-
-      }
-    })().finally(() => {
-      state.busy = false;
-      // If something got queued right as we finished, kick the processor again
-      if (state.queue.length > 0) {
-        scheduleProcess(state, busId);
-      }
-    });
-
-  }
-
-  // =========================
-  // Config Node: smithtek-mako-rf-bus
-  // =========================
-  function SmithtekMakoRfBusConfig(n) {
-    RED.nodes.createNode(this, n);
-
-    this.busName = (n.busName || "mako rf").trim();
-    this.serialPort = n.serialPort || "";
-// ADD THESE HERE:
-    this.appendRssi   = !!n.appendRssi;
-    this.rssiGuardMs  = toNum(n.rssiGuardMs, 10);
-    this.rssiTimeoutMs = toNum(n.rssiTimeoutMs, 100);
-
-    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);
-    this.maxQueue = toNum(n.maxQueue, 50);
-
-    BUS.delete(this.id);
-    ensureBusState(this);
-
-    this.on("close", (removed, done) => {
-      const s = BUS.get(this.id);
-      if (s) {
-        // Clear queue and reset flags
-        s.queue = [];
-        s.busy = false;
-
-        try {
-          s.client.close(() => {});
-        } catch (_e) {}
-
-        if (removed) {
-          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;
-    // TEMP: until we add editor UI in the .html
-//    node._config_appendRssi = !!config.appendRssi;      // set true in flow JSON to enable
-  //  node._config_rssiGuardMs = toNum(config.rssiGuardMs, 3);
-//    node._config_rssiTimeoutMs = toNum(config.rssiTimeoutMs, 50);
-
-    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;
-      }
-
-      const maxQ = clampInt(busCfg.maxQueue, 1, 1000, 50);
-
-      // If queue is full, drop NEW requests (keeps fairness for the ones already queued)
-      const qItem = { node, msg, send, done, req, items };
-      const isWrite = (req.mode === "write");
-
-      // If queue is full:
-      // - NEVER drop writes
-      // - Drop one pending READ to make room
-      if (state.queue.length >= maxQ) {
-        if (isWrite) {
-          const idx = state.queue.findIndex(it => it && it.req && it.req.mode === "read");
-          if (idx >= 0) state.queue.splice(idx, 1);
-          else {
-            try { done(); } catch (_e) {}
-            return;
-          }
-        } else {
-          try { done(); } catch (_e) {}
-          return;
-        }
-      }
-
-      // PRIORITY: writes go to the FRONT
-      if (isWrite) state.queue.unshift(qItem);
-      else state.queue.push(qItem);
-
-      scheduleProcess(state, busCfg.id);
-
-
-    });
-
-    node.on("close", function (_removed, done) {
+          // Cloud output always carries either decoded data or the friendly alarm.
+          // The second output contains a separate technical error payload.
+          const debugMsg = failure ? Object.assign({}, msg, {
+            payload: {ok:false,error:msg.modbus.error,code:msg.modbus.code,req},
+            modbus: Object.assign({}, msg.modbus)
+          }) : null;
+          send([msg, debugMsg]);
+        } catch(e) {completeOnce(e);return;}
+        finally {completeOnce(failure || undefined);}
+      };
       try {
-        const busCfg = RED.nodes.getNode(config.bus);
-        if (busCfg) {
-          const s = BUS.get(busCfg.id);
-          if (s) {
-            s.queue = [];
-            s.busy = false;
-
-            if (typeof s._rssiCleanup === "function") {
-              try { s._rssiCleanup(); } catch (_e) {}
-            }
-
-            s.connected = false;
-            try { s.client.close(() => {}); } catch (_e) {}
+        req=requestFor(config,msg);
+        if(req.mode === 'read') (config.items || []).forEach(item => {
+          if(item.scaleMode === 'range') {
+            if(['bool','digital to unsigned binary encoder'].includes(String(item.type).toLowerCase())) throw new Error((item.name || 'Decoder item') + ': range scaling requires a numeric register type');
+            try { rangeScaling.endpoints(item); } catch(err) { throw new Error((item.name || 'Decoder item') + ': ' + err.message); }
           }
-        }
-      } catch (_e) {}
-
-      node.status({});
-      done();
+        });
+        if(!cfg || !cfg._makoState) throw new Error('No Mako bus configured');
+        const state=cfg._makoState;states.add(state);
+        engine.enqueue(state,{node,req,complete,after: async () => {
+          if(cfg.appendRssi && cfg.serialPort === '/dev/ttyAMA2' && req.mode === 'read') {
+            try {msg._makoRssi = await engine.rssi(state,buildRssiCommandBuffer,tryParseRssiAck);}
+            catch(e){if(e.code === 'ECANCELLED')throw e;msg.rssi_error=e.message;}
+          }
+        }});
+      }catch(err){if(!err.code) err.code='ECONFIG';complete(err);}
+    });
+    node.on('close',(_removed,done)=>{
+      node._makoClosed=true;
+      states.forEach(state=>engine.detach(state,node));
+      node.status({});done();
     });
-
-
   }
-
-  RED.nodes.registerType("smithtek-mako-rf", SmithtekMakoRfNode);
+  RED.nodes.registerType('smithtek-mako-rf', SmithtekMakoRfNode);
 };