node-red-modbus-dynamic-server 0.1.0

package/src/modbus-proxy-target.js

@@ -0,0 +1,302 @@
+const net = require('net')
+
+module.exports = function (RED) {
+  function ModbusProxyTargetNode (config) {
+	RED.nodes.createNode(this, config)
+	const node = this
+
+	node.name = config.name || ''
+	node.targetType = config.targetType || 'tcp'
+	node.timeout = normalizeTimeout(config.timeout, 5000)
+
+	// TCP settings
+	node.tcpHost = config.tcpHost || 'localhost'
+	node.tcpPort = normalizePort(config.tcpPort, 502)
+
+	// Serial settings
+	node.serialPort = config.serialPort || '/dev/ttyUSB0'
+	node.serialBaud = normalizeBaud(config.serialBaud, 9600)
+	node.serialParity = config.serialParity || 'none'
+	node.serialWordLength = normalizeWordLength(config.serialWordLength, 8)
+	node.serialStopBits = normalizeStopBits(config.serialStopBits, 1)
+
+	// Request queue and connection state
+	node._requestQueue = []
+	node._processing = false
+	node._connection = null
+	node._lastError = null
+	node._activeRequest = null
+	node._activeTimeout = null
+	node._incomingBuffer = Buffer.alloc(0)
+	node._connecting = false
+	node._connected = false
+	node._closing = false
+	node._reconnectTimer = null
+	node._reconnectDelay = 1000
+
+	node.enqueueRequest = function (requestBuffer, callback) {
+	  node._requestQueue.push({
+		buffer: requestBuffer,
+		callback,
+		timestamp: Date.now(),
+		retries: 0
+	  })
+
+	  node._processQueue()
+	}
+
+	node._processQueue = function () {
+	  if (node._activeRequest || node._closing) {
+		return
+	  }
+
+	  if (node._requestQueue.length === 0) {
+		node._processing = false
+		return
+	  }
+
+	  if (node.targetType === 'tcp') {
+		node._ensureTcpConnection()
+		if (!node._connected || !node._connection) {
+		  node._processing = true
+		  return
+		}
+
+		node._processing = true
+		const request = node._requestQueue.shift()
+		node._sendViaTcp(request)
+		return
+	  }
+
+	  // Serial path remains single-request and currently unimplemented.
+	  node._processing = true
+	  const request = node._requestQueue.shift()
+	  node._sendRequest(request)
+	}
+
+	node._sendRequest = function (request) {
+	  const requestTimeout = setTimeout(function () {
+		node._lastError = 'Timeout'
+		request.callback({
+		  ok: false,
+		  error: 'timeout',
+		  exception: 4 // Gateway Path Unavailable
+		})
+
+		// Close connection on timeout and continue with next
+		if (node._connection) {
+		  if (node.targetType === 'tcp') {
+			node._connection.destroy()
+		  }
+		  node._connection = null
+		}
+
+		node._processQueue()
+	  }, node.timeout)
+
+	  if (node.targetType === 'tcp') {
+		// TCP uses persistent connection flow and per-request timeout managed in _sendViaTcp.
+		clearTimeout(requestTimeout)
+		node._requestQueue.unshift(request)
+		node._processQueue()
+	  } else if (node.targetType === 'serial') {
+		node._sendViaSerial(request, requestTimeout)
+	  } else {
+		clearTimeout(requestTimeout)
+		request.callback({
+		  ok: false,
+		  error: 'unsupported target type',
+		  exception: 4
+		})
+		node._processQueue()
+	  }
+	}
+
+	node._sendViaTcp = function (request) {
+	  if (!node._connected || !node._connection) {
+		node._requestQueue.unshift(request)
+		node._ensureTcpConnection()
+		return
+	  }
+
+	  node._activeRequest = request
+	  node._activeTimeout = setTimeout(function () {
+		node._failActiveRequest('timeout')
+		if (node._connection) {
+		  node._connection.destroy()
+		}
+	  }, node.timeout)
+
+	  try {
+		node._connection.write(request.buffer)
+	  } catch (err) {
+		node._failActiveRequest(err.message || 'write failed')
+		if (node._connection) {
+		  node._connection.destroy()
+		}
+	  }
+	}
+
+	node._ensureTcpConnection = function () {
+	  if (node._closing || node.targetType !== 'tcp') return
+	  if (node._connected || node._connecting) return
+
+	  node._connecting = true
+	  node.status({ fill: 'yellow', shape: 'ring', text: 'connecting' })
+
+	  const socket = net.createConnection({ host: node.tcpHost, port: node.tcpPort })
+	  node._connection = socket
+
+	  socket.on('connect', function () {
+		node._connecting = false
+		node._connected = true
+		node._lastError = null
+		node._incomingBuffer = Buffer.alloc(0)
+		node.status({ fill: 'green', shape: 'dot', text: 'connected' })
+		node._processQueue()
+	  })
+
+	  socket.on('data', function (chunk) {
+		node._incomingBuffer = Buffer.concat([node._incomingBuffer, chunk])
+		node._drainIncomingFrames()
+	  })
+
+	  socket.on('error', function (err) {
+		node._lastError = err.message
+		node._failActiveRequest(err.message)
+	  })
+
+	  socket.on('close', function () {
+		node._connected = false
+		node._connecting = false
+		node._connection = null
+		node._incomingBuffer = Buffer.alloc(0)
+		node._failActiveRequest(node._lastError || 'connection closed')
+		if (!node._closing) {
+		  node.status({ fill: 'red', shape: 'ring', text: 'disconnected' })
+		  node._scheduleReconnect()
+		}
+	  })
+	}
+
+	node._drainIncomingFrames = function () {
+	  while (node._incomingBuffer.length >= 6) {
+		const mbapLength = node._incomingBuffer.readUInt16BE(4)
+		const expectedFrameLength = 6 + mbapLength
+		if (node._incomingBuffer.length < expectedFrameLength) {
+		  return
+		}
+
+		const frame = Buffer.from(node._incomingBuffer.slice(0, expectedFrameLength))
+		node._incomingBuffer = Buffer.from(node._incomingBuffer.slice(expectedFrameLength))
+
+		if (node._activeRequest) {
+		  const active = node._activeRequest
+		  node._activeRequest = null
+		  clearTimeout(node._activeTimeout)
+		  node._activeTimeout = null
+		  active.callback({ ok: true, responseBuffer: frame, error: null })
+		  node._processing = false
+		  node._processQueue()
+		}
+	  }
+	}
+
+	node._failActiveRequest = function (error) {
+	  if (!node._activeRequest) return
+	  const active = node._activeRequest
+	  node._activeRequest = null
+	  clearTimeout(node._activeTimeout)
+	  node._activeTimeout = null
+	  active.callback({ ok: false, error, exception: 4 })
+	  node._processing = false
+	}
+
+	node._scheduleReconnect = function () {
+	  if (node._reconnectTimer || node._closing || node.targetType !== 'tcp') return
+	  node._reconnectTimer = setTimeout(function () {
+		node._reconnectTimer = null
+		node._ensureTcpConnection()
+	  }, node._reconnectDelay)
+	}
+
+	node._sendViaSerial = function (request, requestTimeout) {
+	  // Serial support stub - would require 'serialport' package
+	  clearTimeout(requestTimeout)
+	  node._lastError = 'Serial not yet implemented'
+	  request.callback({
+		ok: false,
+		error: 'serial not implemented',
+		exception: 4
+	  })
+	  node._processQueue()
+	}
+
+	node.on('close', function (done) {
+	  node._closing = true
+	  if (node._reconnectTimer) {
+		clearTimeout(node._reconnectTimer)
+		node._reconnectTimer = null
+	  }
+	  if (node._activeTimeout) {
+		clearTimeout(node._activeTimeout)
+		node._activeTimeout = null
+	  }
+	  node._activeRequest = null
+	  if (node._connection) {
+		node._connection.destroy()
+		node._connection = null
+	  }
+	  node._requestQueue = []
+	  done()
+	})
+
+	if (node.targetType === 'tcp') {
+	  node._ensureTcpConnection()
+	}
+  }
+
+  function normalizeTimeout (value, fallback) {
+	const parsed = Number(value)
+	if (!Number.isFinite(parsed) || parsed <= 0) {
+	  return fallback
+	}
+	return Math.floor(parsed)
+  }
+
+  function normalizePort (value, fallback) {
+	const parsed = Number(value)
+	if (!Number.isFinite(parsed) || parsed < 1 || parsed > 65535) {
+	  return fallback
+	}
+	return Math.floor(parsed)
+  }
+
+  function normalizeBaud (value, fallback) {
+	const validBauds = [300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, 115200]
+	const parsed = Number(value)
+	if (validBauds.includes(parsed)) {
+	  return parsed
+	}
+	return fallback
+  }
+
+  function normalizeWordLength (value, fallback) {
+	const parsed = Number(value)
+	if (parsed === 5 || parsed === 6 || parsed === 7 || parsed === 8) {
+	  return parsed
+	}
+	return fallback
+  }
+
+  function normalizeStopBits (value, fallback) {
+	const parsed = Number(value)
+	if (parsed === 1 || parsed === 2) {
+	  return parsed
+	}
+	return fallback
+  }
+
+  RED.nodes.registerType('modbus-proxy-target', ModbusProxyTargetNode)
+}
+

