smithtek-mako-rf 3.1.0 → 3.3.2

package/README.md

@@ -1,3 +1,82 @@
+# Cloud data/alarms and local debug — 3.3.2
+
+- **Top pin, output 1 — Data / alarm:** successful decoded readings and write responses, or the friendly named fault JSON when a request fails. Connect this to the cloud flow.
+- **Bottom pin, output 2 — Debug:** technical error payloads containing `ok:false`, `error`, `code` and `req`. Connect this to a local Debug node, or leave it disconnected. Successful requests send nothing here.
+
+A timeout alarm is emitted after **one poll exhausts its configured retries**. Retries 0 means one failed attempt; retries 2 means three failed attempts. There is no separate bad-poll counter. If a retry succeeds, only normal data is emitted. Permanent Modbus exceptions (such as an unsupported register), invalid configuration and queue rejection are reported immediately. Each failed poll emits one friendly alarm on output 1 and one technical message on output 2. Intentional shutdown/redeploy cancellation emits neither.
+
+Existing first-output wires keep both data and friendly alarms. Node-RED logs, status and Catch handling remain enabled. Refresh the editor after updating to see the pin labels. This corrects the output routing introduced in 3.3.1.
+
+---
+
+# Prefixes and operator fault messages — 3.3.0
+
+## Prefix
+
+Set the node's **Prefix** once, for example `b1`. A decoder row named `Pressure` then outputs `{"b1 Pressure":12}`. Copy the node and change its prefix to `b2` to reuse every table entry without renaming them. Leading/trailing prefix whitespace is trimmed, and exactly one space separates it from the row name. A blank prefix preserves existing output names. Existing nested names retain their structure: `tank=>level` becomes `{"b1 tank":{"level":12}}`.
+
+## Operator fault JSON
+
+Failed requests emit a flat numeric alarm on output 1 in `msg.payload`, suitable for forwarding as a named cloud value. For example:
+
+```json
+{"b1 RF ID2 Not communicating — check power/RF; disable if out of service":1}
+```
+
+The key uses the prefix (or node Name when no prefix is set), actual channel (RF, RS485-1 or RS485-2), device ID and a short operator message. RS485 timeouts advise checking power and wiring. Disabling an out-of-service asset is operator advice; the node never disables a device automatically.
+
+Only a final failed request emits this alarm: a timeout that recovers within its configured retries produces normal data, with no fault payload. Permanent device exceptions and configuration errors are reported immediately when retrying cannot help. Each failed poll emits one fault message. Queue overload, gateway port problems, invalid configuration and decoding failures have distinct messages; they are not described as RF failures. Intentional shutdown/redeploy cancellation emits no fault alarm. An optional RSSI diagnostic failure remains in `msg.rssi_error` and does not turn a successful register read into an asset communication fault.
+
+Full technical details remain in `msg.modbus`: `ok:false`, `code`, `error`, `req`, and `fault` (key, reason, operator summary, channel, device ID, prefix, node name and timestamp). Node-RED Catch handling remains supported. Successful requests output normal prefixed readings. No synthetic zero/clear alarm is sent on recovery; cloud alarm reset/expiry must be handled by the receiving flow or service.
+
+**Output change:** failure payloads previously contained `{ok:false,error,req}`; they now contain the flat named alarm above. Use `msg.modbus.ok`, `msg.modbus.error` and `msg.modbus.req` in flows that inspect errors. This package does not connect to or configure 3dm.space; compatibility with a particular cloud ingestion schema must be verified there.
+
+---
+
+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.
+- Reads and writes use FIFO order. Queue overflow returns an explicit error and completes 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 emit msg.modbus.ok=false and the fault payload documented above. 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.3.2",
   "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
       });
     });
@@ -305,6 +369,7 @@
     color: "#B9B6B8",
     defaults: {
       name: { value: "" },
+      prefix: { value: "" },
       bus: { type: "smithtek-mako-rf-bus", required: true },
 
       mode: { value: "read" },
@@ -318,10 +383,11 @@
       valueText: { value: "" },
       includeWriteQuantity: { value: false },
 
-      items: { value: [ defaultItemRow() ] }
+      items: { value: [ defaultItemRow() ], validate: validDecoderItems }
     },
     inputs: 1,
-    outputs: 1,
+    outputs: 2,
+    outputLabels: ["Data / alarm", "Debug"],
     icon: "bridge.svg",
     label: function () { return this.name || "Smithtek Mako RF"; },
 
@@ -414,7 +480,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 +534,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>
 
 
@@ -483,6 +549,12 @@
     <input type="text" id="node-input-name" placeholder="">
   </div>
 
+  <div class="form-row">
+    <label for="node-input-prefix"><i class="fa fa-tag"></i> Prefix</label>
+    <input type="text" id="node-input-prefix" placeholder="e.g. b1">
+    <div class="form-tips">Added before each decoder name with a space: b1 + Pressure becomes b1 Pressure. Leave blank to keep existing names.</div>
+  </div>
+
   <div class="form-row">
     <label for="node-input-bus"><i class="fa fa-sitemap"></i> Bus</label>
     <input type="text" id="node-input-bus" style="width: 25%;">
@@ -581,30 +653,39 @@
     </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.
+
+Prefix adds text and one space before each decoder name. Leave blank to preserve names.
+
+Output 1 (Data / alarm) carries successful readings and write responses, or the friendly named fault JSON on failure. Output 2 (Debug) carries technical error details: ok, error, code and req. Connect it to a local Debug node or leave it disconnected. Node-RED error logs and Catch handling remain enabled. A timeout alarm is sent after one poll exhausts its retries (retries 2 means 3 attempts), not after multiple bad polls. Permanent Modbus exceptions report immediately. Each failed poll emits one alarm and one debug message.
+
+Failed requests output a named numeric alarm on output 1, for example {"b1 RF ID2 Not communicating — check power/RF; disable if out of service":1}. Details remain in msg.modbus, including ok, code, error and fault. Only final failures are reported; a successful retry or intentional shutdown does not emit an alarm. Successful reads resume normal data; no automatic alarm-clear value is sent.
+
+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>