node-red-modbus-dynamic-server 0.1.0

package/src/modbus-registers-read.html

@@ -0,0 +1,133 @@
+<script type="text/html" data-template-name="modbus-registers-read">
+  <div class="form-row">
+    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name" placeholder="Name">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-registerMap"><i class="fa fa-database"></i> Register Map</label>
+    <input type="text" id="node-input-registerMap">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-registerType"><i class="fa fa-filter"></i> Register Type</label>
+    <select id="node-input-registerType">
+      <option value="holding">holding</option>
+      <option value="input">input</option>
+      <option value="coil">coil</option>
+      <option value="discrete">discrete</option>
+    </select>
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-registerAddress"><i class="fa fa-hashtag"></i> Register Address</label>
+    <input type="number" id="node-input-registerAddress" min="0" placeholder="0">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-registerFormat"><i class="fa fa-code"></i> Format</label>
+    <select id="node-input-registerFormat">
+      <option value="int16">int16</option>
+      <option value="uint16">uint16</option>
+      <option value="int32">int32</option>
+      <option value="uint32">uint32</option>
+      <option value="float32">float32</option>
+    </select>
+  </div>
+</script>
+
+<script type="text/html" data-help-name="modbus-registers-read">
+  <p>Reads a value from a shared <code>modbus-registers-config</code> register map on each input
+  message and emits the decoded result as a normal Node-RED message.</p>
+
+  <h3>Inputs</h3>
+  <dl class="message-properties">
+    <dt class="optional">registerType <span class="property-type">string</span></dt>
+    <dd>Overrides the configured register type for this message only.
+    Allowed values: <code>holding</code>, <code>input</code>, <code>coil</code>,
+    <code>discrete</code>.</dd>
+
+    <dt class="optional">registerAddress <span class="property-type">number</span></dt>
+    <dd>Overrides the configured register address (0-based) for this message only.</dd>
+
+    <dt class="optional">registerFormat <span class="property-type">string</span></dt>
+    <dd>Overrides the configured data format for this message only.
+    Allowed values: <code>int16</code>, <code>uint16</code>, <code>int32</code>,
+    <code>uint32</code>, <code>float32</code>.</dd>
+  </dl>
+
+  <h3>Outputs</h3>
+  <ol class="node-ports">
+    <li>Read result message
+      <dl class="message-properties">
+        <dt>payload <span class="property-type">object</span></dt>
+        <dd>Structured read result object with:
+          <ul>
+            <li><code>registerType</code> — register type read from.</li>
+            <li><code>registerAddress</code> — address read from.</li>
+            <li><code>registerFormat</code> — format used for decoding.</li>
+            <li><code>value</code> — decoded value.</li>
+            <li><code>wordsRead</code> — present for word/register reads.</li>
+            <li><code>bitsRead</code> — present for coil/discrete reads.</li>
+          </ul>
+        </dd>
+
+        <dt>modbusRegistersRead <span class="property-type">object</span></dt>
+        <dd>Read metadata mirror for easier downstream inspection.</dd>
+      </dl>
+    </li>
+  </ol>
+
+  <h3>Configuration</h3>
+  <dl class="message-properties">
+    <dt>Register Map <span class="property-type">modbus-registers-config</span></dt>
+    <dd>The shared register map this node reads from. Required.</dd>
+
+    <dt>Register Type <span class="property-type">select</span></dt>
+    <dd>The type of register to read:
+      <ul>
+        <li><code>holding</code> — holding registers.</li>
+        <li><code>input</code> — input registers.</li>
+        <li><code>coil</code> — single-bit coil registers.</li>
+        <li><code>discrete</code> — discrete input bits.</li>
+      </ul>
+    </dd>
+
+    <dt>Register Address <span class="property-type">number</span></dt>
+    <dd>Zero-based register address to read from. For 32-bit formats, both
+    <code>address</code> and <code>address+1</code> are read.</dd>
+
+    <dt>Format <span class="property-type">select</span></dt>
+    <dd>Decoding format for register reads:
+      <ul>
+        <li><code>int16</code> — signed 16-bit integer.</li>
+        <li><code>uint16</code> — unsigned 16-bit integer.</li>
+        <li><code>int32</code> — signed 32-bit integer (2 registers).</li>
+        <li><code>uint32</code> — unsigned 32-bit integer (2 registers).</li>
+        <li><code>float32</code> — IEEE 754 single-precision float (2 registers).</li>
+      </ul>
+      32-bit word/byte ordering follows the linked register map's
+      <em>32-bit Word Order</em> setting.</dd>
+  </dl>
+</script>
+
+<script type="text/javascript">
+  RED.nodes.registerType('modbus-registers-read', {
+    category: 'modbus',
+    color: '#E9967A',
+    defaults: {
+      name: { value: '' },
+      registerMap: { value: '', type: 'modbus-registers-config', required: true },
+      registerType: { value: 'holding', required: true },
+      registerAddress: { value: 0, required: true, validate: RED.validators.number() },
+      registerFormat: { value: 'uint16', required: true }
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: 'file.svg',
+    label: function () {
+      return this.name || 'Modbus Registers Read'
+    }
+  })
+</script>
+

package/src/modbus-registers-read.js

@@ -0,0 +1,204 @@
+function formatStatusValue (value) {
+  if (value === null) return 'null'
+  if (value === undefined) return 'undefined'
+
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) return String(value)
+    return String(value)
+  }
+
+  if (typeof value === 'bigint' || typeof value === 'boolean') {
+    return String(value)
+  }
+
+  if (typeof value === 'string') {
+    return value.length > 20 ? `${value.slice(0, 17)}...` : value
+  }
+
+  if (Array.isArray(value)) {
+    return `[${value.length} items]`
+  }
+
+  if (typeof value === 'object') {
+    return '[object]'
+  }
+
+  return String(value)
+}
+
+module.exports = function (RED) {
+  function ModbusRegistersReadNode (config) {
+    RED.nodes.createNode(this, config)
+    const node = this
+
+    node.name = config.name || ''
+    node.registerMap = RED.nodes.getNode(config.registerMap)
+    node.registerType = config.registerType || 'holding'
+    node.registerAddress = normalizeAddress(config.registerAddress)
+    node.registerFormat = config.registerFormat || 'uint16'
+
+    if (!node.registerMap) {
+      node.status({ fill: 'red', shape: 'ring', text: 'no register map' })
+      return
+    }
+
+    node.status({ fill: 'grey', shape: 'ring', text: 'ready' })
+
+    node.on('input', function (msg, send, done) {
+      const registerType = normalizeRegisterType(msg.registerType || node.registerType)
+      const registerAddress = normalizeAddress(msg.registerAddress, node.registerAddress)
+      const registerFormat = normalizeRegisterFormat(msg.registerFormat || node.registerFormat)
+
+      if (!registerType) {
+        node.status({ fill: 'red', shape: 'ring', text: 'invalid register type' })
+        done(new Error('modbus-registers-read: invalid registerType'))
+        return
+      }
+
+      if (!registerFormat) {
+        node.status({ fill: 'red', shape: 'ring', text: 'invalid format' })
+        done(new Error('modbus-registers-read: invalid registerFormat'))
+        return
+      }
+
+      const readResult = readValue(node.registerMap, registerType, registerAddress, registerFormat)
+      if (!readResult.ok) {
+        node.status({ fill: 'red', shape: 'ring', text: 'read failed' })
+        done(new Error(`modbus-registers-read: ${readResult.error}`))
+        return
+      }
+
+      msg.payload = {
+        registerType,
+        registerAddress,
+        registerFormat,
+        value: readResult.value
+      }
+
+      if (readResult.wordsRead) {
+        msg.payload.wordsRead = readResult.wordsRead
+      }
+      if (readResult.bitsRead) {
+        msg.payload.bitsRead = readResult.bitsRead
+      }
+
+      msg.modbusRegistersRead = {
+        registerType,
+        registerAddress,
+        registerFormat,
+        value: readResult.value,
+        wordsRead: readResult.wordsRead || 0,
+        bitsRead: readResult.bitsRead || 0
+      }
+
+      node.status({ fill: 'green', shape: 'dot', text: `read ${formatStatusValue(readResult.value)}` })
+      send(msg)
+      done()
+    })
+  }
+
+  function normalizeAddress (value, fallback) {
+    const parsed = Number(value)
+    if (!Number.isFinite(parsed) || parsed < 0) {
+      return fallback !== undefined ? fallback : 0
+    }
+    return Math.floor(parsed)
+  }
+
+  function normalizeRegisterType (value) {
+    if (value === 'holding' || value === 'input' || value === 'coil' || value === 'discrete') {
+      return value
+    }
+    return null
+  }
+
+  function normalizeRegisterFormat (value) {
+    if (value === 'int16' || value === 'uint16' || value === 'int32' || value === 'uint32' || value === 'float32') {
+      return value
+    }
+    return null
+  }
+
+  function readValue (registerMap, registerType, registerAddress, registerFormat) {
+    if (registerType === 'coil' || registerType === 'discrete') {
+      const bits = registerMap.readBits(registerType, registerAddress, 1)
+      if (!bits) {
+        return { ok: false, error: 'address out of range' }
+      }
+
+      return {
+        ok: true,
+        value: Boolean(bits[0]),
+        bitsRead: 1
+      }
+    }
+
+    const wordsNeeded = (registerFormat === 'int32' || registerFormat === 'uint32' || registerFormat === 'float32') ? 2 : 1
+    const words = registerMap.readWords(registerType, registerAddress, wordsNeeded)
+    if (!words) {
+      return { ok: false, error: 'address out of range' }
+    }
+
+    const value = decodeWords(words, registerFormat, registerMap.wordOrderMode)
+    if (value === null) {
+      return { ok: false, error: `unsupported format ${registerFormat}` }
+    }
+
+    return {
+      ok: true,
+      value,
+      wordsRead: wordsNeeded
+    }
+  }
+
+  function decodeWords (words, format, wordOrderMode) {
+    const w0 = Number(words[0]) & 0xffff
+
+    if (format === 'uint16') return w0
+    if (format === 'int16') {
+      return w0 >= 0x8000 ? w0 - 0x10000 : w0
+    }
+
+    if (format === 'int32' || format === 'uint32' || format === 'float32') {
+      if (!Array.isArray(words) || words.length < 2) return null
+      const w1 = Number(words[1]) & 0xffff
+      const bytes = decodeWordPairToABCDBytes(w0, w1, wordOrderMode)
+      const buf = Buffer.from(bytes)
+
+      if (format === 'uint32') return buf.readUInt32BE(0)
+      if (format === 'int32') return buf.readInt32BE(0)
+      return buf.readFloatBE(0)
+    }
+
+    return null
+  }
+
+  function decodeWordPairToABCDBytes (firstWord, secondWord, mode) {
+    const firstHi = (firstWord >> 8) & 0xff
+    const firstLo = firstWord & 0xff
+    const secondHi = (secondWord >> 8) & 0xff
+    const secondLo = secondWord & 0xff
+
+    const normalizedMode = normalizeWordOrderMode(mode)
+    if (normalizedMode === 'ABCD') {
+      return [firstHi, firstLo, secondHi, secondLo]
+    }
+    if (normalizedMode === 'CDAB') {
+      return [secondHi, secondLo, firstHi, firstLo]
+    }
+    if (normalizedMode === 'BADC') {
+      return [firstLo, firstHi, secondLo, secondHi]
+    }
+    // DCBA
+    return [secondLo, secondHi, firstLo, firstHi]
+  }
+
+  function normalizeWordOrderMode (value) {
+    const mode = String(value || '').trim().toUpperCase()
+    if (mode === 'ABCD' || mode === 'CDAB' || mode === 'BADC' || mode === 'DCBA') return mode
+    return 'ABCD'
+  }
+
+  RED.nodes.registerType('modbus-registers-read', ModbusRegistersReadNode)
+}
+

