smithtek-mako-rf 3.1.0 → 3.2.4

package/README.md

@@ -1,3 +1,47 @@
+Digital read outputs in msg.payload use numeric 1 (on) and 0 (off), including coils (FC1), discrete inputs (FC2), and individual register bits. The raw Modbus response retains its original representation. Coil writes still accept true/false and 1/0.
+
+# Simple bus settings and range scaling — 3.2.4
+
+The bus editor retains the original timeout, retries, gap, maximum queue and RSSI controls. Queue age, coalescing, offline probe and recovery-quiet controls have been removed. Any saved values for those removed controls are ignored. All accepted requests wait in FIFO order; recovery timing is managed internally. The Range option in the decoder table remains available.
+
+Each numeric decoder row has a compact Scaling dropdown: None (unchanged), Math (+ − × ÷), or Range (input → output). New rows start at None, with all calculation fields hidden. Math and Range settings appear beside the dropdown on the same line. Range shows In low, In high, Out low, Out high and Clamp side by side. Every decoder entry stays on one line; narrow dialogs scroll horizontally. Selecting None hides the fields and disables both calculations, retaining the entered settings for reuse. Existing configured Math and Range rows keep their active mode.
+
+For Range, enter Input low, Input high, Output low and Output high. For example:
+
+| Input low | Input high | Output low | Output high | Result at input 12 |
+|---|---|---|---|---|
+| 4 | 20 | 0 | 100 | 50 |
+
+The input endpoints must match the values reported in Modbus registers. If a sensor reports 4000–20000 instead of 4–20, enter 4000 and 20000. No PLC calculation or extra Function node is needed.
+
+Range scaling uses outputLow + (value - inputLow) * (outputHigh - outputLow) / (inputHigh - inputLow). It operates on the decoded numeric value after any existing integer mask. Range replaces the Math expression, retaining that expression for switching back. Negative, decimal and reversed ranges are supported. Equal input endpoints and invalid/nonfinite values are rejected. Digital/boolean rows cannot use Range mode.
+
+Values outside the input span continue along the same line unless Clamp to output range is checked. For example, 0 mA maps to -25 for a 4–20 to 0–100 range; with Clamp it maps to 0. Floating-point results are not automatically rounded.
+
+Existing rows without a scaling mode continue using Math. Raw Modbus data remains available in msg.modbus.raw. All FIFO queue and recovery behaviour from 3.1.2 is retained, and dependencies are unchanged.
+
+---
+# Reliability update 3.1.2
+
+This release retains the pinned serial dependencies and supports Node.js 14 syntax.
+
+- One worker owns each bus. Closing a runtime node cancels only its own work.
+- Open, request, diagnostic and close operations have deadlines. A port whose close cannot be confirmed stays quarantined rather than acquiring a second owner.
+- Serial errors are handled. Dead connections are retired before reopening.
+- Writes use FIFO order. Queue overflow, expiry and superseded polls return explicit errors and complete once.
+- Every accepted request is retained in FIFO order, including repeated reads from the same node. Requests are not coalesced or expired while waiting.
+- Each queued request gets the configured timeout retry count before moving to the next. There is no offline cooldown or skipped polling.
+- After a communication error, the bus waits for a quiet period and flushes stale buffered data. Automatic quiet time is the response timeout on RF and 100ms on RS485. Late RF frames outside that interval remain a protocol limitation: Modbus RTU read replies carry no register address or transaction ID.
+- RSSI queries verify their checksum, isolate diagnostic bytes, settle on cancellation and retain the serial connection after success.
+- Invalid addresses, quantities and write values are rejected before transmission. Signed scale expressions add/subtract, and incomplete 32-bit values are rejected.
+
+No additional bus settings are required. Recovery timing is automatic: the response timeout on RF and 100ms on RS485.
+
+Failures still emit msg.modbus.ok=false and a failure payload. msg.modbus.code identifies queue, offline and transport conditions; done(error) also enables Node-RED Catch handling. Intentional node/bus shutdown settles callbacks without emitting from closed nodes. No retry can guarantee a timed-out write was not applied at the device: retain an appropriate retry setting for the PLC command semantics.
+
+Validated on a Passport with Raspbian Buster, Node.js 14.21.3, native serial dependencies and two physical RF Makos. Node.js 16 has not been separately executed. No dependency upgrade is required.
+
+---
 **Installation**
 Install using the `NodeRED palette manager`
 