package/src/modbus-registers-config.html

@@ -0,0 +1,109 @@
+<script type="text/html" data-template-name="modbus-registers-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-holdingRegisters"><i class="fa fa-list-ol"></i> Holding Registers</label>
+		<input type="number" id="node-config-input-holdingRegisters" min="0" placeholder="100">
+	</div>
+
+	<div class="form-row">
+		<label for="node-config-input-inputRegisters"><i class="fa fa-list-ol"></i> Input Registers</label>
+		<input type="number" id="node-config-input-inputRegisters" min="0" placeholder="100">
+	</div>
+
+	<div class="form-row">
+		<label for="node-config-input-coilRegisters"><i class="fa fa-dot-circle-o"></i> Coil Registers</label>
+		<input type="number" id="node-config-input-coilRegisters" min="0" placeholder="100">
+	</div>
+
+	<div class="form-row">
+		<label for="node-config-input-discreteRegisters"><i class="fa fa-dot-circle-o"></i> Discrete Inputs</label>
+		<input type="number" id="node-config-input-discreteRegisters" min="0" placeholder="100">
+	</div>
+
+	<div class="form-row">
+		<label for="node-config-input-wordOrderMode"><i class="fa fa-exchange"></i> 32-bit Word Order</label>
+		<select id="node-config-input-wordOrderMode">
+			<option value="ABCD">ABCD (Big-endian word, big-endian byte)</option>
+			<option value="CDAB">CDAB (Little-endian word, big-endian byte)</option>
+			<option value="BADC">BADC (Big-endian word, little-endian byte)</option>
+			<option value="DCBA">DCBA (Little-endian word, little-endian byte)</option>
+		</select>
+	</div>
+</script>
+
+<script type="text/html" data-help-name="modbus-registers-config">
+    <p>Defines a shared in-memory Modbus register map that is referenced by
+    <code>modbus-registers-write</code> and <code>modbus-registers-respond</code> nodes.
+    All nodes sharing the same config instance read and write the same register arrays.</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>Holding Registers <span class="property-type">number</span></dt>
+        <dd>Number of holding registers (FC3/FC6/FC16) to allocate. Set to <code>0</code> to
+        disable this register type entirely — any client request targeting holding registers will
+        receive a Modbus exception&nbsp;2 (Illegal Data Address). Default: <code>100</code>.</dd>
+
+        <dt>Input Registers <span class="property-type">number</span></dt>
+        <dd>Number of input registers (FC4) to allocate. Set to <code>0</code> to disable.
+        Default: <code>100</code>.</dd>
+
+        <dt>Coil Registers <span class="property-type">number</span></dt>
+        <dd>Number of coil registers (FC1/FC5/FC15) to allocate. Set to <code>0</code> to disable.
+        Default: <code>100</code>.</dd>
+
+        <dt>Discrete Inputs <span class="property-type">number</span></dt>
+        <dd>Number of discrete input bits (FC2) to allocate. Set to <code>0</code> to disable.
+        Default: <code>100</code>.</dd>
+
+        <dt>32-bit Word Order <span class="property-type">select</span></dt>
+        <dd>Controls the byte and word ordering used when encoding or decoding 32-bit values
+        (<code>int32</code>, <code>uint32</code>, <code>float32</code>) across two consecutive
+        16-bit registers. Uses PLC-style byte-sequence notation where A is the most-significant byte:
+        <ul>
+            <li><b>ABCD</b> — Big-endian word, big-endian byte. Most significant word first, most
+            significant byte first within each word. Most common; matches network byte order.</li>
+            <li><b>CDAB</b> — Little-endian word, big-endian byte (word swap). Least significant
+            word first, bytes within each word remain big-endian.</li>
+            <li><b>BADC</b> — Big-endian word, little-endian byte. Most significant word first,
+            bytes within each word are swapped.</li>
+            <li><b>DCBA</b> — Little-endian word, little-endian byte (full swap). Both word order
+            and byte order are reversed.</li>
+        </ul>
+        Default: <b>ABCD</b>.</dd>
+    </dl>
+
+    <h3>Details</h3>
+    <p>A single config node represents one independent register space. Multiple
+    <code>modbus-registers-write</code> and <code>modbus-registers-respond</code> nodes linked to
+    the same config node share the same register data — writes from one node are immediately
+    visible to all others.</p>
+    <p>All register arrays are initialised to zero when Node-RED deploys the flow. Values persist
+    in memory for the lifetime of the runtime; they are not saved to disk.</p>
+    <p>The 32-bit word order setting applies globally to all write nodes that use this register map.
+    Ensure all writes and your Modbus client agree on the same ordering.</p>
+</script>
+
+<script type="text/javascript">
+  RED.nodes.registerType('modbus-registers-config', {
+	category: 'config',
+	defaults: {
+	  name: { value: '' },
+	  holdingRegisters: { value: 100, required: true, validate: RED.validators.number() },
+	  inputRegisters: { value: 100, required: true, validate: RED.validators.number() },
+	  coilRegisters: { value: 100, required: true, validate: RED.validators.number() },
+	  discreteRegisters: { value: 100, required: true, validate: RED.validators.number() },
+	  wordOrderMode: { value: 'ABCD', required: true }
+	},
+	label: function () {
+	  return this.name || 'Registers Map'
+	}
+  })
+</script>
+

