node-red-modbus-dynamic-server 0.1.0

package/src/modbus-dynamic-server-config.js

@@ -0,0 +1,391 @@
+const net = require('net')
+const modbus = require('jsmodbus')
+const EventEmitter = require('events')
+const { randomUUID } = require('crypto')
+const resp = require('jsmodbus/dist/response')
+const TcpResponse = require('jsmodbus/dist/tcp-response')
+
+const DEFAULT_PENDING_RESPONSE_TIMEOUT_MS = 5 * 60 * 1000
+const DEFAULT_TIMEOUT_EXCEPTION_CODE = 4
+
+// FC event names jsmodbus emits when no buffer is provided
+const FC_EVENTS = [
+  'readCoils',
+  'readDiscreteInputs',
+  'readHoldingRegisters',
+  'readInputRegisters',
+  'writeSingleCoil',
+  'writeSingleRegister',
+  'writeMultipleCoils',
+  'writeMultipleRegisters'
+]
+
+
+module.exports = function (RED) {
+  'use strict'
+
+  function ModbusFlexServerConfigNode (config) {
+    RED.nodes.createNode(this, config)
+    const node = this
+
+    node.name = config.name || ''
+    node.host = config.host || '0.0.0.0'
+    node.port = Number(config.port || 502)
+    node.enforceResponseOrder = config.enforceResponseOrder !== false
+    node.pendingResponseTimeout = normalizePendingResponseTimeout(config.pendingResponseTimeout)
+
+    // Emitter used by modbus-dynamic-server nodes to receive incoming requests
+    node.emitter = new EventEmitter()
+
+    // requestId → { request, cb, eventName }
+    node.pendingRequests = new Map()
+    node._requestContexts = new WeakMap()
+
+    // connectionId → { nextSeqOut: Number, queue: Map<seqNum, { buf, writeCb }> }
+    node._connectionStates = new Map()
+
+    // connectionId → nextSeqIn counter
+    node._connectionSeqCounters = new Map()
+
+    node.netServer = new net.Server()
+
+
+    // Pass null for all buffers so jsmodbus emits FC events for every request
+    // instead of serving them automatically from an internal buffer.
+    node.modbusServer = new modbus.server.TCP(node.netServer, {
+      coils: null,
+      discrete: null,
+      holding: null,
+      input: null
+    })
+
+
+    node.modbusServer.on('connection', function (client) {
+      const socket = client.socket
+      const connectionId = randomUUID()
+
+      const remoteAddress = socket.remoteAddress || ''
+      const remotePort = Number(socket.remotePort) || 0
+      const localAddress = socket.localAddress || node.host
+      const localPort = Number(socket.localPort) || node.port
+      const meta = {
+        remoteAddress,
+        remotePort,
+        localAddress,
+        localPort,
+        remoteEndpoint: formatEndpoint(remoteAddress, remotePort),
+        localEndpoint: formatEndpoint(localAddress, localPort)
+      }
+
+      node._connectionStates.set(connectionId, { nextSeqOut: 0, queue: new Map(), meta })
+      node._connectionSeqCounters.set(connectionId, 0)
+
+      // Wrap the response handler so we can inject sequence numbers for
+      // in-order delivery per connection.
+      const origHandle = client._responseHandler.handle.bind(client._responseHandler)
+      client._responseHandler.handle = function (request, writeCb) {
+        const seqNum = node._connectionSeqCounters.get(connectionId)
+        node._connectionSeqCounters.set(connectionId, seqNum + 1)
+        node._requestContexts.set(request, { connectionId, seqNum })
+
+        const wrappedCb = function (responseBuffer) {
+          if (!node.enforceResponseOrder) {
+            writeCb(responseBuffer)
+            return
+          }
+          const connState = node._connectionStates.get(connectionId)
+          if (!connState) return
+
+          if (seqNum === connState.nextSeqOut) {
+            writeCb(responseBuffer)
+            connState.nextSeqOut++
+            // Drain any already-ready queued responses
+            while (connState.queue.has(connState.nextSeqOut)) {
+              const queued = connState.queue.get(connState.nextSeqOut)
+              connState.queue.delete(connState.nextSeqOut)
+              queued.writeCb(queued.buf)
+              connState.nextSeqOut++
+            }
+          } else {
+            connState.queue.set(seqNum, { buf: responseBuffer, writeCb })
+          }
+        }
+
+        return origHandle(request, wrappedCb)
+      }
+
+      socket.on('close', function () {
+        node._connectionStates.delete(connectionId)
+        node._connectionSeqCounters.delete(connectionId)
+        const cleanedRequests = node.cleanupPendingRequestsForConnection(connectionId)
+
+        node.log(`Client disconnected: ${connectionId}${cleanedRequests ? ` (cleared ${cleanedRequests} pending requests)` : ''}`)
+      })
+
+      node.log(`Client connected from ${socket.remoteAddress}:${socket.remotePort} (${connectionId})`)
+    })
+
+    // For this new jsmodbus connectin, register a handler for every possible FC event.
+    // The cb received here is already the wrappedCb from the connection handler above.
+    // These events will just be emitted to any 'dynamic server' nodes attached to
+    // this config object (under all but very odd circumstances there will only
+    // be one).
+    FC_EVENTS.forEach(function (eventName) {
+      node.modbusServer.on(eventName, function (request, cb) {
+        const body = request.body
+        const requestId = node.registerPendingRequest(request, cb, eventName)
+        const requestContext = node._requestContexts.get(request) || {}
+        const connectionState = requestContext.connectionId ? node._connectionStates.get(requestContext.connectionId) : null
+        const connectionMeta = connectionState ? connectionState.meta : null
+
+        node.emitter.emit('request', {
+          requestId,
+          eventName,
+          connection: {
+            id: requestContext.connectionId || null,
+            source: connectionMeta
+              ? {
+                  address: connectionMeta.remoteAddress,
+                  port: connectionMeta.remotePort,
+                  endpoint: connectionMeta.remoteEndpoint
+                }
+              : null,
+            destination: connectionMeta
+              ? {
+                  address: connectionMeta.localAddress,
+                  port: connectionMeta.localPort,
+                  endpoint: connectionMeta.localEndpoint
+                }
+              : null
+          },
+          request: {
+            fc: body.fc,
+            // Reads use .start/.count; writes use .address/.quantity
+            address: body.address !== undefined ? body.address : body.start,
+            quantity: body.quantity !== undefined ? body.quantity : (body.count !== undefined ? body.count : 1),
+            unitId: request.unitId,
+            transactionId: request.id,
+            body
+          }
+        })
+      })
+    })
+
+    node.takePendingRequest = function (requestId) {
+      const pending = node.pendingRequests.get(requestId)
+      if (!pending) {
+        return null
+      }
+
+      if (pending.timeoutHandle) {
+        clearTimeout(pending.timeoutHandle)
+      }
+
+      node.pendingRequests.delete(requestId)
+      return pending
+    }
+
+    node.cleanupPendingRequestsForConnection = function (connectionId) {
+      let cleanedRequests = 0
+
+      for (const [requestId, pending] of node.pendingRequests) {
+        if (pending.connectionId === connectionId) {
+          node.takePendingRequest(requestId)
+          cleanedRequests++
+        }
+      }
+
+      return cleanedRequests
+    }
+
+    node.registerPendingRequest = function (request, cb, eventName) {
+      const requestId = randomUUID()
+      const requestContext = node._requestContexts.get(request) || {}
+      const pending = {
+        request,
+        cb,
+        eventName,
+        connectionId: requestContext.connectionId,
+        seqNum: requestContext.seqNum
+      }
+
+      pending.timeoutHandle = setTimeout(function () {
+        const expiredPending = node.takePendingRequest(requestId)
+        if (!expiredPending) {
+          return
+        }
+
+        const connectionIsOpen = !expiredPending.connectionId || node._connectionStates.has(expiredPending.connectionId)
+        if (!connectionIsOpen) {
+          node.warn(`Pending Modbus response expired after ${node.pendingResponseTimeout}ms for requestId ${requestId}; connection already closed`)
+          return
+        }
+
+        node.warn(`Pending Modbus response expired after ${node.pendingResponseTimeout}ms for requestId ${requestId}; replying with exception ${DEFAULT_TIMEOUT_EXCEPTION_CODE}`)
+        try {
+          sendPendingResponse(expiredPending, { exception: DEFAULT_TIMEOUT_EXCEPTION_CODE })
+        } catch (err) {
+          node.error(`respondToRequest timeout error for ${expiredPending.eventName}: ${err.message}`)
+        }
+      }, node.pendingResponseTimeout)
+
+      node.pendingRequests.set(requestId, pending)
+      return requestId
+    }
+
+    node.netServer.on('error', function (err) {
+      node.error(`Server error: ${err.message}`)
+    })
+
+    node.netServer.listen(node.port, node.host, function () {
+      node.log(`Listening on ${node.host}:${node.port}`)
+    })
+
+    /**
+     * Called by modbus-dynamic-server-response to complete a pending request.
+     *
+     * @param {string} requestId - The requestId from msg.modbus.requestId
+     * @param {Array|Buffer|{exception: number}|{values: Array}} payload
+     *   - Read FCs:  array of values or Buffer, or { values: [...] }
+     *   - Write FCs: ignored (response is auto-built from the original request)
+     *   - Exception: { exception: <modbus exception code 1–11> }
+     * @returns {boolean} true on success, false if requestId not found
+     */
+    node.respondToRequest = function (requestId, payload) {
+      const pending = node.takePendingRequest(requestId)
+      if (!pending) {
+        node.warn(`respondToRequest: unknown requestId ${requestId}`)
+        return false
+      }
+
+      try {
+        const connectionIsOpen = !pending.connectionId || node._connectionStates.has(pending.connectionId)
+        if (!connectionIsOpen) {
+          node.warn(`respondToRequest: requestId ${requestId} connection already closed`)
+          return false
+        }
+
+        sendPendingResponse(pending, payload)
+        return true
+      } catch (err) {
+        node.error(`respondToRequest error for ${pending.eventName}: ${err.message}`)
+        return false
+      }
+    }
+
+    function sendPendingResponse (pending, payload) {
+      const { request, cb, eventName } = pending
+      let responseBody
+
+      if (payload && typeof payload === 'object' && !Array.isArray(payload) && !Buffer.isBuffer(payload) && payload.exception) {
+        responseBody = new resp.ExceptionResponseBody(request.body.fc, payload.exception)
+      } else {
+        responseBody = buildResponseBody(eventName, request, payload)
+      }
+
+      const response = TcpResponse.default.fromRequest(request, responseBody)
+      cb(response.createPayload())
+    }
+
+    function buildResponseBody (eventName, request, payload) {
+      const values = Array.isArray(payload)
+        ? payload
+        : (payload && payload.values)
+            ? payload.values
+            : payload
+
+      switch (eventName) {
+        case 'readCoils': {
+          const count = request.body.count
+          const coilArr = normalizeCoilValues(values, count)
+          return new resp.ReadCoilsResponseBody(coilArr, Math.ceil(count / 8))
+        }
+        case 'readDiscreteInputs': {
+          const count = request.body.count
+          const discArr = normalizeCoilValues(values, count)
+          return new resp.ReadDiscreteInputsResponseBody(discArr, Math.ceil(count / 8))
+        }
+        case 'readHoldingRegisters': {
+          const count = request.body.count
+          const regArr = normalizeRegisterValues(values, count)
+          return new resp.ReadHoldingRegistersResponseBody(count * 2, regArr)
+        }
+        case 'readInputRegisters': {
+          const count = request.body.count
+          const regArr = normalizeRegisterValues(values, count)
+          return new resp.ReadInputRegistersResponseBody(count * 2, regArr)
+        }
+        case 'writeSingleCoil':
+          return resp.WriteSingleCoilResponseBody.fromRequest(request.body)
+        case 'writeSingleRegister':
+          return resp.WriteSingleRegisterResponseBody.fromRequest(request.body)
+        case 'writeMultipleCoils':
+          return resp.WriteMultipleCoilsResponseBody.fromRequest(request.body)
+        case 'writeMultipleRegisters':
+          return resp.WriteMultipleRegistersResponseBody.fromRequest(request.body)
+        default:
+          throw new Error(`Unknown FC event: ${eventName}`)
+      }
+    }
+
+    function normalizeRegisterValues (values, count) {
+      if (Buffer.isBuffer(values)) {
+        const expected = count * 2
+        if (values.length === expected) return values
+        // wrong size — reallocate and copy what we can
+        const buf = Buffer.alloc(expected, 0)
+        values.copy(buf, 0, 0, Math.min(values.length, expected))
+        return buf
+      }
+      if (Array.isArray(values)) {
+        const padded = new Array(count).fill(0)
+        values.slice(0, count).forEach((v, i) => { padded[i] = v })
+        return padded
+      }
+      return new Array(count).fill(0)
+    }
+
+    function normalizeCoilValues (values, count) {
+      if (Buffer.isBuffer(values)) {
+        const expected = Math.ceil(count / 8)
+        if (values.length === expected) return values
+        const buf = Buffer.alloc(expected, 0)
+        values.copy(buf, 0, 0, Math.min(values.length, expected))
+        return buf
+      }
+      if (Array.isArray(values)) {
+        const padded = new Array(count).fill(0)
+        values.slice(0, count).forEach((v, i) => { padded[i] = v ? 1 : 0 })
+        return padded
+      }
+      return new Array(count).fill(0)
+    }
+
+    node.on('close', function (done) {
+      for (const requestId of node.pendingRequests.keys()) {
+        node.takePendingRequest(requestId)
+      }
+      node._connectionStates.clear()
+      node._connectionSeqCounters.clear()
+      if (node.netServer) {
+        node.netServer.close(function (err) {
+          done(err || undefined)
+        })
+      } else {
+        done()
+      }
+    })
+  }
+
+  function normalizePendingResponseTimeout (value) {
+    const timeout = Number(value)
+    return Number.isFinite(timeout) && timeout > 0 ? timeout : DEFAULT_PENDING_RESPONSE_TIMEOUT_MS
+  }
+
+  function formatEndpoint (address, port) {
+    if (!address && !port) return ''
+    return `${address || ''}:${port || 0}`
+  }
+
+  RED.nodes.registerType('modbus-dynamic-server-config', ModbusFlexServerConfigNode)
+}