package/bus-engine.js

@@ -0,0 +1,281 @@
+'use strict';
+
+// Node.js 14 compatible. Exactly one worker and one serial owner per bus.
+module.exports = function createEngine(ModbusRTU) {
+  const owners = new Map();
+  const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+  const bounded = (v, fallback, min, max) => v != null && v !== '' && Number.isFinite(Number(v)) ? Math.min(max, Math.max(min, Number(v))) : fallback;
+  const error = (message, code) => Object.assign(new Error(message), { code });
+  const timeoutMs = cfg => bounded(cfg.timeout_s, 8, 1, 120) * 1000;
+  const portOf = client => client && client._port && client._port._client;
+
+  function create(cfg) {
+    return { cfg, queue: [], active: null, worker: null, closing: false, client: null,
+      cancel: null, dirty: false, transportFault: false, lastRx: 0, failures: new Map(), closePromise: null, ownerPath: null };
+  }
+
+  function operation(state, label, ms, start) {
+    return new Promise((resolve, reject) => {
+      let finished = false;
+      const finish = (err, value) => {
+        if (finished) return;
+        finished = true;
+        clearTimeout(timer);
+        if (state.cancel === cancel) state.cancel = null;
+        err ? reject(err) : resolve(value);
+      };
+      const cancel = err => finish(err || error('Operation cancelled', 'ECANCELLED'));
+      const timer = setTimeout(() => finish(error(label + ' deadline exceeded', 'EDEADLINE')), ms);
+      state.cancel = cancel;
+      if (state.closing) return cancel();
+      try { Promise.resolve(start()).then(value => finish(null, value), finish); } catch (err) { finish(err); }
+    });
+  }
+
+  function callbackCall(target, method, args) {
+    return new Promise((resolve, reject) => {
+      try { target[method].apply(target, (args || []).concat(err => err ? reject(err) : resolve())); }
+      catch (err) { reject(err); }
+    });
+  }
+
+  // Do not release ownership until the old descriptor really closed. A timed-out
+  // close blocks this port, but never blocks other physical buses or the worker.
+  async function retire(state) {
+    const client = state.client;
+    if (!client) return;
+    if (client._makoRetiring) return client._makoRetiring;
+    client._makoRetiring = new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = err => {
+        if (settled) return;
+        settled = true; clearTimeout(timer);
+        err ? reject(err) : resolve();
+      };
+      const release = () => {
+        if (state.client === client) state.client = null;
+        if (owners.get(state.ownerPath) === state) owners.delete(state.ownerPath);
+        client._makoClosed = true;
+      };
+      const timer = setTimeout(() => finish(error('Serial close deadline exceeded; port quarantined', 'ECLOSE')), 2000);
+      if (typeof client._cancelPendingTransactions === 'function') client._cancelPendingTransactions();
+      const close = () => {
+        try { client.close(err => {
+          if (!err || !client.isOpen) release();
+          finish(err && client.isOpen ? err : null);
+        }); } catch (err) { finish(err); }
+      };
+      // Opening cannot be cancelled by serialport. Wait for it to settle; close
+      // a late successful open, retaining the lease throughout.
+      if (client._makoOpening) client._makoOpening.then(close, () => {release(); finish();});
+      else close();
+    });
+    return client._makoRetiring;
+  }
+
+  async function connect(state) {
+    if (state.closing) throw error('Bus closing', 'ECANCELLED');
+    const cfg = state.cfg;
+    if (state.client && state.transportFault) await retire(state);
+    if (state.client && state.client._makoRetiring) await retire(state);
+    if (state.client && state.client.isOpen) return;
+    if (state.client) await retire(state);
+    const path = cfg.serialPort;
+    if (!path) throw error('No serial port configured', 'ECONFIG');
+    const owner = owners.get(path);
+    if (owner && owner !== state) throw error('Serial port already owned by another Mako bus: ' + path, 'EPORTBUSY');
+    owners.set(path, state); state.ownerPath = path;
+    const client = new ModbusRTU(); state.client = client;
+    const onFault = err => {
+      if (state.client !== client || client._makoRetiring) return;
+      state.dirty = true;
+      state.transportFault = true;
+      const failure = err instanceof Error ? err : error('Serial port disconnected', 'EDISCONNECT');
+      if (!failure.code) failure.code = 'ESERIAL';
+      if (state.cancel) state.cancel(failure);
+    };
+    client.on('error', onFault);
+    client.on('close', () => onFault(error('Serial port closed', 'EDISCONNECT')));
+    try {
+      await operation(state, 'Serial open', 5000, () => {
+        client._makoOpening = Promise.resolve(client.connectRTUBuffered(path, {
+          baudRate: bounded(cfg.baudRate, 9600, 1200, 921600), dataBits: 8,
+          stopBits: Number(cfg.stopBits) === 2 ? 2 : 1, parity: cfg.parity || 'none'
+        }));
+        return client._makoOpening;
+      });
+      client._makoOpening = null;
+      state.transportFault = false;
+      const port = portOf(client);
+      if (port) port.on('data', () => { if (state.client === client) state.lastRx = Date.now(); });
+      // Preserve a pending recovery interval across reconnects: bytes already
+      // travelling over RF can still arrive on the new descriptor.
+    } catch (err) {
+      await retire(state).catch(() => {});
+      throw err;
+    }
+  }
+
+  async function quiet(state, milliseconds) {
+    const start = Date.now();
+    // New bytes restart the quiet interval, but continuous noise has a deadline.
+    await operation(state, 'Serial quiet period', milliseconds * 3 + 1000, async () => {
+      while (!state.closing) {
+        const remaining = milliseconds - (Date.now() - Math.max(start, state.lastRx));
+        if (remaining <= 0) return;
+        await delay(Math.min(remaining, 50));
+      }
+      throw error('Bus closing', 'ECANCELLED');
+    });
+  }
+
+  async function recover(state) {
+    if (!state.dirty) return;
+    await connect(state);
+    // RTU has no transaction identity. Wait out late replies before reusing the
+    // parser. This is bounded mitigation, not a guarantee for arbitrary RF delay.
+    const guard = bounded(state.cfg.recoveryMs, state.cfg.serialPort === '/dev/ttyAMA2' ? timeoutMs(state.cfg) : 100, 50, 30000);
+    try {
+      await quiet(state, guard);
+      const port = portOf(state.client);
+      if (port && typeof port.flush === 'function') await operation(state, 'Serial flush', 1000, () => callbackCall(port, 'flush'));
+      if (state.client._port && Buffer.isBuffer(state.client._port._buffer)) state.client._port._buffer = Buffer.alloc(0);
+      state.dirty = false;
+    } catch (err) { await retire(state).catch(() => {}); throw err; }
+  }
+
+  async function request(state, req) {
+    await connect(state);
+    await recover(state);
+    const client = state.client;
+    client.setID(req.unitid); client.setTimeout(timeoutMs(state.cfg));
+    const methods = {1:'readCoils',2:'readDiscreteInputs',3:'readHoldingRegisters',4:'readInputRegisters',5:'writeCoil',6:'writeRegister',15:'writeCoils',16:'writeRegisters'};
+    try {
+      return await operation(state, 'Modbus request', timeoutMs(state.cfg) + 1000,
+        () => client[methods[req.fc]](req.address, req.mode === 'read' ? req.quantity : req.value));
+    } catch (err) {
+      if (!err.modbusCode) state.dirty = true;
+      if (state.transportFault || ['EDEADLINE','EDISCONNECT','ESERIAL'].includes(err.code) || !client.isOpen) await retire(state).catch(() => {});
+      throw err;
+    }
+  }
+
+  async function rssi(state, command, parse) {
+    const client = state.client;
+    const wrapper = client && client._port;
+    const port = portOf(client);
+    if (!port || !wrapper) throw error('RSSI serial port unavailable', 'ERSSI');
+    await operation(state, 'RSSI guard', 1100, () => delay(bounded(state.cfg.rssiGuardMs, 10, 0, 1000)));
+    await operation(state, 'RSSI flush', 1000, () => callbackCall(port, 'flush'));
+    // Suspend Modbus delivery while the radio's proprietary frame is read.
+    wrapper.removeListener('data', client._onReceive);
+    let listener;
+    try {
+      const value = await operation(state, 'RSSI', bounded(state.cfg.rssiTimeoutMs, 100, 10, 5000), () => new Promise((resolve, reject) => {
+        let rx = Buffer.alloc(0);
+        listener = chunk => {
+          rx = Buffer.concat([rx, chunk]).slice(-512);
+          const result = parse(rx); if (result) resolve(result.rssiDbm);
+        };
+        port.on('data', listener);
+        port.write(command(), err => { if (err) reject(err); else port.drain(err => {if(err)reject(err);}); });
+      }));
+      return value;
+    } catch (err) { state.dirty = true; throw err; }
+    finally {
+      if (listener) port.removeListener('data', listener);
+      if (Buffer.isBuffer(wrapper._buffer)) wrapper._buffer = Buffer.alloc(0);
+      if (!state.closing && state.client === client && !client._makoRetiring) wrapper.on('data', client._onReceive);
+    }
+  }
+
+  function finish(item, err, result) {
+    if (item.finished) return;
+    item.finished = true;
+    try { item.complete(err, result); } catch (e) { if (item.node.error) item.node.error(e); }
+  }
+
+  async function runItem(state, item) {
+    if (item.node._makoClosed) return finish(item, error('Node closed', 'ECANCELLED'));
+    const maxAge = bounded(state.cfg.maxAge_s, 0, 0, 3600);
+    if (maxAge > 0 && Date.now() - item.queuedAt > maxAge * 1000) return finish(item, error('Queued request expired', 'EQUEUEEXPIRED'));
+    const offline = state.failures.get(item.req.unitid);
+    if (item.req.mode === 'read' && offline && Date.now() < offline) return finish(item, error('Device offline; waiting for next probe', 'EOFFLINE'));
+    const cooldown = bounded(state.cfg.offlineCooldown_s,0,0,300);
+    // After the first failed retry group, one probe is enough to discover a
+    // returning device. Do not monopolize the bus with another retry group.
+    const tries = offline && cooldown > 0 && item.req.mode === 'read' ? 1 : Math.floor(bounded(state.cfg.retries, 2, 0, 10)) + 1;
+    let result, lastErr;
+    for (let attempt = 1; attempt <= tries && !state.closing && !item.node._makoClosed; attempt++) {
+      try {
+        item.node.status({fill:'blue',shape:'dot',text:'uid'+item.req.unitid+' try '+attempt+'/'+tries});
+        result = await request(state, item.req); lastErr = null; break;
+      } catch (err) {
+        lastErr = err;
+        if (item.node.warn) item.node.warn('uid'+item.req.unitid+' try '+attempt+'/'+tries+': '+err.message);
+        // Protocol exceptions and lifecycle/configuration errors cannot improve
+        // by repeating the same request. Timeouts retain configured retry semantics.
+        if (err.modbusCode || ['ECANCELLED','ECONFIG','EPORTBUSY','ECLOSE'].includes(err.code)) break;
+        if (attempt < tries) await operation(state, 'Retry gap', 61000, () => delay(bounded(state.cfg.gap_s, 0, 0, 60)*1000));
+      }
+    }
+    if (state.closing || item.node._makoClosed) return finish(item, error('Node or bus closed', 'ECANCELLED'));
+    if (lastErr) {
+      if (!lastErr.modbusCode && !['ECONFIG','EPORTBUSY','ECLOSE'].includes(lastErr.code)) state.failures.set(item.req.unitid, Date.now()+cooldown*1000);
+      finish(item, lastErr);
+    } else {
+      state.failures.delete(item.req.unitid);
+      if (item.after) await item.after(result);
+      finish(item, null, result);
+    }
+    await operation(state, 'Request gap', 61000, () => delay(bounded(state.cfg.gap_s,0,0,60)*1000));
+  }
+
+  function kick(state) {
+    if (state.worker || state.closing) return;
+    state.worker = Promise.resolve().then(async () => {
+      while (!state.closing && state.queue.length) {
+        const item = state.queue.shift(); state.active = item;
+        try { await runItem(state, item); } catch (err) { finish(item, err); }
+        finally { state.active = null; }
+      }
+    }).catch(err => { if (state.active) finish(state.active, err); }).finally(() => {
+      state.worker = null;
+      if (!state.closing && state.queue.length) kick(state);
+    });
+  }
+
+  function enqueue(state, item) {
+    item.queuedAt = Date.now();
+    if (state.closing || item.node._makoClosed) return finish(item, error('Bus or node closed', 'ECANCELLED'));
+    // Retain only the newest pending read from this node. Never coalesce writes.
+    if (state.cfg.coalesceReads === true && item.req.mode === 'read') {
+      const idx = state.queue.findIndex(q => q.node === item.node && q.req.mode === 'read');
+      if (idx >= 0) finish(state.queue.splice(idx,1)[0],error('Superseded by newer poll','ESUPERSEDED'));
+    }
+    if (state.queue.length >= bounded(state.cfg.maxQueue,50,1,1000)) return finish(item,error('Bus queue full','EQUEUEFULL'));
+    state.queue.push(item); kick(state);
+  }
+
+  function detach(state, node) {
+    node._makoClosed = true;
+    state.queue = state.queue.filter(item => {if(item.node!==node)return true;finish(item,error('Node closed','ECANCELLED'));return false;});
+    if (state.active && state.active.node === node && state.cancel) {
+      state.dirty = true; state.cancel(error('Node closed','ECANCELLED'));
+    }
+  }
+
+  function close(state) {
+    if (state.closePromise) return state.closePromise;
+    state.closing = true;
+    const queued = state.queue.splice(0);
+    queued.forEach(item => finish(item,error('Bus closed','ECANCELLED')));
+    if (state.cancel) state.cancel(error('Bus closed','ECANCELLED'));
+    state.closePromise = (async () => {
+      if (state.worker) await state.worker;
+      await retire(state);
+    })();
+    return state.closePromise;
+  }
+  return { create, enqueue, detach, close, rssi };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smithtek-mako-rf",
-  "version": "3.1.0",
+  "version": "3.2.4",
   "description": "Smithtek dedicated node for communicating with the Mako PLC over RS485 or RF",
   "keywords": [
     "node-red",
@@ -13,13 +13,16 @@
   "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"
-},
+  "dependencies": {
+    "modbus-serial": "8.0.23-no-serial-port",
+    "serialport": "10.4.0"
+  },
   "node-red": {
     "nodes": {
       "smithtek-mako-rf": "smithtek-mako-rf.js"
     }
+  },
+  "engines": {
+    "node": ">=14"
   }
 }

