node-red-modbus-dynamic-server 0.1.0

package/src/modbus-registers-respond.js

@@ -0,0 +1,286 @@
+const { respondWithPayload } = require('./modbus-response-context')
+
+module.exports = function (RED) {
+  const EXCEPTION_ILLEGAL_FUNCTION = 1
+  const EXCEPTION_ILLEGAL_DATA_ADDRESS = 2
+
+  function ModbusRegistersRespondNode (config) {
+	RED.nodes.createNode(this, config)
+	const node = this
+
+	node.name = config.name || ''
+	node.registerMap = RED.nodes.getNode(config.registerMap)
+
+	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 context = msg._modbus || {}
+	  const requestId = context.requestId
+	  const eventName = context.eventName
+	  const request = msg.payload || {}
+	  const body = request.body || {}
+
+	  if (!requestId || !eventName) {
+		node.error('Missing Modbus request context', msg)
+		node.status({ fill: 'red', shape: 'ring', text: 'missing context' })
+		done()
+		return
+	  }
+
+	  const responsePayload = buildResponsePayload(node.registerMap, eventName, request, body)
+	  const actualDataSent = deriveActualDataSent(eventName, request.quantity, responsePayload)
+
+	  const responseResult = respondWithPayload(RED, node, msg, responsePayload)
+	  if (!responseResult.context) {
+		node.status({ fill: 'red', shape: 'ring', text: 'missing context' })
+		done()
+		return
+	  }
+	  const ok = responseResult.ok
+	  if (!ok) {
+		node.status({ fill: 'red', shape: 'ring', text: 'unknown request' })
+		done(new Error(`modbus-registers-respond: request ${requestId} could not be responded to`))
+		return
+	  }
+
+	  msg.modbusResponse = {
+		requestId,
+		eventName,
+		address: request.address,
+		quantity: request.quantity,
+		payloadSubmitted: clonePayload(responsePayload),
+		payloadType: describePayload(responsePayload),
+		actualDataSent,
+		actualDataType: describePayload(actualDataSent),
+		ok,
+		timestamp: new Date().toISOString()
+	  }
+
+	  if (typeof eventName === 'string' && eventName.startsWith('write')) {
+		msg.modbusResponse.note = 'Write FC response is auto-built from request body by server config'
+	  }
+
+	  if (responsePayload && responsePayload.exception) {
+		node.status({ fill: 'yellow', shape: 'ring', text: `exception ${responsePayload.exception}` })
+	  } else {
+		node.status({ fill: 'green', shape: 'dot', text: eventName })
+	  }
+	  send(msg)
+	  done()
+	})
+  }
+
+  function buildResponsePayload (registerMap, eventName, request, body) {
+	const address = Number(request.address)
+	const quantity = Number(request.quantity)
+
+	switch (eventName) {
+	  case 'readHoldingRegisters':
+		return readWordsOrException(registerMap, 'holding', address, quantity)
+	  case 'readInputRegisters':
+		return readWordsOrException(registerMap, 'input', address, quantity)
+	  case 'readCoils':
+		return readBitsOrException(registerMap, 'coil', address, quantity)
+	  case 'readDiscreteInputs':
+		return readBitsOrException(registerMap, 'discrete', address, quantity)
+	  case 'writeSingleRegister':
+		return handleSingleWordWrite(registerMap, 'holding', body)
+	  case 'writeMultipleRegisters':
+		return handleMultipleWordWrite(registerMap, 'holding', body)
+	  case 'writeSingleCoil':
+		return handleSingleBitWrite(registerMap, 'coil', body)
+	  case 'writeMultipleCoils':
+		return handleMultipleBitWrite(registerMap, 'coil', body)
+	  default:
+		return { exception: EXCEPTION_ILLEGAL_FUNCTION }
+	}
+  }
+
+  function readWordsOrException (registerMap, registerType, address, quantity) {
+	const values = registerMap.readWords(registerType, address, quantity)
+	return values === null ? { exception: EXCEPTION_ILLEGAL_DATA_ADDRESS } : values
+  }
+
+  function readBitsOrException (registerMap, registerType, address, quantity) {
+	const values = registerMap.readBits(registerType, address, quantity)
+	return values === null ? { exception: EXCEPTION_ILLEGAL_DATA_ADDRESS } : values
+  }
+
+  function handleSingleWordWrite (registerMap, registerType, body) {
+	const address = Number(body.address)
+	const value = readSingleWordValue(body)
+	const result = registerMap.writeWords(registerType, address, [value])
+	return result.ok ? undefined : { exception: EXCEPTION_ILLEGAL_DATA_ADDRESS }
+  }
+
+  function handleMultipleWordWrite (registerMap, registerType, body) {
+	const address = Number(body.address)
+	const values = readWordValues(body)
+	const result = registerMap.writeWords(registerType, address, values)
+	return result.ok ? undefined : { exception: EXCEPTION_ILLEGAL_DATA_ADDRESS }
+  }
+
+  function handleSingleBitWrite (registerMap, registerType, body) {
+	const address = Number(body.address)
+	const value = readSingleBitValue(body)
+	const result = registerMap.writeBits(registerType, address, [value])
+	return result.ok ? undefined : { exception: EXCEPTION_ILLEGAL_DATA_ADDRESS }
+  }
+
+  function handleMultipleBitWrite (registerMap, registerType, body) {
+	const address = Number(body.address)
+	const values = readBitValues(body)
+	const result = registerMap.writeBits(registerType, address, values)
+	return result.ok ? undefined : { exception: EXCEPTION_ILLEGAL_DATA_ADDRESS }
+  }
+
+  function readSingleWordValue (body) {
+	if (body.value !== undefined) return Number(body.value) & 0xffff
+	if (body.values && body.values.length) return Number(body.values[0]) & 0xffff
+	return 0
+  }
+
+  function readWordValues (body) {
+	if (Array.isArray(body.values)) {
+	  return body.values.map(function (value) {
+		return Number(value) & 0xffff
+	  })
+	}
+
+	if (Buffer.isBuffer(body.valuesAsBuffer)) {
+	  const values = []
+	  for (let offset = 0; offset + 1 < body.valuesAsBuffer.length; offset += 2) {
+		values.push(body.valuesAsBuffer.readUInt16BE(offset))
+	  }
+	  return values
+	}
+
+	return []
+  }
+
+  function readSingleBitValue (body) {
+	if (body.value !== undefined) return body.value ? 1 : 0
+	if (body.values && body.values.length) return body.values[0] ? 1 : 0
+	return 0
+  }
+
+  function readBitValues (body) {
+	if (Array.isArray(body.values)) {
+	  return body.values.map(function (value) {
+		return value ? 1 : 0
+	  })
+	}
+
+	if (Buffer.isBuffer(body.valuesAsBuffer)) {
+	  const bits = []
+	  for (let i = 0; i < body.valuesAsBuffer.length; i++) {
+		const byte = body.valuesAsBuffer[i]
+		for (let b = 0; b < 8; b++) {
+		  bits.push((byte >> b) & 1)
+		}
+	  }
+	  return bits
+	}
+
+	return []
+  }
+
+  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)
+	}
+
+	return payload
+  }
+
+  function normalizeWordPayload (payload, count) {
+	if (Buffer.isBuffer(payload)) {
+	  const expectedBytes = count * 2
+	  const buf = Buffer.alloc(expectedBytes, 0)
+	  payload.copy(buf, 0, 0, Math.min(payload.length, expectedBytes))
+	  const words = []
+	  for (let i = 0; i < expectedBytes; i += 2) {
+		words.push(buf.readUInt16BE(i))
+	  }
+	  return words
+	}
+
+	if (Array.isArray(payload)) {
+	  const out = new Array(count).fill(0)
+	  payload.slice(0, count).forEach(function (v, i) {
+		out[i] = Number(v) & 0xffff
+	  })
+	  return out
+	}
+
+	if (payload && typeof payload === 'object' && Array.isArray(payload.values)) {
+	  return normalizeWordPayload(payload.values, count)
+	}
+
+	return new Array(count).fill(0)
+  }
+
+  function normalizeBitPayload (payload, count) {
+	if (Buffer.isBuffer(payload)) {
+	  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 < payload.length) {
+		  out[i] = (payload[byteIndex] >> bitIndex) & 1
+		}
+	  }
+	  return out
+	}
+
+	if (Array.isArray(payload)) {
+	  const out = new Array(count).fill(0)
+	  payload.slice(0, count).forEach(function (v, i) {
+		out[i] = v ? 1 : 0
+	  })
+	  return out
+	}
+
+	if (payload && typeof payload === 'object' && Array.isArray(payload.values)) {
+	  return normalizeBitPayload(payload.values, count)
+	}
+
+	return new Array(count).fill(0)
+  }
+
+  RED.nodes.registerType('modbus-registers-respond', ModbusRegistersRespondNode)
+}
+