package/src/modbus-registers-respond.html

@@ -0,0 +1,116 @@
+<script type="text/html" data-template-name="modbus-registers-respond">
+	<div class="form-row">
+		<label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+		<input type="text" id="node-input-name" placeholder="Name">
+	</div>
+
+	<div class="form-row">
+		<label for="node-input-registerMap"><i class="fa fa-database"></i> Register Map</label>
+		<input type="text" id="node-input-registerMap">
+	</div>
+
+</script>
+
+<script type="text/html" data-help-name="modbus-registers-respond">
+    <p>Handles an incoming Modbus request emitted by a <code>modbus-dynamic-server</code> node by
+    automatically reading from or writing to a shared <code>modbus-registers-config</code> register
+    map, then sending the correct Modbus response back to the client — all without manual payload
+    construction.</p>
+
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+            <dt>_modbus.requestId <span class="property-type">string</span></dt>
+            <dd>Required internal request context field emitted by <code>modbus-dynamic-server</code>.</dd>
+
+            <dt>_modbus.eventName <span class="property-type">string</span></dt>
+            <dd>Required internal function-code event name from the incoming request, e.g.
+        <code>readHoldingRegisters</code>, <code>writeSingleCoil</code>.</dd>
+
+            <dt>_modbus.configNodeId <span class="property-type">string</span></dt>
+            <dd>Required internal config-node identifier used to complete the pending request.</dd>
+
+        <dt>payload <span class="property-type">object</span></dt>
+        <dd>The full jsmodbus request object as emitted by the <code>modbus-dynamic-server</code>
+        node. Must contain <code>address</code>, <code>quantity</code>, and <code>body</code>
+        fields.</dd>
+    </dl>
+
+    <h3>Outputs</h3>
+    <ol class="node-ports">
+        <li>Passthrough message
+            <dl class="message-properties">
+                <dt>payload <span class="property-type">object</span></dt>
+                <dd>The original request message, forwarded unchanged after the response has been
+                sent to the Modbus client.</dd>
+
+                <dt>modbusResponse <span class="property-type">object</span></dt>
+                <dd>Details of what this node submitted to <code>respondToRequest</code>, including:
+                    <ul>
+                        <li><code>requestId</code>, <code>eventName</code>, <code>address</code>, <code>quantity</code></li>
+                        <li><code>payloadSubmitted</code> — the exact payload passed to server config</li>
+                        <li><code>payloadType</code> — payload classification (<code>array</code>, <code>buffer</code>, <code>object</code>, ...)</li>
+                        <li><code>actualDataSent</code> — normalized values actually encoded for read FC responses</li>
+                        <li><code>actualDataType</code> — type of <code>actualDataSent</code></li>
+                        <li><code>ok</code> — whether the response was accepted for the requestId</li>
+                        <li><code>timestamp</code> — ISO timestamp when this node submitted it</li>
+                        <li><code>note</code> — present for write FCs to indicate auto-built response behavior</li>
+                    </ul>
+                </dd>
+            </dl>
+        </li>
+    </ol>
+
+    <h3>Configuration</h3>
+    <dl class="message-properties">
+        <dt>Register Map <span class="property-type">modbus-registers-config</span></dt>
+        <dd>The shared register map to read from (for read requests) or write to (for write requests).
+        Required.</dd>
+
+    </dl>
+
+    <h3>Details</h3>
+    <p>This node handles all eight standard function codes automatically:</p>
+    <ul>
+        <li><b>FC1 readCoils</b> — reads from the coil register map and returns the values.</li>
+        <li><b>FC2 readDiscreteInputs</b> — reads from the discrete input map.</li>
+        <li><b>FC3 readHoldingRegisters</b> — reads from the holding register map.</li>
+        <li><b>FC4 readInputRegisters</b> — reads from the input register map.</li>
+        <li><b>FC5 writeSingleCoil</b> — writes a single bit to the coil map.</li>
+        <li><b>FC6 writeSingleRegister</b> — writes a single word to the holding register map.</li>
+        <li><b>FC15 writeMultipleCoils</b> — writes multiple bits to the coil map.</li>
+        <li><b>FC16 writeMultipleRegisters</b> — writes multiple words to the holding register map.</li>
+    </ul>
+    <p>If a request addresses a register range that has been set to zero (disabled) in the register
+    map config, this node automatically responds with Modbus exception code&nbsp;2
+    (Illegal Data Address). An unknown function code returns exception code&nbsp;1 (Illegal
+    Function). Neither case raises a flow error.</p>
+      <p>Flows must preserve <code>msg._modbus</code>:</p>
+      <pre><code>// CORRECT
+    msg.payload = newValue;
+    return msg;
+
+    // INCORRECT: request context is lost
+    msg = { payload: newValue };
+    return msg;</code></pre>
+    <p>This node is the recommended response handler when using a static register map. For fully
+    custom response logic, use the lower-level <code>modbus-dynamic-server-response</code> node
+    instead.</p>
+</script>
+
+<script type="text/javascript">
+  RED.nodes.registerType('modbus-registers-respond', {
+	category: 'modbus',
+	color: '#E9967A',
+	defaults: {
+	  name: { value: '' },
+    registerMap: { value: '', type: 'modbus-registers-config', required: true }
+	},
+	inputs: 1,
+	outputs: 1,
+	icon: 'arrow-out.svg',
+	label: function () {
+	  return this.name || 'Modbus Registers Respond'
+	}
+  })
+</script>
+