package/range-scaling.js

@@ -0,0 +1,26 @@
+'use strict';
+
+function endpoints(item) {
+  const values = ['inputLow', 'inputHigh', 'outputLow', 'outputHigh'].map(key => {
+    const raw = item[key];
+    if ((typeof raw !== 'number' && typeof raw !== 'string') || String(raw).trim() === '' || !Number.isFinite(Number(raw))) {
+      throw new Error('Range scaling: ' + key + ' must be a finite number');
+    }
+    return Number(raw);
+  });
+  if (values[0] === values[1]) throw new Error('Range scaling: input low and input high must differ');
+  if (!Number.isFinite(values[1] - values[0]) || !Number.isFinite(values[3] - values[2])) throw new Error('Range scaling: endpoints are too far apart');
+  return values;
+}
+
+function scale(value, item) {
+  if (typeof value !== 'number' || !Number.isFinite(value)) throw new Error('Range scaling requires a finite numeric value');
+  const [inputLow, inputHigh, outputLow, outputHigh] = endpoints(item);
+  let fraction = (value - inputLow) / (inputHigh - inputLow);
+  if (item.clampRange === true) fraction = Math.max(0, Math.min(1, fraction));
+  const result = outputLow + fraction * (outputHigh - outputLow);
+  if (!Number.isFinite(result)) throw new Error('Range scaling result is not finite');
+  return result;
+}
+
+module.exports = { endpoints, scale };