package/src/modbus-registers-write.html

@@ -0,0 +1,157 @@
+<script type="text/html" data-template-name="modbus-registers-write">
+	<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>
+
+	<div class="form-row">
+		<label for="node-input-exceptionOnOutOfRangeValues"><i class="fa fa-exclamation-triangle"></i> Exception On Out Of Range Values</label>
+		<input type="checkbox" id="node-input-exceptionOnOutOfRangeValues" style="display:inline-block; width:auto;">
+	</div>
+</script>
+
+<script type="text/html" data-help-name="modbus-registers-write">
+    <p>Writes a value into a shared <code>modbus-registers-config</code> register map on each
+    input message. Supports 16-bit and 32-bit signed/unsigned integer and floating-point formats.
+    The message is forwarded unchanged (plus write metadata) after a successful write.</p>
+
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">number | string | boolean</span></dt>
+        <dd>The value to write. For integer formats the value is truncated to a whole number before
+        writing. For <code>coil</code> and <code>discrete</code> register types any truthy value
+        writes <code>1</code>, falsy writes <code>0</code>.</dd>
+
+        <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>
+
+        <dt class="optional">exceptionOnOutOfRangeValues <span class="property-type">boolean</span></dt>
+        <dd>Overrides the node's <em>Exception On Out Of Range Values</em> setting for this
+        message only.</dd>
+    </dl>
+
+    <h3>Outputs</h3>
+    <ol class="node-ports">
+        <li>Passthrough message
+            <dl class="message-properties">
+                <dt>modbusRegistersWrite <span class="property-type">object</span></dt>
+                <dd>Metadata added to the message after a successful write:
+                    <ul>
+                        <li><code>registerType</code> — register type written to.</li>
+                        <li><code>registerAddress</code> — address written to.</li>
+                        <li><code>registerFormat</code> — data format used.</li>
+                        <li><code>originalValue</code> — value received in <code>msg.payload</code>.</li>
+                        <li><code>writtenValue</code> — value actually stored (may differ if clamped).</li>
+                        <li><code>outOfRange</code> — <code>true</code> if the value exceeded the format's valid range.</li>
+                        <li><code>clamped</code> — <code>true</code> if the value was clamped rather than rejected.</li>
+                        <li><code>wordsWritten</code> — number of 16-bit registers written (1 for 16-bit formats, 2 for 32-bit).</li>
+                        <li><code>bitsWritten</code> — number of bits written (for coil/discrete writes).</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 this node writes to. Required.</dd>
+
+        <dt>Register Type <span class="property-type">select</span></dt>
+        <dd>The type of register to write:
+            <ul>
+                <li><code>holding</code> — FC6/FC16 holding registers (read/write).</li>
+                <li><code>input</code> — input registers (read-only by Modbus clients, but writable here for simulation).</li>
+                <li><code>coil</code> — FC5/FC15 single-bit coil registers.</li>
+                <li><code>discrete</code> — discrete input bits (read-only by clients, writable here for simulation).</li>
+            </ul>
+        </dd>
+
+        <dt>Register Address <span class="property-type">number</span></dt>
+        <dd>Zero-based register address to write to. For 32-bit formats, registers
+        <code>address</code> and <code>address+1</code> are both written.</dd>
+
+        <dt>Format <span class="property-type">select</span></dt>
+        <dd>Data format to use when encoding the value into 16-bit register words:
+            <ul>
+                <li><code>int16</code> — signed 16-bit integer (−32768 to 32767).</li>
+                <li><code>uint16</code> — unsigned 16-bit integer (0 to 65535).</li>
+                <li><code>int32</code> — signed 32-bit integer (−2147483648 to 2147483647), occupies 2 registers.</li>
+                <li><code>uint32</code> — unsigned 32-bit integer (0 to 4294967295), occupies 2 registers.</li>
+                <li><code>float32</code> — IEEE 754 single-precision float, occupies 2 registers.</li>
+            </ul>
+            32-bit word/byte ordering is controlled by the linked register map's <em>32-bit Word Order</em> setting.</dd>
+
+        <dt>Exception On Out Of Range Values <span class="property-type">boolean</span></dt>
+        <dd>Controls behaviour when a value falls outside the valid range for the selected format:
+            <ul>
+                <li><b>Checked (default)</b> — the write is aborted and an error is raised, catchable by a Catch node.</li>
+                <li><b>Unchecked</b> — the value is clamped to the nearest min/max boundary and written. <code>msg.modbusRegistersWrite.clamped</code> will be <code>true</code>.</li>
+            </ul>
+            Range checking applies to integer formats only. <code>float32</code> values are always passed through.
+        </dd>
+    </dl>
+</script>
+
+<script type="text/javascript">
+  RED.nodes.registerType('modbus-registers-write', {
+	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 },
+	  exceptionOnOutOfRangeValues: { value: true }
+	},
+	inputs: 1,
+	outputs: 1,
+	icon: 'file.svg',
+	label: function () {
+	  return this.name || 'Modbus Registers Write'
+	}
+  })
+</script>
+