package/src/modbus-registers-config.js

@@ -0,0 +1,216 @@
+module.exports = function (RED) {
+  function ModbusRegistersConfigNode (config) {
+	RED.nodes.createNode(this, config)
+	const node = this
+
+	node.name = config.name || ''
+	node.holdingRegisters = normalizeCount(config.holdingRegisters, 100)
+	node.inputRegisters = normalizeCount(config.inputRegisters, 100)
+	node.coilRegisters = normalizeCount(config.coilRegisters, 100)
+	node.discreteRegisters = normalizeCount(config.discreteRegisters, 100)
+	node.wordOrderMode = normalizeWordOrderMode(config.wordOrderMode)
+
+	node._maps = {
+	  holding: new Uint16Array(node.holdingRegisters),
+	  input: new Uint16Array(node.inputRegisters),
+	  coil: new Array(node.coilRegisters).fill(0),
+	  discrete: new Array(node.discreteRegisters).fill(0)
+	}
+
+	node.readWords = function (registerType, start, quantity) {
+	  const map = getWordMap(registerType, node._maps)
+	  if (!map || !isNonNegativeInteger(start) || !isPositiveInteger(quantity) || start + quantity > map.length) {
+		return null
+	  }
+	  return Array.from(map.slice(start, start + quantity))
+	}
+
+	node.readBits = function (registerType, start, quantity) {
+	  const map = getBitMap(registerType, node._maps)
+	  if (!map || !isNonNegativeInteger(start) || !isPositiveInteger(quantity) || start + quantity > map.length) {
+		return null
+	  }
+	  return map.slice(start, start + quantity).map(Boolean)
+	}
+
+	node.writeValue = function (registerType, address, format, value) {
+	  if (!isNonNegativeInteger(address)) {
+		return { ok: false, error: 'address must be a non-negative integer' }
+	  }
+
+	  if (registerType === 'coil' || registerType === 'discrete') {
+		const bitMap = getBitMap(registerType, node._maps)
+		if (!bitMap || address >= bitMap.length) {
+		  return { ok: false, error: 'address out of range' }
+		}
+
+		bitMap[address] = toBitValue(value)
+		return { ok: true, wordsWritten: 1 }
+	  }
+
+	  const map = getWordMap(registerType, node._maps)
+	  if (!map) {
+		return { ok: false, error: `unsupported registerType ${registerType}` }
+	  }
+
+	  const words = encodeValueAsWords(format, value, node.wordOrderMode)
+	  if (!words) {
+		return { ok: false, error: `unsupported format ${format}` }
+	  }
+	  if (address + words.length > map.length) {
+		return { ok: false, error: 'address out of range' }
+	  }
+
+	  words.forEach(function (word, idx) {
+		map[address + idx] = word
+	  })
+	  return { ok: true, wordsWritten: words.length }
+	}
+
+	node.writeWords = function (registerType, address, values) {
+	  const map = getWordMap(registerType, node._maps)
+	  if (!map || !isNonNegativeInteger(address) || !Array.isArray(values) || address + values.length > map.length) {
+		return { ok: false, error: 'invalid write range' }
+	  }
+
+	  values.forEach(function (value, idx) {
+		map[address + idx] = Number(value) & 0xffff
+	  })
+
+	  return { ok: true, wordsWritten: values.length }
+	}
+
+	node.writeBits = function (registerType, address, values) {
+	  const map = getBitMap(registerType, node._maps)
+	  if (!map || !isNonNegativeInteger(address) || !Array.isArray(values) || address + values.length > map.length) {
+		return { ok: false, error: 'invalid write range' }
+	  }
+
+	  values.forEach(function (value, idx) {
+		map[address + idx] = toBitValue(value)
+	  })
+
+	  return { ok: true, bitsWritten: values.length }
+	}
+  }
+
+  function normalizeCount (value, fallback) {
+	if (value === '' || value === null || value === undefined) {
+	  return fallback
+	}
+
+	const n = Number(value)
+	if (!Number.isFinite(n) || n < 0) {
+	  return fallback
+	}
+	return Math.floor(n)
+  }
+
+  function getWordMap (registerType, maps) {
+	if (registerType === 'holding') return maps.holding
+	if (registerType === 'input') return maps.input
+	return null
+  }
+
+  function getBitMap (registerType, maps) {
+	if (registerType === 'coil') return maps.coil
+	if (registerType === 'discrete') return maps.discrete
+	return null
+  }
+
+  function normalizeWordOrderMode (value) {
+	const mode = String(value || '').trim().toLowerCase()
+	if (mode === 'abcd' || mode === 'be-be') return 'ABCD'
+	if (mode === 'cdab' || mode === 'le-be') return 'CDAB'
+	if (mode === 'badc' || mode === 'be-le') return 'BADC'
+	if (mode === 'dcba' || mode === 'le-le') return 'DCBA'
+	return 'ABCD'
+  }
+
+  function isNonNegativeInteger (value) {
+	return Number.isInteger(value) && value >= 0
+  }
+
+  function isPositiveInteger (value) {
+	return Number.isInteger(value) && value > 0
+  }
+
+  function toBitValue (value) {
+	if (typeof value === 'string') {
+	  const normalized = value.trim().toLowerCase()
+	  if (normalized === 'true' || normalized === '1' || normalized === 'on') {
+		return 1
+	  }
+	  if (normalized === 'false' || normalized === '0' || normalized === 'off') {
+		return 0
+	  }
+	}
+
+	return value ? 1 : 0
+  }
+
+  function encodeValueAsWords (format, value, wordOrderMode) {
+	switch (format) {
+	  case 'int16':
+	  case 'uint16': {
+		const n = Number(value)
+		if (!Number.isFinite(n)) return null
+		return [n & 0xffff]
+	  }
+	  case 'uint32': {
+		const n = Number(value)
+		if (!Number.isFinite(n) || n < 0 || n > 0xffffffff) return null
+		const buf = Buffer.alloc(4)
+		buf.writeUInt32BE(Math.floor(n), 0)
+		return encode32BitBufferToWords(buf, wordOrderMode)
+	  }
+	  case 'int32': {
+		const n = Number(value)
+		if (!Number.isFinite(n) || n < -2147483648 || n > 2147483647) return null
+		const buf = Buffer.alloc(4)
+		buf.writeInt32BE(Math.floor(n), 0)
+		return encode32BitBufferToWords(buf, wordOrderMode)
+	  }
+	  case 'float32': {
+		const n = Number(value)
+		if (!Number.isFinite(n)) return null
+		const buf = Buffer.alloc(4)
+		buf.writeFloatBE(n, 0)
+		return encode32BitBufferToWords(buf, wordOrderMode)
+	  }
+	  // Backward-compatible aliases for older flows
+	  case 'float32be':
+		return encodeValueAsWords('float32', value, 'ABCD')
+	  case 'float32le': {
+		return encodeValueAsWords('float32', value, 'BADC')
+	  }
+	  default:
+		return null
+	}
+  }
+
+  function encode32BitBufferToWords (buf, mode) {
+	const normalizedMode = normalizeWordOrderMode(mode)
+	let firstWordBytes = [buf[0], buf[1]]
+	let secondWordBytes = [buf[2], buf[3]]
+
+	if (normalizedMode === 'BADC' || normalizedMode === 'DCBA') {
+	  firstWordBytes = [firstWordBytes[1], firstWordBytes[0]]
+	  secondWordBytes = [secondWordBytes[1], secondWordBytes[0]]
+	}
+
+	if (normalizedMode === 'CDAB' || normalizedMode === 'DCBA') {
+	  const tmp = firstWordBytes
+	  firstWordBytes = secondWordBytes
+	  secondWordBytes = tmp
+	}
+
+	return [
+	  (firstWordBytes[0] << 8) | firstWordBytes[1],
+	  (secondWordBytes[0] << 8) | secondWordBytes[1]
+	]
+  }
+
+  RED.nodes.registerType('modbus-registers-config', ModbusRegistersConfigNode)
+}
+