package/smithtek-mako-rf.html

@@ -26,6 +26,12 @@
       offset: 0,      // BYTES stored in config (legacy decoder compatibility)
       length: 1,      // stored but hidden (1=16-bit, 2=32-bit)
       scale: "",
+      scaleMode: "none",
+      inputLow: 4,
+      inputHigh: 20,
+      outputLow: 0,
+      outputHigh: 100,
+      clampRange: false,
       offsetbit: 0
     };
   }
@@ -58,10 +64,42 @@
     } else {
       $bit.val(0);
       $bit.prop("disabled", true).hide();
-      $bitCol.hide();
+      $bitCol.show();
+    }
+    updateScaleUi($tr);
+  }
+
+  function updateScaleUi($tr) {
+    const mode = $tr.find('.st-scale-mode').val();
+    const range = mode === 'range';
+    const digital = isDigitalUnsigned($tr.find('.st-item-type').val());
+    $tr.find('.st-item-scale').toggle(mode === 'math');
+    $tr.find('.st-range-fields').toggle(range);
+    $tr.find('.st-range-note').toggle(range && digital);
+    const inputs = $tr.find('.st-range-number');
+    inputs.each(function () {
+      const raw = String($(this).val()).trim();
+      const bad = range && (raw === '' || !Number.isFinite(Number(raw)));
+      this.setCustomValidity(bad ? 'Enter a finite number.' : '');
+      $(this).attr('aria-invalid', bad ? 'true' : 'false');
+    });
+    const low = $tr.find('.st-inputLow'), high = $tr.find('.st-inputHigh');
+    if (range && String(low.val()).trim() !== '' && String(high.val()).trim() !== '' && Number(low.val()) === Number(high.val())) {
+      high[0].setCustomValidity('Input low and input high must differ.');
+      high.attr('aria-invalid', 'true');
     }
   }
 