package/src/modbus-dynamic-server-response.html

@@ -0,0 +1,88 @@
+<script type="text/html" data-template-name="modbus-dynamic-server-response">
+    <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>
+
+</script>
+
+<script type="text/html" data-help-name="modbus-dynamic-server-response">
+    <p>Completes a pending Modbus request by sending a response back to the connected client.
+    The input message must carry the <code>requestId</code> originally emitted by a
+    <code>modbus-dynamic-server</code> node.</p>
+
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+        <dt>_modbus.requestId <span class="property-type">string</span></dt>
+        <dd>Required internal request context populated by <code>modbus-dynamic-server</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">array | Buffer | object</span></dt>
+        <dd>
+            The response value(s) to send back to the Modbus client:
+            <ul>
+                <li><b>Read requests (FC1–FC4):</b> an array of values, a <code>Buffer</code>,
+                or an object <code>{ values: [...] }</code>.</li>
+                <li><b>Write requests (FC5, FC6, FC15, FC16):</b> ignored — the response is
+                built automatically from the original request body.</li>
+                <li><b>Exception:</b> an object <code>{ exception: &lt;code&gt; }</code> where
+                code is a Modbus exception code (1–11).</li>
+            </ul>
+        </dd>
+    </dl>
+
+    <h3>Outputs</h3>
+    <ol class="node-ports">
+        <li>Response report message
+            <dl class="message-properties">
+                <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>Details</h3>
+    <p>Once <code>respondToRequest</code> is called, the pending request is consumed and cannot be
+    answered again. This node now emits one message so flows can inspect what was sent.</p>
+    <p>If <code>msg._modbus</code> is missing, this node cannot respond and logs
+    <em>Missing Modbus request context</em>.</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>For a simpler alternative that automatically reads/writes values from a shared register map
+    without manual payload construction, use the <code>modbus-registers-respond</code> node instead.</p>
+</script>
+
+<script type="text/javascript">
+  RED.nodes.registerType('modbus-dynamic-server-response', {
+    category: 'modbus',
+    color: '#E9967A',
+    defaults: {
+      name: { value: '' }
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: 'arrow-out.svg',
+    label: function () {
+      return this.name || 'Modbus Dynamic Response'
+    }
+  })
+</script>

package/src/modbus-dynamic-server-response.js

@@ -0,0 +1,160 @@
+const { respondWithPayload } = require('./modbus-response-context')
+
+module.exports = function (RED) {
+  function ModbusFlexServerResponseNode (config) {
+    RED.nodes.createNode(this, config)
+    const node = this
+
+    node.status({ fill: 'grey', shape: 'ring', text: 'ready' })
+
+    node.on('input', function (msg, send, done) {
+      const responseResult = respondWithPayload(RED, node, msg, msg.payload)
+      if (!responseResult.context) {
+        node.status({ fill: 'red', shape: 'ring', text: 'missing context' })
+        done()
+        return
+      }
+
+      const context = responseResult.context
+      const eventName = context.eventName || (msg.modbus && msg.modbus.eventName)
+      const address = context.address !== undefined ? context.address : (msg.modbus && msg.modbus.address)
+      const quantity = context.quantity !== undefined ? context.quantity : (msg.modbus && msg.modbus.quantity)
+      const requestId = context.requestId
+      const ok = responseResult.ok
+      const actualDataSent = deriveActualDataSent(eventName, quantity, msg.payload)
+
+      msg.modbusResponse = {
+        requestId,
+        eventName,
+        address,
+        quantity,
+        payloadSubmitted: clonePayload(msg.payload),
+        payloadType: describePayload(msg.payload),
+        actualDataSent,
+        actualDataType: describePayload(actualDataSent),
+        ok,
+        timestamp: new Date().toISOString()
+      }
+
+      // Write FC responses are generated from the original request body by jsmodbus.
+      if (typeof eventName === 'string' && eventName.startsWith('write')) {
+        msg.modbusResponse.note = 'Write FC response is auto-built from request body by server config'
+      }
+
+      if (ok) {
+        node.status({ fill: 'green', shape: 'dot', text: 'responded' })
+        send(msg)
+        done()
+      } else {
+        node.status({ fill: 'red', shape: 'ring', text: 'unknown requestId' })
+        done(new Error(`modbus-dynamic-server-response: unknown requestId ${requestId}`))
+      }
+    })
+
+    node.on('close', function () {
+      // nothing to clean up; pending requests are owned by the config node
+    })
+  }
+
+  function clonePayload (payload) {
+    if (Buffer.isBuffer(payload)) {
+      return Buffer.from(payload)
+    }
+    if (Array.isArray(payload)) {
+      return payload.slice()
+    }
+    if (payload && typeof payload === 'object') {
+      return { ...payload }
+    }
+    return payload
+  }
+
+  function describePayload (payload) {
+    if (Buffer.isBuffer(payload)) return 'buffer'
+    if (Array.isArray(payload)) return 'array'
+    return typeof payload
+  }
+
+  function deriveActualDataSent (eventName, quantity, payload) {
+    const count = Number(quantity)
+    if (!Number.isFinite(count) || count <= 0) {
+      return payload
+    }
+
+    if (eventName === 'readHoldingRegisters' || eventName === 'readInputRegisters') {
+      return normalizeWordPayload(payload, count)
+    }
+
+    if (eventName === 'readCoils' || eventName === 'readDiscreteInputs') {
+      return normalizeBitPayload(payload, count)
+    }
+
+    // write responses are auto-built from request body by server config
+    return payload
+  }
+
+  function normalizeWordPayload (payload, count) {
+    const values = resolveValues(payload)
+
+    if (Buffer.isBuffer(values)) {
+      const expectedBytes = count * 2
+      const buf = Buffer.alloc(expectedBytes, 0)
+      values.copy(buf, 0, 0, Math.min(values.length, expectedBytes))
+      const words = []
+      for (let i = 0; i < expectedBytes; i += 2) {
+        words.push(buf.readUInt16BE(i))
+      }
+      return words
+    }
+
+    if (Array.isArray(values)) {
+      const out = new Array(count).fill(0)
+      values.slice(0, count).forEach(function (v, i) {
+        out[i] = Number(v) & 0xffff
+      })
+      return out
+    }
+
+    return new Array(count).fill(0)
+  }
+
+  function normalizeBitPayload (payload, count) {
+    const values = resolveValues(payload)
+
+    if (Buffer.isBuffer(values)) {
+      const out = new Array(count).fill(0)
+      for (let i = 0; i < count; i++) {
+        const byteIndex = Math.floor(i / 8)
+        const bitIndex = i % 8
+        if (byteIndex < values.length) {
+          out[i] = (values[byteIndex] >> bitIndex) & 1
+        }
+      }
+      return out
+    }
+
+    if (Array.isArray(values)) {
+      const out = new Array(count).fill(0)
+      values.slice(0, count).forEach(function (v, i) {
+        out[i] = v ? 1 : 0
+      })
+      return out
+    }
+
+    return new Array(count).fill(0)
+  }
+
+  function resolveValues (payload) {
+    if (Array.isArray(payload) || Buffer.isBuffer(payload)) {
+      return payload
+    }
+
+    if (payload && typeof payload === 'object' && Array.isArray(payload.values)) {
+      return payload.values
+    }
+
+    return payload
+  }
+
+  RED.nodes.registerType('modbus-dynamic-server-response', ModbusFlexServerResponseNode)
+}