node-red-contrib-modbus-tcp-full-avd 1.0.0

package/modbus-tcp.js

@@ -0,0 +1,1102 @@
+/**
+ * Node-RED MODBUS TCP Node
+ * Volledige ondersteuning voor MODBUS TCP communicatie
+ */
+
+module.exports = function(RED) {
+    "use strict";
+    const ModbusRTU = require("modbus-serial");
+    const net = require("net");
+    const EventEmitter = require("events");
+
+    /**
+     * MODBUS Protocol Handler
+     */
+    class ModbusProtocol {
+        constructor() {
+            this.transactionId = 0;
+        }
+
+        /**
+         * Genereer volgende transaction ID
+         */
+        getNextTransactionId() {
+            this.transactionId = (this.transactionId + 1) % 65536;
+            return this.transactionId;
+        }
+
+        /**
+         * Bouw MBAP header
+         */
+        buildMBAP(transactionId, unitId, pduLength) {
+            const buffer = Buffer.allocUnsafe(7);
+            buffer.writeUInt16BE(transactionId, 0);
+            buffer.writeUInt16BE(0, 2); // Protocol ID (0 = MODBUS)
+            buffer.writeUInt16BE(pduLength, 4);
+            buffer.writeUInt8(unitId, 6);
+            return buffer;
+        }
+
+        /**
+         * Parse MBAP header
+         */
+        parseMBAP(buffer) {
+            return {
+                transactionId: buffer.readUInt16BE(0),
+                protocolId: buffer.readUInt16BE(2),
+                length: buffer.readUInt16BE(4),
+                unitId: buffer.readUInt8(6)
+            };
+        }
+
+        /**
+         * Bouw PDU voor request
+         */
+        buildPDU(functionCode, address, quantity, values) {
+            let buffer;
+            
+            switch(functionCode) {
+                case 1: // Read Coils
+                case 2: // Read Discrete Inputs
+                case 3: // Read Holding Registers
+                case 4: // Read Input Registers
+                    buffer = Buffer.allocUnsafe(5);
+                    buffer.writeUInt8(functionCode, 0);
+                    buffer.writeUInt16BE(address, 1);
+                    buffer.writeUInt16BE(quantity, 3);
+                    break;
+                    
+                case 5: // Write Single Coil
+                    buffer = Buffer.allocUnsafe(5);
+                    buffer.writeUInt8(functionCode, 0);
+                    buffer.writeUInt16BE(address, 1);
+                    buffer.writeUInt16BE(values ? 0xFF00 : 0x0000, 3);
+                    break;
+                    
+                case 6: // Write Single Register
+                    buffer = Buffer.allocUnsafe(5);
+                    buffer.writeUInt8(functionCode, 0);
+                    buffer.writeUInt16BE(address, 1);
+                    buffer.writeUInt16BE(values, 3);
+                    break;
+                    
+                case 15: // Write Multiple Coils
+                    const coilBytes = Math.ceil(quantity / 8);
+                    buffer = Buffer.allocUnsafe(6 + coilBytes);
+                    buffer.writeUInt8(functionCode, 0);
+                    buffer.writeUInt16BE(address, 1);
+                    buffer.writeUInt16BE(quantity, 3);
+                    buffer.writeUInt8(coilBytes, 5);
+                    // Pack coils into bytes
+                    for (let i = 0; i < quantity; i++) {
+                        const byteIndex = 6 + Math.floor(i / 8);
+                        const bitIndex = i % 8;
+                        if (values[i]) {
+                            buffer[byteIndex] |= (1 << bitIndex);
+                        }
+                    }
+                    break;
+                    
+                case 16: // Write Multiple Registers
+                    buffer = Buffer.allocUnsafe(6 + (quantity * 2));
+                    buffer.writeUInt8(functionCode, 0);
+                    buffer.writeUInt16BE(address, 1);
+                    buffer.writeUInt16BE(quantity, 3);
+                    buffer.writeUInt8(quantity * 2, 5);
+                    for (let i = 0; i < quantity; i++) {
+                        buffer.writeUInt16BE(values[i], 6 + (i * 2));
+                    }
+                    break;
+                    
+                default:
+                    throw new Error(`Unsupported function code: ${functionCode}`);
+            }
+            
+            return buffer;
+        }
+
+        /**
+         * Parse PDU response
+         */
+        parsePDU(buffer) {
+            const functionCode = buffer[0];
+            
+            // Check for exception
+            if (functionCode & 0x80) {
+                return {
+                    exception: true,
+                    functionCode: functionCode & 0x7F,
+                    exceptionCode: buffer[1]
+                };
+            }
+            
+            let data = [];
+            
+            switch(functionCode) {
+                case 1: // Read Coils
+                case 2: // Read Discrete Inputs
+                    const byteCount = buffer[1];
+                    for (let i = 0; i < byteCount; i++) {
+                        const byte = buffer[2 + i];
+                        for (let j = 0; j < 8; j++) {
+                            data.push((byte & (1 << j)) !== 0);
+                        }
+                    }
+                    break;
+                    
+                case 3: // Read Holding Registers
+                case 4: // Read Input Registers
+                    const registerCount = buffer[1] / 2;
+                    for (let i = 0; i < registerCount; i++) {
+                        data.push(buffer.readUInt16BE(2 + (i * 2)));
+                    }
+                    break;
+                    
+                case 5: // Write Single Coil
+                case 6: // Write Single Register
+                    if (buffer.length < 5) {
+                        throw new Error(`Invalid response length for function ${functionCode}: expected 5 bytes, got ${buffer.length}`);
+                    }
+                    data = {
+                        address: buffer.readUInt16BE(1),
+                        value: functionCode === 5 ? 
+                            (buffer.readUInt16BE(3) === 0xFF00) : 
+                            buffer.readUInt16BE(3)
+                    };
+                    break;
+                    
+                case 15: // Write Multiple Coils
+                case 16: // Write Multiple Registers
+                    data = {
+                        address: buffer.readUInt16BE(1),
+                        quantity: buffer.readUInt16BE(3)
+                    };
+                    break;
+            }
+            
+            return {
+                exception: false,
+                functionCode: functionCode,
+                data: data
+            };
+        }
+    }
+
+    /**
+     * MODBUS TCP Client
+     */
+    class ModbusTCPClient {
+        constructor(config, node) {
+            this.config = config;
+            this.node = node;
+            this.protocol = new ModbusProtocol();
+            this.client = null;
+            this.connected = false;
+            this.pendingRequests = new Map();
+            this.reconnectTimer = null;
+            this.responseBuffer = Buffer.alloc(0);
+        }
+
+        connect() {
+            if (this.client && this.connected) {
+                return Promise.resolve();
+            }
+
+            return new Promise((resolve, reject) => {
+                this.client = new net.Socket();
+                
+                this.client.on('connect', () => {
+                    this.connected = true;
+                    this.node.status({ fill: "green", shape: "dot", text: "connected" });
+                    this.node.log("MODBUS TCP Client connected");
+                    resolve();
+                });
+
+                this.client.on('data', (data) => {
+                    this.handleResponse(data);
+                });
+
+                this.client.on('error', (err) => {
+                    this.node.error(`MODBUS TCP Client error: ${err.message}`);
+                    this.node.status({ fill: "red", shape: "ring", text: "error" });
+                    this.connected = false;
+                });
+
+                this.client.on('close', () => {
+                    this.connected = false;
+                    this.node.status({ fill: "yellow", shape: "ring", text: "disconnected" });
+                    this.node.log("MODBUS TCP Client disconnected");
+                    this.scheduleReconnect();
+                });
+
+                this.client.setTimeout(this.config.connectionTimeout);
+                this.client.connect(this.config.port, this.config.host);
+            });
+        }
+
+        scheduleReconnect() {
+            if (this.reconnectTimer) {
+                clearTimeout(this.reconnectTimer);
+            }
+            this.reconnectTimer = setTimeout(() => {
+                this.node.log("Attempting to reconnect...");
+                this.connect().catch(err => {
+                    this.node.error(`Reconnect failed: ${err.message}`);
+                });
+            }, this.config.reconnectInterval);
+        }
+
+        handleResponse(data) {
+            // Append new data to buffer
+            this.responseBuffer = Buffer.concat([this.responseBuffer, data]);
+
+            // Process complete responses from buffer
+            while (this.responseBuffer.length >= 7) {
+                const mbap = this.protocol.parseMBAP(this.responseBuffer);
+                // MBAP length includes PDU length + 1 (unitId byte)
+                const expectedLength = 7 + mbap.length - 1;
+                
+                if (this.responseBuffer.length < expectedLength) {
+                    // Wait for more data
+                    return;
+                }
+
+                const pdu = this.responseBuffer.slice(7, expectedLength);
+                const response = this.protocol.parsePDU(pdu);
+
+                const requestId = mbap.transactionId;
+                const pendingRequest = this.pendingRequests.get(requestId);
+
+                if (pendingRequest) {
+                    clearTimeout(pendingRequest.timeout);
+                    this.pendingRequests.delete(requestId);
+
+                    if (response.exception) {
+                        pendingRequest.reject(new Error(`MODBUS Exception ${response.exceptionCode}`));
+                    } else {
+                        pendingRequest.resolve(response);
+                    }
+                }
+
+                // Remove processed response from buffer
+                this.responseBuffer = this.responseBuffer.slice(expectedLength);
+            }
+        }
+
+        async sendRequest(functionCode, address, quantity, values, unitId) {
+            if (!this.connected) {
+                await this.connect();
+            }
+
+            const transactionId = this.protocol.getNextTransactionId();
+            const pdu = this.protocol.buildPDU(functionCode, address, quantity, values);
+            const mbap = this.protocol.buildMBAP(transactionId, unitId || this.config.unitId, pdu.length + 1);
+            const request = Buffer.concat([mbap, pdu]);
+
+            return new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    this.pendingRequests.delete(transactionId);
+                    reject(new Error("Request timeout"));
+                }, this.config.requestTimeout);
+
+                this.pendingRequests.set(transactionId, {
+                    resolve: (response) => {
+                        clearTimeout(timeout);
+                        resolve(response);
+                    },
+                    reject: (error) => {
+                        clearTimeout(timeout);
+                        reject(error);
+                    },
+                    timeout: timeout
+                });
+
+                this.client.write(request);
+            });
+        }
+
+        async requestWithRetry(functionCode, address, quantity, values, unitId) {
+            let lastError;
+            for (let i = 0; i <= this.config.retryCount; i++) {
+                try {
+                    return await this.sendRequest(functionCode, address, quantity, values, unitId);
+                } catch (err) {
+                    lastError = err;
+                    if (i < this.config.retryCount) {
+                        await new Promise(resolve => setTimeout(resolve, this.config.retryInterval));
+                    }
+                }
+            }
+            throw lastError;
+        }
+
+        disconnect() {
+            if (this.reconnectTimer) {
+                clearTimeout(this.reconnectTimer);
+            }
+            if (this.client) {
+                this.client.destroy();
+                this.client = null;
+            }
+            this.connected = false;
+            this.responseBuffer = Buffer.alloc(0);
+        }
+    }
+
+    /**
+     * MODBUS TCP Server
+     */
+    class ModbusTCPServer {
+        constructor(config, node) {
+            this.config = config;
+            this.node = node;
+            this.protocol = new ModbusProtocol();
+            this.server = null;
+            this.clients = new Map();
+            this.dataModel = {
+                coils: new Array(65536).fill(false),
+                discreteInputs: new Array(65536).fill(false),
+                holdingRegisters: new Array(65536).fill(0),
+                inputRegisters: new Array(65536).fill(0)
+            };
+        }
+
+        start() {
+            this.server = net.createServer((socket) => {
+                const clientId = `${socket.remoteAddress}:${socket.remotePort}`;
+                this.node.log(`New client connected: ${clientId}`);
+
+                if (this.clients.size >= this.config.maxConnections) {
+                    this.node.warn(`Max connections reached, rejecting ${clientId}`);
+                    socket.destroy();
+                    return;
+                }
+
+                this.clients.set(clientId, socket);
+                this.node.status({ fill: "green", shape: "dot", text: `${this.clients.size} clients` });
+
+                let buffer = Buffer.alloc(0);
+
+                socket.on('data', (data) => {
+                    buffer = Buffer.concat([buffer, data]);
+                    this.processRequest(socket, buffer, clientId);
+                });
+
+                socket.on('error', (err) => {
+                    this.node.error(`Client ${clientId} error: ${err.message}`);
+                });
+
+                socket.on('close', () => {
+                    this.clients.delete(clientId);
+                    this.node.log(`Client disconnected: ${clientId}`);
+                    this.node.status({ fill: "green", shape: "dot", text: `${this.clients.size} clients` });
+                });
+            });
+
+            this.server.listen(this.config.port, () => {
+                this.node.log(`MODBUS TCP Server listening on port ${this.config.port}`);
+                this.node.status({ fill: "green", shape: "dot", text: `listening on ${this.config.port}` });
+            });
+
+            this.server.on('error', (err) => {
+                this.node.error(`MODBUS TCP Server error: ${err.message}`);
+                this.node.status({ fill: "red", shape: "ring", text: "error" });
+            });
+        }
+
+        processRequest(socket, buffer, clientId) {
+            while (buffer.length >= 7) {
+                const mbap = this.protocol.parseMBAP(buffer);
+                const expectedLength = 7 + mbap.length - 1; // -1 because unitId is included in length
+
+                if (buffer.length < expectedLength) {
+                    return; // Wait for more data
+                }
+
+                const pdu = buffer.slice(7, expectedLength);
+                buffer = buffer.slice(expectedLength);
+
+                try {
+                    const response = this.handleModbusRequest(pdu, mbap.unitId);
+                    const responseMBAP = this.protocol.buildMBAP(mbap.transactionId, mbap.unitId, response.length + 1);
+                    socket.write(Buffer.concat([responseMBAP, response]));
+                } catch (err) {
+                    this.node.error(`Error processing request: ${err.message}`);
+                }
+            }
+        }
+
+        handleModbusRequest(pdu, unitId) {
+            if (unitId !== this.config.unitId && unitId !== 0) {
+                return this.buildExceptionResponse(pdu[0], 0x0A); // Gateway Target Device Failed
+            }
+
+            const functionCode = pdu[0];
+            let response;
+
+            try {
+                switch(functionCode) {
+                    case 1: // Read Coils
+                        response = this.readCoils(pdu);
+                        break;
+                    case 2: // Read Discrete Inputs
+                        response = this.readDiscreteInputs(pdu);
+                        break;
+                    case 3: // Read Holding Registers
+                        response = this.readHoldingRegisters(pdu);
+                        break;
+                    case 4: // Read Input Registers
+                        response = this.readInputRegisters(pdu);
+                        break;
+                    case 5: // Write Single Coil
+                        response = this.writeSingleCoil(pdu);
+                        break;
+                    case 6: // Write Single Register
+                        response = this.writeSingleRegister(pdu);
+                        break;
+                    case 15: // Write Multiple Coils
+                        response = this.writeMultipleCoils(pdu);
+                        break;
+                    case 16: // Write Multiple Registers
+                        response = this.writeMultipleRegisters(pdu);
+                        break;
+                    default:
+                        return this.buildExceptionResponse(functionCode, 0x01); // Illegal Function
+                }
+            } catch (err) {
+                if (err.code === 'ILLEGAL_ADDRESS') {
+                    return this.buildExceptionResponse(functionCode, 0x02); // Illegal Data Address
+                } else if (err.code === 'ILLEGAL_VALUE') {
+                    return this.buildExceptionResponse(functionCode, 0x03); // Illegal Data Value
+                } else {
+                    return this.buildExceptionResponse(functionCode, 0x04); // Server Device Failure
+                }
+            }
+
+            return response;
+        }
+
+        readCoils(pdu) {
+            const address = pdu.readUInt16BE(1);
+            const quantity = pdu.readUInt16BE(3);
+
+            if (address + quantity > 65536) {
+                throw new Error('ILLEGAL_ADDRESS');
+            }
+
+            const byteCount = Math.ceil(quantity / 8);
+            const response = Buffer.allocUnsafe(2 + byteCount);
+            response.writeUInt8(1, 0);
+            response.writeUInt8(byteCount, 1);
+
+            for (let i = 0; i < quantity; i++) {
+                const byteIndex = 2 + Math.floor(i / 8);
+                const bitIndex = i % 8;
+                if (this.dataModel.coils[address + i]) {
+                    response[byteIndex] |= (1 << bitIndex);
+                }
+            }
+
+            return response;
+        }
+
+        readDiscreteInputs(pdu) {
+            const address = pdu.readUInt16BE(1);
+            const quantity = pdu.readUInt16BE(3);
+
+            if (address + quantity > 65536) {
+                throw new Error('ILLEGAL_ADDRESS');
+            }
+
+            const byteCount = Math.ceil(quantity / 8);
+            const response = Buffer.allocUnsafe(2 + byteCount);
+            response.writeUInt8(2, 0);
+            response.writeUInt8(byteCount, 1);
+
+            for (let i = 0; i < quantity; i++) {
+                const byteIndex = 2 + Math.floor(i / 8);
+                const bitIndex = i % 8;
+                if (this.dataModel.discreteInputs[address + i]) {
+                    response[byteIndex] |= (1 << bitIndex);
+                }
+            }
+
+            return response;
+        }
+
+        readHoldingRegisters(pdu) {
+            const address = pdu.readUInt16BE(1);
+            const quantity = pdu.readUInt16BE(3);
+
+            if (address + quantity > 65536) {
+                throw new Error('ILLEGAL_ADDRESS');
+            }
+
+            const response = Buffer.allocUnsafe(2 + (quantity * 2));
+            response.writeUInt8(3, 0);
+            response.writeUInt8(quantity * 2, 1);
+
+            for (let i = 0; i < quantity; i++) {
+                response.writeUInt16BE(this.dataModel.holdingRegisters[address + i], 2 + (i * 2));
+            }
+
+            return response;
+        }
+
+        readInputRegisters(pdu) {
+            const address = pdu.readUInt16BE(1);
+            const quantity = pdu.readUInt16BE(3);
+
+            if (address + quantity > 65536) {
+                throw new Error('ILLEGAL_ADDRESS');
+            }
+
+            const response = Buffer.allocUnsafe(2 + (quantity * 2));
+            response.writeUInt8(4, 0);
+            response.writeUInt8(quantity * 2, 1);
+
+            for (let i = 0; i < quantity; i++) {
+                response.writeUInt16BE(this.dataModel.inputRegisters[address + i], 2 + (i * 2));
+            }
+
+            return response;
+        }
+
+        writeSingleCoil(pdu) {
+            const address = pdu.readUInt16BE(1);
+            const value = pdu.readUInt16BE(3);
+
+            if (address > 65535) {
+                throw new Error('ILLEGAL_ADDRESS');
+            }
+
+            if (value !== 0x0000 && value !== 0xFF00) {
+                throw new Error('ILLEGAL_VALUE');
+            }
+
+            this.dataModel.coils[address] = (value === 0xFF00);
+
+            // Echo response
+            return Buffer.from(pdu);
+        }
+
+        writeSingleRegister(pdu) {
+            const address = pdu.readUInt16BE(1);
+            const value = pdu.readUInt16BE(3);
+
+            if (address > 65535) {
+                throw new Error('ILLEGAL_ADDRESS');
+            }
+
+            this.dataModel.holdingRegisters[address] = value;
+
+            // Echo response
+            return Buffer.from(pdu);
+        }
+
+        writeMultipleCoils(pdu) {
+            const address = pdu.readUInt16BE(1);
+            const quantity = pdu.readUInt16BE(3);
+            const byteCount = pdu[5];
+
+            if (address + quantity > 65536) {
+                throw new Error('ILLEGAL_ADDRESS');
+            }
+
+            for (let i = 0; i < quantity; i++) {
+                const byteIndex = 6 + Math.floor(i / 8);
+                const bitIndex = i % 8;
+                this.dataModel.coils[address + i] = (pdu[byteIndex] & (1 << bitIndex)) !== 0;
+            }
+
+            // Echo response
+            const response = Buffer.allocUnsafe(5);
+            response.writeUInt8(15, 0);
+            response.writeUInt16BE(address, 1);
+            response.writeUInt16BE(quantity, 3);
+            return response;
+        }
+
+        writeMultipleRegisters(pdu) {
+            const address = pdu.readUInt16BE(1);
+            const quantity = pdu.readUInt16BE(3);
+
+            if (address + quantity > 65536) {
+                throw new Error('ILLEGAL_ADDRESS');
+            }
+
+            for (let i = 0; i < quantity; i++) {
+                this.dataModel.holdingRegisters[address + i] = pdu.readUInt16BE(6 + (i * 2));
+            }
+
+            // Echo response
+            const response = Buffer.allocUnsafe(5);
+            response.writeUInt8(16, 0);
+            response.writeUInt16BE(address, 1);
+            response.writeUInt16BE(quantity, 3);
+            return response;
+        }
+
+        buildExceptionResponse(functionCode, exceptionCode) {
+            const response = Buffer.allocUnsafe(2);
+            response.writeUInt8(functionCode | 0x80, 0);
+            response.writeUInt8(exceptionCode, 1);
+            return response;
+        }
+
+        updateData(type, address, value, values) {
+            if (values && Array.isArray(values)) {
+                for (let i = 0; i < values.length; i++) {
+                    this.updateData(type, address + i, values[i]);
+                }
+            } else {
+                switch(type) {
+                    case 'coils':
+                        this.dataModel.coils[address] = value;
+                        break;
+                    case 'discreteInputs':
+                        this.dataModel.discreteInputs[address] = value;
+                        break;
+                    case 'holdingRegisters':
+                        this.dataModel.holdingRegisters[address] = value;
+                        break;
+                    case 'inputRegisters':
+                        this.dataModel.inputRegisters[address] = value;
+                        break;
+                }
+            }
+        }
+
+        generateTestData(pattern, startAddress, quantity, dataType) {
+            startAddress = startAddress || 0;
+            quantity = quantity || 100;
+            dataType = dataType || 'holdingRegisters';
+            pattern = pattern || 'incrementing';
+
+            const dataArray = this.dataModel[dataType];
+            if (!dataArray) {
+                throw new Error(`Invalid data type: ${dataType}`);
+            }
+
+            let values = [];
+            
+            switch(pattern) {
+                case 'incrementing':
+                    for (let i = 0; i < quantity; i++) {
+                        values.push((startAddress + i) % 65536);
+                    }
+                    break;
+                    
+                case 'random':
+                    for (let i = 0; i < quantity; i++) {
+                        values.push(Math.floor(Math.random() * 65536));
+                    }
+                    break;
+                    
+                case 'sine':
+                    for (let i = 0; i < quantity; i++) {
+                        const sineValue = Math.sin((i / quantity) * Math.PI * 2);
+                        values.push(Math.floor((sineValue + 1) * 32767.5));
+                    }
+                    break;
+                    
+                case 'square':
+                    for (let i = 0; i < quantity; i++) {
+                        values.push((i % 2 === 0) ? 0 : 65535);
+                    }
+                    break;
+                    
+                case 'alternating':
+                    for (let i = 0; i < quantity; i++) {
+                        values.push(i % 2 === 0 ? 0 : 1);
+                    }
+                    break;
+                    
+                default:
+                    // Default to incrementing
+                    for (let i = 0; i < quantity; i++) {
+                        values.push((startAddress + i) % 65536);
+                    }
+            }
+
+            // Update the data model
+            if (dataType === 'coils' || dataType === 'discreteInputs') {
+                for (let i = 0; i < quantity; i++) {
+                    dataArray[startAddress + i] = values[i] !== 0;
+                }
+            } else {
+                for (let i = 0; i < quantity; i++) {
+                    dataArray[startAddress + i] = values[i];
+                }
+            }
+
+            this.node.log(`Generated ${quantity} test data values for ${dataType} starting at address ${startAddress} with pattern ${pattern}`);
+            
+            return {
+                pattern: pattern,
+                dataType: dataType,
+                startAddress: startAddress,
+                quantity: quantity,
+                values: values.slice(0, 10) // Return first 10 as sample
+            };
+        }
+
+        stop() {
+            if (this.server) {
+                this.server.close();
+                this.server = null;
+            }
+            this.clients.forEach((socket) => socket.destroy());
+            this.clients.clear();
+        }
+    }
+
+    /**
+     * Helper function to get data summary
+     */
+    function getDataSummary(dataArray, type) {
+        const nonZeroIndices = [];
+        const sampleData = {};
+        
+        // Find first 10 non-zero/non-false values
+        for (let i = 0; i < Math.min(dataArray.length, 100); i++) {
+            const value = dataArray[i];
+            if ((type === "coils" || type === "discreteInputs") ? value : value !== 0) {
+                nonZeroIndices.push(i);
+                if (nonZeroIndices.length <= 10) {
+                    sampleData[i] = value;
+                }
+            }
+        }
+        
+        return {
+            type: type,
+            totalRegisters: dataArray.length,
+            nonZeroCount: nonZeroIndices.length,
+            sampleData: sampleData,
+            firstNonZeroIndex: nonZeroIndices[0] !== undefined ? nonZeroIndices[0] : null,
+            lastNonZeroIndex: nonZeroIndices.length > 0 ? nonZeroIndices[nonZeroIndices.length - 1] : null
+        };
+    }
+
+    /**
+     * Helper function to create data map with addresses
+     */
+    function createDataMap(dataArray, startAddress) {
+        const map = {};
+        if (Array.isArray(dataArray)) {
+            dataArray.forEach((value, index) => {
+                map[startAddress + index] = value;
+            });
+        }
+        return map;
+    }
+
+    /**
+     * Node-RED Node Definition
+     */
+    function ModbusTCPNode(config) {
+        RED.nodes.createNode(this, config);
+
+        this.config = {
+            tcpMode: config.tcpMode || "client",
+            host: config.host || "127.0.0.1",
+            port: config.port || 502,
+            reconnectInterval: config.reconnectInterval || 5000,
+            connectionTimeout: config.connectionTimeout || 10000,
+            maxConnections: config.maxConnections || 10,
+            modbusMode: config.modbusMode || "client",
+            unitId: config.unitId || 1,
+            byteOrder: config.byteOrder || "bigEndian",
+            addressOffset: config.addressOffset || 0,
+            requestTimeout: config.requestTimeout || 5000,
+            retryCount: config.retryCount || 3,
+            retryInterval: config.retryInterval || 1000,
+            showData: config.showData || false,
+            debugMode: config.debugMode || false,
+            generateTestData: config.generateTestData || false,
+            testDataPattern: config.testDataPattern || "incrementing"
+        };
+
+        this.client = null;
+        this.server = null;
+
+        // Initialize based on mode
+        if (this.config.tcpMode === "client" && this.config.modbusMode === "client") {
+            this.client = new ModbusTCPClient(this.config, this);
+            this.client.connect().catch(err => {
+                this.error(`Failed to connect: ${err.message}`);
+            });
+        } else if (this.config.tcpMode === "server" && this.config.modbusMode === "server") {
+            this.server = new ModbusTCPServer(this.config, this);
+            this.server.start();
+            
+            // Generate test data if enabled
+            if (this.config.generateTestData) {
+                setTimeout(() => {
+                    this.server.generateTestData(
+                        this.config.testDataPattern,
+                        0,
+                        100,
+                        'holdingRegisters'
+                    );
+                    this.server.generateTestData(
+                        this.config.testDataPattern,
+                        0,
+                        100,
+                        'inputRegisters'
+                    );
+                    this.log("Test data generated automatically");
+                }, 1000);
+            }
+        } else {
+            this.error(`Unsupported mode combination: TCP ${this.config.tcpMode} + MODBUS ${this.config.modbusMode}`);
+            this.status({ fill: "red", shape: "ring", text: "invalid mode" });
+            return;
+        }
+
+        // Handle incoming messages
+        this.on('input', async (msg) => {
+            try {
+                // Check for special actions
+                const action = msg.action || msg.payload?.action;
+                
+                // Client mode: read and show data
+                if (action === "readData" && this.config.modbusMode === "client" && this.client) {
+                    const readType = msg.readType || msg.payload?.readType || "holdingRegisters";
+                    const startAddress = (msg.address !== undefined ? msg.address : msg.payload?.address || 0) + this.config.addressOffset;
+                    const quantity = msg.quantity || msg.payload?.quantity || 10;
+                    
+                    let functionCode;
+                    switch(readType) {
+                        case "coils":
+                            functionCode = 1;
+                            break;
+                        case "discreteInputs":
+                            functionCode = 2;
+                            break;
+                        case "holdingRegisters":
+                            functionCode = 3;
+                            break;
+                        case "inputRegisters":
+                            functionCode = 4;
+                            break;
+                        default:
+                            functionCode = 3;
+                    }
+                    
+                    try {
+                        const response = await this.client.requestWithRetry(
+                            functionCode,
+                            startAddress,
+                            quantity,
+                            null,
+                            msg.unitId || msg.payload?.unitId
+                        );
+                        
+                        msg.payload = {
+                            action: "readData",
+                            type: readType,
+                            address: startAddress,
+                            quantity: quantity,
+                            data: response.data,
+                            dataMap: createDataMap(response.data, startAddress),
+                            timestamp: new Date()
+                        };
+                        
+                        if (this.config.debugMode) {
+                            this.log(`Read Data - Type: ${readType}, Address: ${startAddress}, Data: ${JSON.stringify(response.data)}`);
+                        }
+                        
+                        if (this.config.showData) {
+                            const dataPreview = Array.isArray(response.data) 
+                                ? response.data.slice(0, 5).join(", ") + (response.data.length > 5 ? "..." : "")
+                                : JSON.stringify(response.data);
+                            this.status({ 
+                                fill: "green", 
+                                shape: "dot", 
+                                text: `${readType}[${startAddress}]: ${dataPreview}` 
+                            });
+                        }
+                        
+                        this.send(msg);
+                        return;
+                    } catch (err) {
+                        msg.error = {
+                            message: err.message,
+                            type: readType,
+                            address: startAddress
+                        };
+                        this.error(`Failed to read data: ${err.message}`);
+                        this.send(msg);
+                        return;
+                    }
+                }
+                
+                // Server mode: generate test data
+                if (action === "generateTestData" && this.config.modbusMode === "server" && this.server) {
+                    const pattern = msg.pattern || msg.payload?.pattern || this.config.testDataPattern;
+                    const startAddress = (msg.address !== undefined ? msg.address : msg.payload?.address || 0) + this.config.addressOffset;
+                    const quantity = msg.quantity || msg.payload?.quantity || 100;
+                    const dataType = msg.dataType || msg.payload?.dataType || "holdingRegisters";
+                    
+                    try {
+                        const result = this.server.generateTestData(pattern, startAddress, quantity, dataType);
+                        
+                        msg.payload = {
+                            action: "generateTestData",
+                            result: result,
+                            timestamp: new Date()
+                        };
+                        
+                        if (this.config.debugMode) {
+                            this.log(`Test data generated - Pattern: ${pattern}, Type: ${dataType}, Address: ${startAddress}, Quantity: ${quantity}`);
+                        }
+                        
+                        this.status({ 
+                            fill: "green", 
+                            shape: "dot", 
+                            text: `Test data: ${dataType}[${startAddress}-${startAddress + quantity - 1}]` 
+                        });
+                        
+                        this.send(msg);
+                        return;
+                    } catch (err) {
+                        msg.error = {
+                            message: err.message,
+                            pattern: pattern,
+                            dataType: dataType
+                        };
+                        this.error(`Failed to generate test data: ${err.message}`);
+                        this.send(msg);
+                        return;
+                    }
+                }
+                
+                // Server mode: show all register data
+                if (action === "showData" && this.config.modbusMode === "server" && this.server) {
+                    const dataSummary = {
+                        coils: getDataSummary(this.server.dataModel.coils, "coils"),
+                        discreteInputs: getDataSummary(this.server.dataModel.discreteInputs, "discreteInputs"),
+                        holdingRegisters: getDataSummary(this.server.dataModel.holdingRegisters, "holdingRegisters"),
+                        inputRegisters: getDataSummary(this.server.dataModel.inputRegisters, "inputRegisters")
+                    };
+                    
+                    msg.payload = {
+                        action: "showData",
+                        summary: dataSummary,
+                        timestamp: new Date()
+                    };
+                    
+                    if (this.config.debugMode) {
+                        this.log(JSON.stringify(dataSummary, null, 2));
+                    }
+                    
+                    this.send(msg);
+                    return;
+                }
+                
+                if (this.config.modbusMode === "client" && this.client) {
+                    // Client mode: send request
+                    const functionCode = msg.function || msg.payload?.function;
+                    const address = (msg.address !== undefined ? msg.address : msg.payload?.address) + this.config.addressOffset;
+                    const quantity = msg.quantity || msg.payload?.quantity;
+                    const values = msg.values || msg.payload?.values || msg.value || msg.payload?.value;
+                    const unitId = msg.unitId || msg.payload?.unitId;
+
+                    if (!functionCode || address === undefined) {
+                        this.error("Missing required fields: function and address");
+                        return;
+                    }
+
+                    const response = await this.client.requestWithRetry(
+                        functionCode,
+                        address,
+                        quantity,
+                        values,
+                        unitId
+                    );
+
+                    msg.payload = {
+                        function: functionCode,
+                        address: address,
+                        quantity: quantity,
+                        data: response.data,
+                        timestamp: new Date(),
+                        responseTime: Date.now() - (msg.timestamp || Date.now())
+                    };
+
+                    // Show data in status if enabled
+                    if (this.config.showData && response.data) {
+                        const dataPreview = Array.isArray(response.data) 
+                            ? response.data.slice(0, 5).join(", ") + (response.data.length > 5 ? "..." : "")
+                            : JSON.stringify(response.data);
+                        this.status({ 
+                            fill: "green", 
+                            shape: "dot", 
+                            text: `Addr ${address}: ${dataPreview}` 
+                        });
+                    }
+
+                    // Debug mode: log data
+                    if (this.config.debugMode) {
+                        this.log(`MODBUS Response - Function: ${functionCode}, Address: ${address}, Data: ${JSON.stringify(response.data)}`);
+                    }
+
+                    this.send(msg);
+                } else if (this.config.modbusMode === "server" && this.server) {
+                    // Server mode: update data
+                    const type = msg.type || msg.payload?.type;
+                    const address = (msg.address !== undefined ? msg.address : msg.payload?.address) + this.config.addressOffset;
+                    const value = msg.value !== undefined ? msg.value : msg.payload?.value;
+                    const values = msg.values || msg.payload?.values;
+
+                    if (type && address !== undefined) {
+                        this.server.updateData(type, address, value, values);
+                        
+                        // Show data in status if enabled
+                        if (this.config.showData) {
+                            const displayValue = values ? 
+                                `${values.slice(0, 3).join(",")}${values.length > 3 ? "..." : ""}` : 
+                                value;
+                            this.status({ 
+                                fill: "green", 
+                                shape: "dot", 
+                                text: `${type}[${address}]: ${displayValue}` 
+                            });
+                        } else {
+                            this.status({ fill: "green", shape: "dot", text: "data updated" });
+                        }
+                        
+                        // Debug mode: log data update
+                        if (this.config.debugMode) {
+                            this.log(`MODBUS Server Data Update - Type: ${type}, Address: ${address}, Value: ${JSON.stringify(values || value)}`);
+                        }
+                    }
+                }
+            } catch (err) {
+                msg.error = {
+                    code: err.message.includes("Exception") ? parseInt(err.message.match(/\d+/)?.[0] || 0) : 0,
+                    message: err.message,
+                    function: msg.function || msg.payload?.function,
+                    address: msg.address || msg.payload?.address
+                };
+                msg.payload = null;
+                this.error(err.message);
+                this.send(msg);
+            }
+        });
+
+        // Cleanup on close
+        this.on('close', () => {
+            if (this.client) {
+                this.client.disconnect();
+            }
+            if (this.server) {
+                this.server.stop();
+            }
+        });
+    }
+
+    RED.nodes.registerType("modbus-tcp-avd", ModbusTCPNode);
+};