+  function validDecoderItems(items) {
+    return Array.isArray(items) && items.every(item => {
+      if (item.scaleMode !== 'range') return true;
+      if (isDigitalUnsigned(item.type) || item.type === 'bool') return false;
+      const values = ['inputLow','inputHigh','outputLow','outputHigh'].map(key => item[key]);
+      return values.every(value => (typeof value === 'string' || typeof value === 'number') && String(value).trim() !== '' && Number.isFinite(Number(value))) &&
+        Number(item.inputLow) !== Number(item.inputHigh) && Number.isFinite(Number(item.inputHigh)-Number(item.inputLow)) && Number.isFinite(Number(item.outputHigh)-Number(item.outputLow));
+    });
+  }
+
   // Determine next row behaviour based on the last row (REGS visible)
   function nextRowFromLast($tbody) {
     const $last = $tbody.find("tr").last();
@@ -135,7 +173,27 @@
       .attr("type", "text")
       .addClass("st-item-scale")
       .css("width", "100%")
-      .val(it.scale ?? "");
+      .val(it.scale ?? it.scaler ?? it.scaleFactor ?? "");
+
+    const $scaleMode = $('<select></select>').addClass('st-scale-mode').attr('aria-label','Scaling mode').css({width:'82px',flex:'0 0 82px'})
+      .attr('title','None: unchanged; Math: expression such as /100; Range: input low/high to output low/high.')
+      .append($('<option value="none">None</option>'))
+      .append($('<option value="math">Math</option>'))
+      .append($('<option value="range">Range</option>'))
+      .val(it.scaleMode === 'none' ? 'none' : it.scaleMode === 'range' ? 'range' : String($scale.val()).trim() ? 'math' : 'none');
+    $scale.css({width:'100px',flex:'0 0 100px'}).attr('placeholder','/100 or +5').attr('aria-label','Math expression');
+    const $rangeFields = $('<div></div>').addClass('st-range-fields').css({display:'flex','align-items':'center',gap:'5px','flex-wrap':'nowrap'});
+    const $grid = $('<div></div>').css({display:'flex','align-items':'center',gap:'5px','flex-wrap':'nowrap'});
+    [['inputLow','In low',4],['inputHigh','In high',20],['outputLow','Out low',0],['outputHigh','Out high',100]].forEach(([key,label,fallback]) => {
+      const $input = $('<input/>').attr({type:'number',step:'any','aria-label':label,title:label.replace('In ', 'Input ').replace('Out ', 'Output ')}).addClass('st-range-number st-'+key).css({width:'62px','min-width':'62px',padding:'4px'}).val(it[key] ?? fallback);
+      const $label = $('<label></label>').css({display:'flex','align-items':'center',gap:'3px',width:'auto','white-space':'nowrap','font-size':'10px',margin:0}).append($('<span></span>').text(label)).append($input);
+      $input.on('input',() => updateScaleUi($tr));
+      $grid.append($label);
+    });
+    const $clamp = $('<input/>').attr('type','checkbox').addClass('st-clamp-range').prop('checked',it.clampRange === true).css({width:'auto',margin:'0 5px 0 0'});
+    $rangeFields.append($grid).append($('<label></label>').css({display:'flex','align-items':'center',width:'auto','white-space':'nowrap','font-size':'11px',margin:0}).append($clamp).append(document.createTextNode('Clamp')));
+    $rangeFields.append($('<div></div>').addClass('st-range-note').attr('title','Choose a numeric register type for range scaling.').css({color:'#b33','font-size':'11px'}).text('!'));
+    $scaleMode.on('change',() => updateScaleUi($tr));
 
     const $offsetbit = $("<input/>")
       .attr("type", "number")
@@ -166,7 +224,7 @@
     $tr.append($("<td></td>").append($name));
     $tr.append($("<td></td>").append($type));
     $tr.append($("<td></td>").append($offsetRegs).append($offsetBytes));
-    $tr.append($("<td></td>").append($scale));
+    $tr.append($("<td></td>").append($("<div></div>").addClass("st-scaling-inline").css({display:"flex","align-items":"center",gap:"5px","flex-wrap":"nowrap"}).append($scaleMode).append($scale).append($rangeFields)));
 
     const $bitTd = $("<td></td>").addClass("st-bit-col").append($offsetbit);
     $tr.append($bitTd);
@@ -194,6 +252,12 @@
         offset: Number($tr.find(".st-item-offset").val()) || 0,      // BYTES saved
         length: Number($tr.find(".st-item-length").val()) || 1,      // hidden but saved
         scale: String($tr.find(".st-item-scale").val() ?? "").trim(),
+        scaleMode: $tr.find('.st-scale-mode').val() || 'none',
+        inputLow: String($tr.find('.st-inputLow').val() ?? '').trim(),
+        inputHigh: String($tr.find('.st-inputHigh').val() ?? '').trim(),
+        outputLow: String($tr.find('.st-outputLow').val() ?? '').trim(),
+        outputHigh: String($tr.find('.st-outputHigh').val() ?? '').trim(),
+        clampRange: $tr.find('.st-clamp-range').prop('checked') === true,
         offsetbit: Number($tr.find(".st-item-offsetbit").val()) || 0
       });
     });