package/src/modbus-registers-write.js

@@ -0,0 +1,156 @@
+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 ModbusRegistersWriteNode (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'
+    node.exceptionOnOutOfRangeValues = normalizeBooleanDefaultTrue(config.exceptionOnOutOfRangeValues)
+
+    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 = msg.registerType || node.registerType
+      const registerAddress = normalizeAddress(msg.registerAddress, node.registerAddress)
+      const registerFormat = msg.registerFormat || node.registerFormat
+      const exceptionOnOutOfRangeValues = normalizeBooleanDefaultTrue(
+        msg.exceptionOnOutOfRangeValues,
+        node.exceptionOnOutOfRangeValues
+      )
+
+      const valueResult = normalizeValueForFormat(registerFormat, msg.payload)
+      if (valueResult.outOfRange && exceptionOnOutOfRangeValues) {
+        node.status({ fill: 'red', shape: 'ring', text: 'value out of range' })
+        done(new Error(`modbus-registers-write: value ${valueResult.originalValue} out of range for ${registerFormat}`))
+        return
+      }
+
+      const value = valueResult.value
+
+      const result = node.registerMap.writeValue(registerType, registerAddress, registerFormat, value)
+      if (!result.ok) {
+        node.status({ fill: 'red', shape: 'ring', text: 'write failed' })
+        done(new Error(`modbus-registers-write: ${result.error}`))
+        return
+      }
+
+      msg.modbusRegistersWrite = {
+        registerType,
+        registerAddress,
+        registerFormat,
+        originalValue: valueResult.originalValue,
+        writtenValue: value,
+        outOfRange: valueResult.outOfRange,
+        clamped: valueResult.outOfRange && !exceptionOnOutOfRangeValues,
+        wordsWritten: result.wordsWritten || 0,
+        bitsWritten: result.bitsWritten || 0
+      }
+
+      const valueText = formatStatusValue(value)
+      node.status({ fill: 'green', shape: 'dot', text: `wrote ${valueText}` })
+
+      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 normalizeBooleanDefaultTrue (value, fallback) {
+    if (value === undefined || value === null || value === '') {
+      if (fallback === undefined) return true
+      return fallback
+    }
+
+    if (typeof value === 'boolean') {
+      return value
+    }
+
+    const normalized = String(value).trim().toLowerCase()
+    if (normalized === 'false' || normalized === '0' || normalized === 'off' || normalized === 'no') {
+      return false
+    }
+
+    return true
+  }
+
+  function normalizeValueForFormat (format, value) {
+    if (format === 'uint16') return normalizeIntegerRange(value, 0, 65535)
+    if (format === 'int16') return normalizeIntegerRange(value, -32768, 32767)
+    if (format === 'uint32') return normalizeIntegerRange(value, 0, 0xffffffff)
+    if (format === 'int32') return normalizeIntegerRange(value, -2147483648, 2147483647)
+
+    return {
+      value,
+      originalValue: value,
+      outOfRange: false
+    }
+  }
+
+  function normalizeIntegerRange (value, min, max) {
+    const originalValue = value
+    const parsed = Number(value)
+    if (!Number.isFinite(parsed)) {
+      return { value: min, originalValue, outOfRange: true }
+    }
+
+    const integerValue = Math.trunc(parsed)
+    if (integerValue < min) {
+      return { value: min, originalValue, outOfRange: true }
+    }
+    if (integerValue > max) {
+      return { value: max, originalValue, outOfRange: true }
+    }
+
+    return {
+      value: integerValue,
+      originalValue,
+      outOfRange: false
+    }
+  }
+
+  RED.nodes.registerType('modbus-registers-write', ModbusRegistersWriteNode)
+}
+

