node-red-modbus-dynamic-server 0.1.0

package/src/modbus-dynamic-proxy.js

@@ -0,0 +1,400 @@
+const jsmodbus = require('jsmodbus')
+const ModbusTCPRequest = require('jsmodbus/dist/tcp-request').default
+const { respondWithPayload } = require('./modbus-response-context')
+
+module.exports = function (RED) {
+  function ModbusDynamicProxyNode (config) {
+	RED.nodes.createNode(this, config)
+	const node = this
+
+	node.name = config.name || ''
+	node.proxyTarget = RED.nodes.getNode(config.proxyTarget)
+
+	if (!node.proxyTarget) {
+	  node.status({ fill: 'red', shape: 'ring', text: 'no proxy target' })
+	  return
+	}
+
+	node._lastStatusText = 'ready'
+
+	function getConnectionStyle () {
+	  if (!node.proxyTarget) {
+		return { fill: 'red', shape: 'ring' }
+	  }
+
+	  if (node.proxyTarget.targetType === 'tcp') {
+		if (node.proxyTarget._connected) {
+		  return { fill: 'green', shape: 'dot' }
+		}
+
+		if (node.proxyTarget._connecting) {
+		  return { fill: 'yellow', shape: 'ring' }
+		}
+
+		return { fill: 'red', shape: 'ring' }
+	  }
+
+	  // Serial target exists but current proxy-target serial path is stubbed.
+	  return { fill: 'yellow', shape: 'ring' }
+	}
+
+	function updateConnectionStatus (statusText) {
+	  if (typeof statusText === 'string' && statusText.length > 0) {
+		node._lastStatusText = statusText
+	  }
+
+	  const style = getConnectionStyle()
+	  node.status({ fill: style.fill, shape: style.shape, text: node._lastStatusText })
+	}
+
+	updateConnectionStatus()
+	node._statusTimer = setInterval(function () {
+	  updateConnectionStatus()
+	}, 1000)
+
+	node.on('input', function (msg, send, done) {
+	  const context = msg._modbus || {}
+	  const requestId = context.requestId
+	  const eventName = context.eventName
+	  const address = context.address
+	  const quantity = context.quantity
+	  const request = msg.payload || {}
+
+	  if (!requestId || !eventName) {
+		node.status({ fill: 'red', shape: 'ring', text: 'missing context' })
+		node.error('Missing Modbus request context', msg)
+		done()
+		return
+	  }
+
+	  // Extract request buffer from msg or construct from Modbus request
+	  const requestBuffer = msg.requestBuffer || constructModbusRequest(request)
+	  if (!requestBuffer) {
+		done(new Error('modbus-dynamic-proxy: unable to construct request buffer'))
+		return
+	  }
+
+
+	  // Send to proxy target queue
+	  node.proxyTarget.enqueueRequest(requestBuffer, function (proxyResult) {
+		const debugEnabled = msg.modbusProxyDebug === true
+		if (!proxyResult.ok) {
+		  // Send Modbus exception back to server
+		  const exceptionCode = proxyResult.exception || 4
+		  const responseResult = respondWithPayload(RED, node, msg, { exception: exceptionCode })
+		  const ok = responseResult.ok
+
+		  if (!responseResult.context) {
+			node.status({ fill: 'red', shape: 'ring', text: 'missing context' })
+			done()
+			return
+		  }
+
+		  if (!ok) {
+			node.status({ fill: 'red', shape: 'ring', text: 'unknown request' })
+			done(new Error(`modbus-dynamic-proxy: request ${requestId} could not be responded to`))
+			return
+		  }
+
+		  updateConnectionStatus(`exception ${exceptionCode}`)
+
+		  const outputMsg = {
+			payload: null,
+			modbusProxy: {
+			  requestId,
+			  eventName,
+			  fc: request.fc,
+			  address: address !== undefined ? address : request.address,
+			  quantity: quantity !== undefined ? quantity : request.quantity,
+			  proxied: false,
+			  proxyError: proxyResult.error,
+			  exception: exceptionCode,
+			  targetType: node.proxyTarget.targetType
+			}
+		  }
+
+		  send(outputMsg)
+		  done()
+		  return
+		}
+
+		// Parse response and send back to server
+		const parsedResponse = parseModbusResponse(proxyResult.responseBuffer, eventName, quantity !== undefined ? quantity : request.quantity)
+		const responseSummary = summarizeTcpResponse(proxyResult.responseBuffer)
+		if (debugEnabled) {
+		  node.warn(`modbus-dynamic-proxy raw response requestId=${requestId} summary=${JSON.stringify(responseSummary)}`)
+		}
+		if (!parsedResponse) {
+		  const responseResult = respondWithPayload(RED, node, msg, { exception: 4 })
+		  const ok = responseResult.ok
+
+		  if (!responseResult.context) {
+			node.status({ fill: 'red', shape: 'ring', text: 'missing context' })
+			done()
+			return
+		  }
+
+		  if (!ok) {
+			done(new Error(`modbus-dynamic-proxy: request ${requestId} could not be responded to`))
+			return
+		  }
+
+		  updateConnectionStatus('parse error')
+
+		  const outputMsg = {
+			payload: null,
+			modbusProxy: {
+			  requestId,
+			  eventName,
+			  fc: request.fc,
+			  address: address !== undefined ? address : request.address,
+			  quantity: quantity !== undefined ? quantity : request.quantity,
+			  proxied: false,
+			  parseError: true,
+			  exception: 4,
+			  targetType: node.proxyTarget.targetType
+			}
+		  }
+
+		  send(outputMsg)
+		  done()
+		  return
+		}
+
+		// Send response back to server
+		const responseResult = respondWithPayload(RED, node, msg, parsedResponse)
+		const ok = responseResult.ok
+
+		if (!responseResult.context) {
+		  node.status({ fill: 'red', shape: 'ring', text: 'missing context' })
+		  done()
+		  return
+		}
+
+		if (!ok) {
+		  node.status({ fill: 'red', shape: 'ring', text: 'unknown request' })
+		  done(new Error(`modbus-dynamic-proxy: request ${requestId} could not be responded to`))
+		  return
+		}
+
+		updateConnectionStatus(`proxied ${eventName}`)
+
+		// Emit the proxied response for caching/inspection
+		const outputMsg = {
+		  payload: proxyResult.responseBuffer,
+		  modbusProxy: {
+			requestId,
+			eventName,
+			fc: request.fc,
+			address: address !== undefined ? address : request.address,
+			quantity: quantity !== undefined ? quantity : request.quantity,
+			proxied: true,
+			targetType: node.proxyTarget.targetType,
+			responseSummary
+		  }
+		}
+
+		if (debugEnabled) {
+		  outputMsg.modbusProxy.parsedResponsePreview = previewParsedResponse(parsedResponse)
+		  node.warn(`modbus-dynamic-proxy parsed response requestId=${requestId} parsed=${JSON.stringify(outputMsg.modbusProxy.parsedResponsePreview)}`)
+		}
+
+		send(outputMsg)
+		done()
+	  })
+	})
+
+	node.on('close', function (done) {
+	  if (node._statusTimer) {
+		clearInterval(node._statusTimer)
+		node._statusTimer = null
+	  }
+	  // nothing to clean up; queue is owned by proxy target config node
+	  done()
+	})
+  }
+
+  function constructModbusRequest (request) {
+	if (!request || typeof request !== 'object') {
+	  return null
+	}
+
+	const fc = Number(request.fc)
+	const address = Number(request.address)
+	const quantity = Number(request.quantity)
+	const unitId = Number(request.unitId) || 0
+
+	if (!Number.isFinite(fc) || !Number.isFinite(address) || !Number.isFinite(quantity)) {
+	  return null
+	}
+
+	// Validate FC and address/quantity ranges
+	if (fc < 1 || fc > 16 || [7, 8, 9, 10, 11, 12, 13, 14].includes(fc)) {
+	  return null
+	}
+
+	if (address < 0 || address > 65535 || quantity < 1 || quantity > 65535) {
+	  return null
+	}
+
+	try {
+	  let requestBody
+
+	  switch (fc) {
+		case 1:
+		  requestBody = new jsmodbus.requests.ReadCoilsRequestBody(address, quantity)
+		  break
+		case 2:
+		  requestBody = new jsmodbus.requests.ReadDiscreteInputsRequestBody(address, quantity)
+		  break
+		case 3:
+		  requestBody = new jsmodbus.requests.ReadHoldingRegistersRequestBody(address, quantity)
+		  break
+		case 4:
+		  requestBody = new jsmodbus.requests.ReadInputRegistersRequestBody(address, quantity)
+		  break
+		case 5:
+		case 6:
+		case 15:
+		case 16:
+		  // Write requests need values which aren't in this basic payload
+		  // Return null to indicate request buffer should be passed via msg.requestBuffer
+		  return null
+		default:
+		  return null
+	  }
+
+	  if (!requestBody) {
+		return null
+	  }
+
+	  // Wrap in Modbus TCP request
+	  const tcpRequest = new ModbusTCPRequest(requestBody)
+	  // Constructor puts requestBody in _id, move it to _body
+	  tcpRequest._body = tcpRequest._id
+	  tcpRequest._id = 1
+	  tcpRequest._protocol = 0
+	  tcpRequest._length = 0
+	  tcpRequest._unitId = unitId
+
+	  return tcpRequest.createPayload()
+	} catch (err) {
+	  return null
+	}
+  }
+
+  function parseModbusResponse (responseBuffer, eventName, quantity) {
+	if (!Buffer.isBuffer(responseBuffer) || responseBuffer.length < 9) {
+	  return null
+	}
+
+	// Modbus TCP MBAP header (7 bytes) + PDU
+	const pduOffset = 7
+	const fc = responseBuffer[pduOffset]
+
+	// Exception response: FC | 0x80, exception byte follows
+	if ((fc & 0x80) === 0x80) {
+	  if (responseBuffer.length < pduOffset + 2) {
+		return null
+	  }
+	  return { exception: responseBuffer[pduOffset + 1] }
+	}
+
+	if (eventName === 'readHoldingRegisters' || eventName === 'readInputRegisters') {
+	  const byteCount = responseBuffer[pduOffset + 1]
+	  const start = pduOffset + 2
+	  const end = start + byteCount
+	  if (responseBuffer.length < end) {
+		return null
+	  }
+
+	  // Decode into register word array so server config builds an unambiguous response.
+	  const data = responseBuffer.slice(start, end)
+	  const words = []
+	  for (let i = 0; i + 1 < data.length; i += 2) {
+		words.push(data.readUInt16BE(i))
+	  }
+	  return words
+	}
+
+	if (eventName === 'readCoils' || eventName === 'readDiscreteInputs') {
+	  const byteCount = responseBuffer[pduOffset + 1]
+	  const start = pduOffset + 2
+	  const end = start + byteCount
+	  if (responseBuffer.length < end) {
+		return null
+	  }
+
+	  // Decode packed bits to explicit coil/discrete array.
+	  const count = Number(quantity)
+	  if (!Number.isFinite(count) || count <= 0) {
+		return []
+	  }
+
+	  const out = new Array(count).fill(0)
+	  const data = responseBuffer.slice(start, end)
+	  for (let i = 0; i < count; i++) {
+		const byteIndex = Math.floor(i / 8)
+		const bitIndex = i % 8
+		if (byteIndex < data.length) {
+		  out[i] = (data[byteIndex] >> bitIndex) & 1
+		}
+	  }
+	  return out
+	}
+
+	// For write responses, return undefined (server builds auto-response)
+	if (eventName.startsWith('write')) {
+	  return undefined
+	}
+
+	return null
+  }
+
+  function summarizeTcpResponse (responseBuffer) {
+	if (!Buffer.isBuffer(responseBuffer) || responseBuffer.length < 9) {
+	  return { valid: false }
+	}
+
+	const transactionId = responseBuffer.readUInt16BE(0)
+	const protocolId = responseBuffer.readUInt16BE(2)
+	const mbapLength = responseBuffer.readUInt16BE(4)
+	const unitId = responseBuffer[6]
+	const fc = responseBuffer[7]
+	const byteCount = responseBuffer.length > 8 ? responseBuffer[8] : null
+
+	let dataWords = []
+	if ((fc & 0x80) === 0 && Number.isInteger(byteCount) && byteCount >= 2 && responseBuffer.length >= 9 + byteCount) {
+	  const data = responseBuffer.slice(9, 9 + byteCount)
+	  for (let i = 0; i + 1 < data.length; i += 2) {
+		dataWords.push(data.readUInt16BE(i))
+	  }
+	}
+
+	return {
+	  valid: true,
+	  transactionId,
+	  protocolId,
+	  mbapLength,
+	  unitId,
+	  fc,
+	  byteCount,
+	  dataWords,
+	  rawHex: responseBuffer.toString('hex')
+	}
+  }
+
+  function previewParsedResponse (parsedResponse) {
+	if (parsedResponse === undefined) return { type: 'undefined' }
+	if (Buffer.isBuffer(parsedResponse)) {
+	  return { type: 'buffer', hex: parsedResponse.toString('hex') }
+	}
+	if (Array.isArray(parsedResponse)) {
+	  return { type: 'array', values: parsedResponse }
+	}
+	return { type: typeof parsedResponse, value: parsedResponse }
+  }
+
+  RED.nodes.registerType('modbus-dynamic-proxy', ModbusDynamicProxyNode)
+}
+

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