@@ -318,7 +382,7 @@
       valueText: { value: "" },
       includeWriteQuantity: { value: false },
 
-      items: { value: [ defaultItemRow() ] }
+      items: { value: [ defaultItemRow() ], validate: validDecoderItems }
     },
     inputs: 1,
     outputs: 1,
@@ -414,7 +478,7 @@
       <label for="node-config-input-appendRssi"><i class="fa fa-signal"></i> RSSI</label>
       <input type="checkbox" id="node-config-input-appendRssi" style="width:auto;">
       <span style="margin-left:8px; font-size:12px; color:#888;">
-        (Tick on RSSI diagnostic in dBi, using this feeature slows down RF polling by 30%.)
+        (Append RSSI in dBm. Diagnostics add one radio query per successful read.)
       </span>
     </div>
 
@@ -468,7 +532,7 @@
     <input type="number" id="node-config-input-maxQueue" min="1" style="width:140px;">
   </div>
   <div class="form-tips">
-    The max queue will limmit how many polls can be queued from the connected devices. It will drop the oldest from the queue.
+    Requests wait in order. Each request finishes or exhausts its timeout retries before the next starts. New requests are reported as failed if the queue is full.
   </div>
 
 
@@ -581,30 +645,33 @@
     </div>
 
     <div class="form-row">
