node-red-contrib-modbus-modpackqt 1.1.85 → 2.0.0

package/nodes/modpackqt-config.js

@@ -1,26 +1,353 @@
-module.exports = function(RED) {
+/**
+ * ModPackQT Config Node — embedded Modbus runtime for Node-RED.
+ *
+ * Owns:
+ *   - A connection pool of Modbus TCP/RTU master clients (one per target).
+ *   - An optional embedded Modbus TCP slave server with a local register store.
+ *   - A local rate-limit counter (anonymous tier: 1,000 ops/day per Node-RED instance).
+ *
+ * Phase 1: limits are enforced locally only. Phase 2 will validate the API key
+ * against the ModPackQT cloud lease endpoint for unlimited usage.
+ */
+module.exports = function (RED) {
+  const ModbusRTU = require('modbus-serial');
+  const { EventEmitter } = require('events');
+
+  const FREE_DAILY_LIMIT = 1000;
+  const UPGRADE_URL = 'https://modpackqt.com/nodered';
+  const DEBUG_LOG_INTERVAL = 100; // log "powered by ModPackQT" every N ops
+
   function ModPackQTConfigNode(config) {
     RED.nodes.createNode(this, config);
-    this.host = config.host || 'localhost';
-    this.port = config.port || 8502;
-    this.apiKey = this.credentials.apiKey || '';
-
-    const axios = require('axios');
-    this.baseUrl = `http://${this.host}:${this.port}`;
-
-    this.request = async function(method, path, data) {
-      const headers = {};
-      if (this.apiKey) headers['x-api-key'] = this.apiKey;
-      const response = await axios({
-        method,
-        url: `${this.baseUrl}${path}`,
-        data,
-        headers,
-        timeout: 10000
+    const node = this;
+
+    // Traffic event bus — modpackqt-traffic nodes subscribe to this.
+    node.traffic = new EventEmitter();
+    node.traffic.setMaxListeners(0);
+    function emitTraffic(evt) {
+      try { node.traffic.emit('op', evt); } catch (_) { /* listener errors must not affect ops */ }
+    }
+
+    // ---- Master settings ----
+    node.masterMode = config.masterMode || 'tcp'; // 'tcp' | 'rtu'
+    node.serialPort = config.serialPort || '';
+    node.baudRate   = parseInt(config.baudRate, 10) || 9600;
+    node.parity     = config.parity || 'none';
+    node.dataBits   = parseInt(config.dataBits, 10) || 8;
+    node.stopBits   = parseInt(config.stopBits, 10) || 1;
+    node.timeoutMs  = parseInt(config.timeoutMs, 10) || 3000;
+
+    // ---- Slave server settings ----
+    node.slaveEnabled = config.slaveEnabled === true || config.slaveEnabled === 'true';
+    node.slavePort    = parseInt(config.slavePort, 10) || 1502;
+    node.slaveHost    = config.slaveHost || '0.0.0.0';
+
+    // ---- Auth (Phase 2) ----
+    node.apiKey = (node.credentials && node.credentials.apiKey) || '';
+
+    // ====================================================================
+    // RATE LIMITING (local, in-memory)
+    // ====================================================================
+    const today = () => new Date().toISOString().slice(0, 10);
+    node._opsDay   = today();
+    node._opsCount = 0;
+
+    node.checkLimit = function () {
+      // Reset counter at midnight
+      const d = today();
+      if (d !== node._opsDay) { node._opsDay = d; node._opsCount = 0; }
+
+      // Phase 1: anonymous tier only — API key currently ignored for billing
+      if (node._opsCount >= FREE_DAILY_LIMIT) {
+        const err = new Error(
+          `ModPackQT free tier limit reached (${FREE_DAILY_LIMIT} ops/day). ` +
+          `Get a free trial API key at ${UPGRADE_URL}`
+        );
+        err.code = 'RATE_LIMIT';
+        throw err;
+      }
+      node._opsCount += 1;
+
+      if (node._opsCount % DEBUG_LOG_INTERVAL === 0) {
+        node.log(
+          `[modpackqt] ${node._opsCount} ops served today — ` +
+          `unlock unlimited at ${UPGRADE_URL}`
+        );
+      }
+      return node._opsCount;
+    };
+
+    node.brandStatus = function (text) {
+      // Phase 1: branding always visible (anonymous tier).
+      // Phase 2: paid users get clean text without the "modpackqt ·" prefix.
+      return `modpackqt · ${text}`;
+    };
+
+    node.opsToday = function () { return node._opsCount; };
+
+    // ====================================================================
+    // MASTER CLIENT POOL — one client per target (host:port:unit or serial:unit)
+    // ====================================================================
+    node._masterPool = new Map();
+    node._masterQueue = Promise.resolve(); // serialize all master ops
+
+    function targetKey(opts) {
+      if (node.masterMode === 'rtu') return `rtu:${node.serialPort}:${opts.unitId}`;
+      return `tcp:${opts.host}:${opts.port}:${opts.unitId}`;
+    }
+
+    async function getClient(opts) {
+      const key = targetKey(opts);
+      let client = node._masterPool.get(key);
+      if (client && client.isOpen) return client;
+
+      client = new ModbusRTU();
+      client.setTimeout(node.timeoutMs);
+
+      if (node.masterMode === 'rtu') {
+        if (!node.serialPort) throw new Error('Serial port not configured for RTU mode');
+        await client.connectRTUBuffered(node.serialPort, {
+          baudRate: node.baudRate,
+          parity:   node.parity,
+          dataBits: node.dataBits,
+          stopBits: node.stopBits
+        });
+      } else {
+        await client.connectTCP(opts.host, { port: opts.port });
+      }
+      client.setID(opts.unitId);
+      node._masterPool.set(key, client);
+      return client;
+    }
+
+    /**
+     * Read raw register values from a remote Modbus device.
+     * Returns plain array — no decoding, no objects. Use the
+     * node-red-contrib-bytes-modpackqt palette to decode.
+     */
+    // Modbus spec maximums (per IEC 61158-6-7) — enforced before hitting the wire
+    // so users get a clear error instead of a cryptic device exception.
+    const MAX_READ_BITS = 2000;       // FC1, FC2
+    const MAX_READ_REGS = 125;        // FC3, FC4
+    const MAX_WRITE_BITS = 1968;      // FC15
+    const MAX_WRITE_REGS = 123;       // FC16
+
+    node.read = function (opts) {
+      // Queue this op behind any in-flight master ops to avoid serial-port collision
+      node._masterQueue = node._masterQueue.then(async () => {
+        node.checkLimit();
+        const fc = parseInt(opts.functionCode, 10);
+        const addr = parseInt(opts.address, 10);
+        const qty  = parseInt(opts.quantity, 10);
+        // Pre-validate quantity against Modbus spec
+        if (qty < 1) throw new Error(`Quantity must be >= 1 (got ${qty})`);
+        if ((fc === 1 || fc === 2) && qty > MAX_READ_BITS) {
+          throw new Error(`FC${fc} read quantity ${qty} exceeds Modbus spec max of ${MAX_READ_BITS} bits`);
+        }
+        if ((fc === 3 || fc === 4) && qty > MAX_READ_REGS) {
+          throw new Error(`FC${fc} read quantity ${qty} exceeds Modbus spec max of ${MAX_READ_REGS} registers`);
+        }
+        const target = node.masterMode === 'rtu'
+          ? `rtu:${node.serialPort}` : `${opts.host}:${opts.port}`;
+        const start = Date.now();
+        let res, err = null;
+        try {
+          const client = await getClient(opts);
+          client.setID(opts.unitId);
+          switch (fc) {
+            case 1:  res = await client.readCoils(addr, qty); break;
+            case 2:  res = await client.readDiscreteInputs(addr, qty); break;
+            case 3:  res = await client.readHoldingRegisters(addr, qty); break;
+            case 4:  res = await client.readInputRegisters(addr, qty); break;
+            default: throw new Error(`Unsupported read function code: ${fc}`);
+          }
+          return res.data;
+        } catch (e) { err = e; throw e; }
+        finally {
+          emitTraffic({
+            ts: new Date().toISOString(),
+            direction: 'read', kind: 'master',
+            target, unitId: opts.unitId, fc, address: addr, quantity: qty,
+            values: res ? res.data : null,
+            durationMs: Date.now() - start,
+            ok: !err, error: err ? err.message : null
+          });
+        }
+      });
+      return node._masterQueue;
+    };
+
+    /**
+     * Write raw register values to a remote Modbus device.
+     * Caller must pre-encode multi-register values (use the bytes palette).
+     */
+    node.write = function (opts) {
+      node._masterQueue = node._masterQueue.then(async () => {
+        node.checkLimit();
+        const fc = parseInt(opts.functionCode, 10);
+        const addr = parseInt(opts.address, 10);
+        const values = opts.values;
+        // Pre-validate write count against Modbus spec
+        const count = Array.isArray(values) ? values.length : 1;
+        if (fc === 15 && count > MAX_WRITE_BITS) {
+          throw new Error(`FC15 write count ${count} exceeds Modbus spec max of ${MAX_WRITE_BITS} bits`);
+        }
+        if (fc === 16 && count > MAX_WRITE_REGS) {
+          throw new Error(`FC16 write count ${count} exceeds Modbus spec max of ${MAX_WRITE_REGS} registers`);
+        }
+        const target = node.masterMode === 'rtu'
+          ? `rtu:${node.serialPort}` : `${opts.host}:${opts.port}`;
+        const start = Date.now();
+        let err = null;
+        try {
+          const client = await getClient(opts);
+          client.setID(opts.unitId);
+          switch (fc) {
+            case 5:  return await client.writeCoil(addr, !!values[0]);
+            case 6:  return await client.writeRegister(addr, values[0]);
+            case 15: return await client.writeCoils(addr, values.map(Boolean));
+            case 16: return await client.writeRegisters(addr, values);
+            default: throw new Error(`Unsupported write function code: ${fc}`);
+          }
+        } catch (e) { err = e; throw e; }
+        finally {
+          emitTraffic({
+            ts: new Date().toISOString(),
+            direction: 'write', kind: 'master',
+            target, unitId: opts.unitId, fc, address: addr,
+            quantity: values.length, values,
+            durationMs: Date.now() - start,
+            ok: !err, error: err ? err.message : null
+          });
+        }
+      });
+      return node._masterQueue;
+    };
+
+    // ====================================================================
+    // EMBEDDED SLAVE SERVER (Modbus TCP)
+    // ====================================================================
+    // Local register store — single unit, multiple register types
+    node._slaveStore = {
+      coils:        new Array(65536).fill(false),
+      discrete:     new Array(65536).fill(false),
+      holding:      new Array(65536).fill(0),
+      input:        new Array(65536).fill(0)
+    };
+
+    node.slaveGet = function (registerType, address, quantity) {
+      const arr = node._slaveStore[registerType];
+      if (!arr) throw new Error(`Unknown register type: ${registerType}`);
+      const values = arr.slice(address, address + quantity);
+      emitTraffic({
+        ts: new Date().toISOString(),
+        direction: 'read', kind: 'slave', via: 'flow',
+        target: `local:${node.slavePort}`, unitId: 1, fc: null,
+        registerType, address, quantity: values.length, values,
+        durationMs: 0, ok: true, error: null
       });
-      return response.data;
+      return values;
     };
+
+    node.slaveSet = function (registerType, address, values) {
+      const arr = node._slaveStore[registerType];
+      if (!arr) throw new Error(`Unknown register type: ${registerType}`);
+      const isBool = (registerType === 'coils' || registerType === 'discrete');
+      const stored = values.map((v) => isBool ? Boolean(v) : (parseInt(v, 10) & 0xFFFF));
+      stored.forEach((v, i) => { arr[address + i] = v; });
+      emitTraffic({
+        ts: new Date().toISOString(),
+        direction: 'write', kind: 'slave', via: 'flow',
+        target: `local:${node.slavePort}`, unitId: 1, fc: null,
+        registerType, address, quantity: stored.length, values: stored,
+        durationMs: 0, ok: true, error: null
+      });
+    };
+
+    // Helper: emit a slave traffic event for ops coming from EXTERNAL Modbus masters
+    // (i.e. via the embedded TCP server's vector callbacks). Internal slaveGet/slaveSet
+    // already emit their own events tagged via='flow'.
+    function emitExternalSlave(direction, registerType, address, values) {
+      emitTraffic({
+        ts: new Date().toISOString(),
+        direction, kind: 'slave', via: 'external',
+        target: `local:${node.slavePort}`, unitId: 1, fc: null,
+        registerType, address, quantity: Array.isArray(values) ? values.length : 1,
+        values: Array.isArray(values) ? values : [values],
+        durationMs: 0, ok: true, error: null
+      });
+    }
+
+    node._slaveServer = null;
+    if (node.slaveEnabled) {
+      const vector = {
+        getCoil: (addr, _unit, cb) => {
+          const v = node._slaveStore.coils[addr];
+          emitExternalSlave('read', 'coils', addr, v);
+          cb(null, v);
+        },
+        getDiscreteInput: (addr, _unit, cb) => {
+          const v = node._slaveStore.discrete[addr];
+          emitExternalSlave('read', 'discrete', addr, v);
+          cb(null, v);
+        },
+        getHoldingRegister: (addr, _unit, cb) => {
+          const v = node._slaveStore.holding[addr];
+          emitExternalSlave('read', 'holding', addr, v);
+          cb(null, v);
+        },
+        getInputRegister: (addr, _unit, cb) => {
+          const v = node._slaveStore.input[addr];
+          emitExternalSlave('read', 'input', addr, v);
+          cb(null, v);
+        },
+        setCoil: (addr, value, _unit, cb) => {
+          node._slaveStore.coils[addr] = !!value;
+          emitExternalSlave('write', 'coils', addr, !!value);
+          cb(null);
+        },
+        setRegister: (addr, value, _unit, cb) => {
+          const v = value & 0xFFFF;
+          node._slaveStore.holding[addr] = v;
+          emitExternalSlave('write', 'holding', addr, v);
+          cb(null);
+        }
+      };
+      try {
+        node._slaveServer = new ModbusRTU.ServerTCP(vector, {
+          host: node.slaveHost,
+          port: node.slavePort,
+          debug: false,
+          unitID: 1
+        });
+        node._slaveServer.on('socketError', (err) => node.warn(`[slave] socket error: ${err.message}`));
+        node._slaveServer.on('serverError', (err) => node.error(`[slave] server error: ${err.message}`));
+        node.log(
+          `[modpackqt] embedded Modbus slave listening on ${node.slaveHost}:${node.slavePort} — ` +
+          `powered by ModPackQT (${UPGRADE_URL})`
+        );
+      } catch (err) {
+        node.error(`Failed to start embedded slave server: ${err.message}`);
+      }
+    }
+
+    // ====================================================================
+    // CLEANUP
+    // ====================================================================
+    node.on('close', function (done) {
+      const tasks = [];
+      for (const client of node._masterPool.values()) {
+        try { if (client.isOpen) tasks.push(new Promise((r) => client.close(r))); } catch (_) {}
+      }
+      node._masterPool.clear();
+      if (node._slaveServer) {
+        tasks.push(new Promise((r) => node._slaveServer.close(r)));
+        node._slaveServer = null;
+      }
+      Promise.all(tasks).then(() => done()).catch(() => done());
+    });
   }
+
   RED.nodes.registerType('modpackqt-config', ModPackQTConfigNode, {
     credentials: { apiKey: { type: 'password' } }
   });

package/nodes/modpackqt-master-read.html

@@ -1,7 +1,7 @@
 <script type="text/javascript">
   RED.nodes.registerType('modpackqt-master-read', {
     category: 'ModPackQT',
-    color: '#2563eb',
+    color: '#16a34a',
     defaults: {
       name:         { value: '' },
       server:       { value: '', type: 'modpackqt-config', required: true },
@@ -16,10 +16,10 @@
     inputs: 1,
     outputs: 1,
     icon: 'font-awesome/fa-download',
-    label: function() {
+    label: function () {
       return this.name || `Master Read FC${this.functionCode} @${this.address}`;
     },
-    paletteLabel: 'modpackqt master read'
+    paletteLabel: 'modbus master read'
   });
 </script>
 
@@ -29,12 +29,12 @@
     <input type="text" id="node-input-name" placeholder="Name">
   </div>
   <div class="form-row">
-    <label for="node-input-server"><i class="fa fa-cog"></i> Gateway</label>
+    <label for="node-input-server"><i class="fa fa-cog"></i> Runtime</label>
     <input type="text" id="node-input-server">
   </div>
   <div class="form-row">
     <label for="node-input-targetHost"><i class="fa fa-plug"></i> Target Host</label>
-    <input type="text" id="node-input-targetHost" placeholder="Modbus device IP/hostname">
+    <input type="text" id="node-input-targetHost" placeholder="Modbus device IP/hostname (TCP only)">
   </div>
   <div class="form-row">
     <label for="node-input-targetPort"><i class="fa fa-hashtag"></i> Target Port</label>
@@ -65,25 +65,22 @@
     <label for="node-input-pollInterval"><i class="fa fa-clock-o"></i> Poll Interval (ms)</label>
     <input type="number" id="node-input-pollInterval" min="0" placeholder="0 = disabled">
   </div>
+  <div class="form-tips">
+    <b>Output:</b> <code>msg.payload</code> = raw register array. To decode int / float / string,
+    pair with <a href="https://www.npmjs.com/package/node-red-contrib-bytes-modpackqt" target="_blank">node-red-contrib-bytes-modpackqt</a>.
+  </div>
 </script>
 
 <script type="text/html" data-help-name="modpackqt-master-read">
-  <p>Reads Modbus registers from a remote device via the ModPackQT Gateway app.</p>
-  <p>Calls <code>POST /api/modbus/tcp/read</code> on the gateway, which opens a Modbus TCP connection to the target device.</p>
-  <h3>Inputs</h3>
-  <dl class="message-properties">
-    <dt>payload <span class="property-type">any</span></dt>
-    <dd>Any incoming message triggers a read (when Poll Interval is 0).</dd>
-  </dl>
+  <p>Reads Modbus registers from a remote device using the embedded Modbus runtime in the
+  <code>modpackqt-config</code> node. No external gateway app required.</p>
   <h3>Outputs</h3>
   <dl class="message-properties">
-    <dt>payload <span class="property-type">object</span></dt>
-    <dd>Contains <code>values</code> (array) and <code>success</code>.</dd>
+    <dt>payload <span class="property-type">array</span></dt>
+    <dd>Raw register values — integers (FC3/FC4) or booleans (FC1/FC2). Use the bytes palette to decode int32, float32, string, etc.</dd>
     <dt>topic <span class="property-type">string</span></dt>
-    <dd><code>modbus/read/{targetHost}:{targetPort}</code></dd>
+    <dd><code>modpackqt/read/{host}:{port}/fc{N}/{address}</code></dd>
   </dl>
-  <h3>Details</h3>
-  <p><b>Gateway</b> — host and port of the running ModPackQT Gateway app (default: <code>localhost:8502</code>).</p>
-  <p><b>Target Host / Target Port</b> — the actual Modbus TCP slave device to read from.</p>
-  <p>Set <b>Poll Interval</b> &gt; 0 to continuously poll on a timer.</p>
+  <h3>Free tier</h3>
+  <p>1,000 ops/day per Node-RED instance. Add an API key in the runtime config for unlimited use.</p>
 </script>

package/nodes/modpackqt-master-read.js

@@ -1,18 +1,21 @@
-module.exports = function(RED) {
+/**
+ * ModPackQT Master Read — embedded Modbus TCP/RTU read.
+ * Outputs raw register values (no decoding). Pair with
+ * node-red-contrib-bytes-modpackqt to decode int/float/string/bitmask.
+ */
+module.exports = function (RED) {
   function ModPackQTMasterReadNode(config) {
     RED.nodes.createNode(this, config);
     const node = this;
     const server = RED.nodes.getNode(config.server);
 
     node.targetHost   = config.targetHost   || 'localhost';
-    node.targetPort   = parseInt(config.targetPort)   || 502;
-    node.unitId       = parseInt(config.unitId)       || 1;
-    node.functionCode = parseInt(config.functionCode) || 3;
-    node.address      = parseInt(config.address)      || 0;
-    node.quantity     = parseInt(config.quantity)     || 1;
-    node.pollInterval = config.pollInterval ? parseInt(config.pollInterval, 10) : 0;
-
-    const FC_TO_REGISTER_TYPE = { 1: 'coil', 2: 'discrete', 3: 'holding', 4: 'input' };
+    node.targetPort   = parseInt(config.targetPort,   10) || 502;
+    node.unitId       = parseInt(config.unitId,       10) || 1;
+    node.functionCode = parseInt(config.functionCode, 10) || 3;
+    node.address      = parseInt(config.address,      10) || 0;
+    node.quantity     = parseInt(config.quantity,     10) || 1;
+    node.pollInterval = parseInt(config.pollInterval, 10) || 0;
 
     let timer = null;
 
@@ -22,21 +25,27 @@ module.exports = function(RED) {
         return;
       }
       try {
-        const registerType = FC_TO_REGISTER_TYPE[node.functionCode] || 'holding';
-        const result = await server.request('POST', '/api/modbus/tcp/read', {
+        const values = await server.read({
           host:         node.targetHost,
           port:         node.targetPort,
           unitId:       node.unitId,
-          registerType,
+          functionCode: node.functionCode,
           address:      node.address,
           quantity:     node.quantity
         });
         const ts = new Date().toLocaleTimeString();
-        const pollLabel = node.pollInterval > 0 ? ` (poll ${node.pollInterval}ms)` : '';
-        node.status({ fill: 'green', shape: 'dot', text: `FC${node.functionCode} @${node.address} · ${ts}${pollLabel}` });
-        node.send({ payload: result, topic: `modbus/read/${node.targetHost}:${node.targetPort}` });
+        const ops = server.opsToday();
+        node.status({
+          fill: 'green', shape: 'dot',
+          text: server.brandStatus(`FC${node.functionCode} @${node.address} · ${ts} · ${ops} ops`)
+        });
+        node.send({
+          payload: values,
+          topic: `modpackqt/read/${node.targetHost}:${node.targetPort}/fc${node.functionCode}/${node.address}`,
+          modpackqt: { fc: node.functionCode, address: node.address, quantity: node.quantity }
+        });
       } catch (err) {
-        node.status({ fill: 'red', shape: 'dot', text: err.message });
+        node.status({ fill: 'red', shape: 'dot', text: err.message.slice(0, 60) });
         node.error(err.message);
       }
     }
@@ -46,8 +55,8 @@ module.exports = function(RED) {
       timer = setInterval(doRead, node.pollInterval);
     }
 
-    node.on('input', async function() { await doRead(); });
-    node.on('close', function() { if (timer) { clearInterval(timer); timer = null; } });
+    node.on('input', async function () { await doRead(); });
+    node.on('close', function () { if (timer) clearInterval(timer); });
   }
   RED.nodes.registerType('modpackqt-master-read', ModPackQTMasterReadNode);
 };

package/nodes/modpackqt-master-write.html

@@ -1,7 +1,7 @@
 <script type="text/javascript">
   RED.nodes.registerType('modpackqt-master-write', {
     category: 'ModPackQT',
-    color: '#2563eb',
+    color: '#16a34a',
     defaults: {
       name:         { value: '' },
       server:       { value: '', type: 'modpackqt-config', required: true },
@@ -14,10 +14,10 @@
     inputs: 1,
     outputs: 1,
     icon: 'font-awesome/fa-upload',
-    label: function() {
+    label: function () {
       return this.name || `Master Write FC${this.functionCode} @${this.address}`;
     },
-    paletteLabel: 'modpackqt master write'
+    paletteLabel: 'modbus master write'
   });
 </script>
 
@@ -27,12 +27,12 @@
     <input type="text" id="node-input-name" placeholder="Name">
   </div>
   <div class="form-row">
-    <label for="node-input-server"><i class="fa fa-cog"></i> Gateway</label>
+    <label for="node-input-server"><i class="fa fa-cog"></i> Runtime</label>
     <input type="text" id="node-input-server">
   </div>
   <div class="form-row">
     <label for="node-input-targetHost"><i class="fa fa-plug"></i> Target Host</label>
-    <input type="text" id="node-input-targetHost" placeholder="Modbus device IP/hostname">
+    <input type="text" id="node-input-targetHost" placeholder="Modbus device IP/hostname (TCP only)">
   </div>
   <div class="form-row">
     <label for="node-input-targetPort"><i class="fa fa-hashtag"></i> Target Port</label>
@@ -55,22 +55,18 @@
     <label for="node-input-address"><i class="fa fa-map-marker"></i> Start Address</label>
     <input type="number" id="node-input-address" min="0" max="65535" placeholder="0">
   </div>
+  <div class="form-tips">
+    <b>Input:</b> <code>msg.payload</code> = number (FC5/FC6) or array of numbers (FC15/FC16).
+    Encode multi-register values upstream with
+    <a href="https://www.npmjs.com/package/node-red-contrib-bytes-modpackqt" target="_blank">node-red-contrib-bytes-modpackqt</a>.
+  </div>
 </script>
 
 <script type="text/html" data-help-name="modpackqt-master-write">
-  <p>Writes Modbus registers to a remote device via the ModPackQT Gateway app.</p>
-  <p>Calls <code>POST /api/modbus/tcp/write</code> on the gateway.</p>
+  <p>Writes Modbus registers to a remote device using the embedded Modbus runtime.</p>
   <h3>Inputs</h3>
   <dl class="message-properties">
     <dt>payload <span class="property-type">number | array</span></dt>
-    <dd>The value(s) to write. A single number for FC5/FC6, or an array for FC15/FC16.</dd>
-  </dl>
-  <h3>Outputs</h3>
-  <dl class="message-properties">
-    <dt>payload <span class="property-type">any</span></dt>
-    <dd>Original message is passed through with <code>msg.success = true</code> on success.</dd>
+    <dd>Raw value(s). For float/int32/string, pre-encode upstream with the bytes palette.</dd>
   </dl>
-  <h3>Details</h3>
-  <p><b>Gateway</b> — host and port of the running ModPackQT Gateway app (default: <code>localhost:8502</code>).</p>
-  <p><b>Target Host / Target Port</b> — the actual Modbus TCP slave device to write to.</p>
 </script>