package/src/modbus-response-context.js

@@ -0,0 +1,52 @@
+'use strict'
+
+function resolveRequestContext (RED, node, msg) {
+  const context = msg && msg._modbus
+  if (!context || typeof context !== 'object') {
+    node.error('Missing Modbus request context', msg)
+    return null
+  }
+
+  const requestId = context.requestId
+  const configNodeId = context.configNodeId
+
+  if (!requestId || !configNodeId) {
+    node.error('Missing Modbus request context', msg)
+    return null
+  }
+
+  const serverNode = RED.nodes.getNode(configNodeId)
+  if (!serverNode || typeof serverNode.respondToRequest !== 'function') {
+    node.error('Invalid Modbus request context', msg)
+    return null
+  }
+
+  return {
+    requestId,
+    configNodeId,
+    eventName: context.eventName,
+    address: context.address,
+    quantity: context.quantity,
+    serverNode
+  }
+}
+
+function respondWithPayload (RED, node, msg, payload) {
+  const context = resolveRequestContext(RED, node, msg)
+  if (!context) {
+    return { ok: false, context: null }
+  }
+
+  const ok = context.serverNode.respondToRequest(context.requestId, payload)
+  if (!ok) {
+    node.warn(`respondToRequest returned false for requestId ${context.requestId}`)
+  }
+
+  return { ok, context }
+}
+
+module.exports = {
+  resolveRequestContext,
+  respondWithPayload
+}
+