-      <table class="table table-condensed" style="width:100%;">
+      <div style="overflow-x:auto;"><table class="table table-condensed" style="width:100%; min-width:1100px; table-layout:fixed;">
         <thead>
           <tr>
-            <th style="width:28%;">Name </th>
-            <th style="width:26%;">Register data Type</th>
-            <th style="width:14%;">Offset (regs)</th>
-            <th style="width:22%;">Scale</th>
-            <th style="width:6%;">Bit</th>
-            <th style="width:4%;">Action</th>
+            <th style="width:20%;">Name </th>
+            <th style="width:145px;">Register data Type</th>
+            <th style="width:65px;">Offset</th>
+            <th style="width:565px;">Scaling</th>
+            <th style="width:42px;">Bit</th>
+            <th style="width:55px;">Action</th>
           </tr>
         </thead>
         <tbody id="st-items-tbody"></tbody>
-      </table>
+      </table></div>
     </div>
 
     <div style="font-size:12px; color:#666; margin-top:6px;">
   (Register Offsets numbers should match the modbus table you have built in V-NET!, if you add a digital it will automatically increase the bit number. Bit 1 = digital 1 and so on.
     </div>
+    <div class="form-tips">None keeps the row compact and applies no scaling. Choose Math for an inline expression such as /100, or Range to map input low/high to output low/high. Use the values actually reported by the Mako: for example 4–20 to 0–100, or 4000–20000 to 0–100 if the register reports microamps. Range replaces the Math expression. Values outside the input range continue scaling unless Clamp is checked.</div>
   </div>
 </script>
 
 <script type="text/markdown" data-help-name="smithtek-mako-rf">
-Smithtek Mako RF (RS-485 only).
+Smithtek Mako RF / RS485.
 
-Read mode outputs decoded JSON in msg.payload using the Decoder map rows.
+Read mode outputs decoded JSON in msg.payload using the Decoder map rows. Digital points (coils, discrete inputs and register bits) output numeric 1 for on and 0 for off.
 Raw modbus response is kept in msg.modbus.raw.
+
+Each numeric decoder row starts compact with None (unchanged). Choose Math or Range to show the inline settings and enable scaling. Selecting None hides both controls and disables both calculations, while retaining the entered settings. Range maps input low/high to output low/high using a straight line; for example 4–20 maps to 0–100, with 12 mapping to 50. Use raw register endpoints, not assumed electrical units. Input endpoints must differ. Reversed ranges and negative/decimal endpoints are supported. Clamp optionally limits output to the configured range. Existing rows without a scaling mode retain their Math expression.
 </script>

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,76 +77,6 @@ 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) {
     if (!path || typeof path !== "string") {
@@ -162,6 +90,7 @@ state._rssiCleanup = cleanup;
 
     if (!parts.length) return;
 
+    if (parts.some(k => ["__proto__","prototype","constructor"].includes(k))) throw new Error("Invalid decoder property path");
     let ref = obj;
     for (let i = 0; i < parts.length - 1; i++) {
       const k = parts[i];
@@ -213,7 +142,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 +226,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);
@@ -342,6 +271,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 +291,139 @@ 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);
+        }
       }
 