@@ -0,0 +1,85 @@
+<script type="text/html" data-template-name="modbus-dynamic-server-config">
+
+    <div class="form-row">
+        <label for="node-config-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-config-input-name" placeholder="Optional name">
+    </div>
+
+    <div class="form-row">
+        <label for="node-config-input-host"><i class="fa fa-globe"></i> Host</label>
+        <input type="text" id="node-config-input-host" placeholder="0.0.0.0">
+    </div>
+
+    <div class="form-row">
+        <label for="node-config-input-port"><i class="fa fa-random"></i> Port</label>
+        <input type="number" id="node-config-input-port" placeholder="502">
+    </div>
+
+    <div class="form-row">
+        <label for="node-config-input-enforceResponseOrder">
+            <i class="fa fa-sort-numeric-asc"></i> Enforce Response Order
+        </label>
+        <input type="checkbox" id="node-config-input-enforceResponseOrder" style="display:inline-block; width:auto;">
+    </div>
+
+    <div class="form-row">
+        <label for="node-config-input-pendingResponseTimeout">
+            <i class="fa fa-clock-o"></i> Pending Response Timeout (ms)
+        </label>
+        <input type="number" id="node-config-input-pendingResponseTimeout" placeholder="300000">
+    </div>
+
+</script>
+
+<script type="text/html" data-help-name="modbus-dynamic-server-config">
+    <p>Configures and starts a Modbus TCP server. All incoming function-code requests are held as
+    <em>pending requests</em> and dispatched to connected <code>modbus-dynamic-server</code> nodes
+    for processing.</p>
+
+    <h3>Configuration</h3>
+    <dl class="message-properties">
+        <dt>Name <span class="property-type">string</span></dt>
+        <dd>Optional label shown in the editor.</dd>
+
+        <dt>Host <span class="property-type">string</span></dt>
+        <dd>IP address or hostname the TCP server will bind to. Use <code>0.0.0.0</code> to listen
+        on all interfaces. Default: <code>0.0.0.0</code>.</dd>
+
+        <dt>Port <span class="property-type">number</span></dt>
+        <dd>TCP port to listen on. Default: <code>502</code>.</dd>
+
+        <dt>Enforce Response Order <span class="property-type">boolean</span></dt>
+        <dd>When enabled, responses for a given TCP connection are written back in the same order
+        the requests were received, regardless of which response is completed first. Default: enabled.</dd>
+
+        <dt>Pending Response Timeout (ms) <span class="property-type">number</span></dt>
+        <dd>Maximum time in milliseconds a request may remain unanswered before the server
+        automatically replies with a Modbus exception code&nbsp;4 (Server Failure).
+        Default: <code>300000</code> (5 minutes).</dd>
+    </dl>
+
+    <h3>Details</h3>
+    <p>One config node represents one Modbus TCP server instance. Multiple
+    <code>modbus-dynamic-server</code> nodes can reference the same config node; each
+    will receive a copy of every incoming request message.</p>
+    <p>Requests are held internally by a <em>requestId</em> UUID until a response node calls
+    <code>respondToRequest</code>. If no response arrives within the timeout window the server
+    sends a Gateway Path Unavailable exception to the client automatically.</p>
+</script>
+
+<script type="text/javascript">
+  RED.nodes.registerType('modbus-dynamic-server-config', {
+    category: 'config',
+    defaults: {
+      name: { value: '' },
+      host: { value: '0.0.0.0', required: true },
+      port: { value: 502, required: true, validate: RED.validators.number() },
+      enforceResponseOrder: { value: true },
+      pendingResponseTimeout: { value: 300000, required: true, validate: RED.validators.number() }
+
+    },
+    label: function () {
+      return this.name || this.host + ':' + this.port
+    }
+  })
+</script>