+      // 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, "=>");
     }
 
     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);
+  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;
       }
-    }
-
-    // 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);
-      }
-    }
-
-    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);
-      }
-
-      // 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;
-    }
-  }
-
-
-  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);
+      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'));
       }
-
-      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}`);
     }
+    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;
   }
 
-  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
-            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));
-            }
-          }
-        }
-
-        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;
-            }
-          }
-        } 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);
+    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;
+    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) => {
+        try {
+          if(node._makoClosed || (err && err.code === 'ECANCELLED')) return;
+          msg.modbus = {ok:!err,bus:cfg && cfg.busName,req};
+          if(err) {
+            msg.modbus.error = err.message || String(err);
+            msg.modbus.code = err.code || (err.modbusCode ? 'MODBUS_EXCEPTION_'+err.modbusCode : 'ECOMM');
+            msg.payload = {ok:false,error:msg.modbus.error,req};
+            node.status({fill:err.code === 'EOFFLINE' ? 'yellow' : 'red',shape:'ring',text:msg.modbus.error});
+          } else {
+            msg.modbus.raw = res;
+            msg.payload = req.mode === 'read' && res && Array.isArray(res.data) ? decodeWithItems(res.data,config.items || []) : res;
+            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});
           }
-        } 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) {
+          send(msg);
+        } catch(e) {completeOnce(e);return;}
+        finally {completeOnce(err || 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){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);
 };