nodbus-plus 0.8.2 → 1.0.0

package/src/protocol/modbus_master_serial.js

@@ -0,0 +1,247 @@
+/**
+** Modbus Serial Master Base Class module.
+* Only deal with basic ADU operations
+* @module protocol/modbus_master_tcp
+* @author Hector E. Socarras.
+* @version 1.0.0
+*/
+
+const valByte2Chars = require('./utils.js').valByteToChars;
+
+const ModbusClient = require('./modbus_master');
+
+/**
+ * Class representing a modbus master.
+ * @extends ModbusClient
+*/
+class ModbusSerialClient extends ModbusClient {
+    /**
+    * Create a Modbus Master.
+    */
+    constructor(){
+        super();  
+        
+        
+        /**
+         * Current pending request
+         * @type {Buffer}
+         */
+        this.activeRequest = null;
+
+        this._asciiRequest = false;
+
+        /**
+         * Variable that holds the timer's id for request timeout
+         */
+        this.activeRequestTimerId = -1;
+
+        /** 
+         * variable that holds the timer used when broadcast request is sended.
+        */
+        this.turnAroundDelay = -1;
+
+        
+
+    }  
+   
+    
+
+    /**
+     * Function to make a request buffer from pdu buffer and unit id.    
+     * @param {number} address Legacy modbus address
+     * @param {Buffer} pdu Buffer with modbus pdu
+     * @param {boolean} asciiMode. If true the request is made in ascii format.
+     * @returns {Buffer} buffer with request if succesfull or null.
+     */
+    makeRequest(address, pdu, asciiMode = false){
+
+        if(pdu instanceof Buffer & address >= 0 & address <= 247){
+
+            let reqBuffer = Buffer.alloc(3 + pdu.length);
+            reqBuffer[0] = address;
+            pdu.copy(reqBuffer, 1);
+
+            if (asciiMode){
+                let reqAsciiBuffer = this.aduRtuToAscii(reqBuffer);
+                return reqAsciiBuffer
+            }
+            else{
+                //calculating crc and appending to request                
+                let crc = this.calcCRC(reqBuffer);
+                reqBuffer.writeUInt16BE(crc, reqBuffer.length-2);
+                return reqBuffer;
+            }   
+                        
+        }
+        else{
+            return null;
+        }
+        
+    }
+
+    /**
+     * Function to store the request in activeRequest and set the ascii flag is the request is in ascii Format.     
+     * @param {Buffer} bufferReq
+     * @returns {boolean} true if is succesful stored, false otherwise
+     */
+    storeRequest(bufferReq, asciiMode = false){
+
+        let len = bufferReq.length;
+
+        //storing request on the pool
+        if(this.activeRequest == null){
+            if(asciiMode){
+                this._asciiRequest = true;
+            }
+            else{
+                this._asciiRequest = false;
+            }
+            this.activeRequest = bufferReq;
+            return true
+        }
+        else{
+            return false;
+        }
+
+    }
+   
+    /**
+     * Function to initialize a timer for timeout detection.
+     * @param {number} transactionId 
+     * @param {number} timeout 
+     * @return {number} timer id for cleartimeout function or -1 if no timer was set.
+     * @emits req-timeout. Timeout event
+     */
+    setReqTimer(timeout = 100){
+
+        let self = this;
+        
+        if(this.activeRequest instanceof Buffer & typeof timeout === 'number' & timeout >= 1){
+            
+            let timerId = setTimeout(()=>{
+                self.emit('req-timeout', self.activeRequest); //what to do when timeout occurs is desition for the user app
+            }, timeout);
+            
+            self.activeRequestTimerId = timerId;
+
+            return timerId
+        }
+        else{
+            return -1;
+        }
+        
+    }
+
+    /**
+     * Function to initialize a timer for timeout detection on broadcast request.
+     * @param {number} transactionId 
+     * @param {number} timeout 
+     * @return {number} timer id for cleartimeout function or -1 if no timer was set.
+     * @emits req-timeout. Timeout event
+     */
+    setTurnAroundDelay(timeout = 100){
+
+        let self = this;
+        
+        if(this.activeRequest instanceof Buffer & typeof timeout === 'number' & timeout >= 1){
+            
+            let timerId = setTimeout(()=>{
+                self.activeRequest = null;
+                self.emit('broadcast-timeout'); //what to do when timeout occurs is desition for the user app
+            }, timeout);
+            
+            self.turnAroundDelay = timerId;
+
+            return timerId
+        }
+        else{
+            return -1;
+        }
+    }
+
+    /**
+     * Funcion to clear the timeout imer for a given request
+     * @param {number} transactionId 
+     */
+    clearReqTimer(){
+
+       
+        clearTimeout(this.activeRequestTimerId);
+            
+    }
+
+    /**
+     * Function to make basic processing to response
+     * @param {buffer} bufferAdu adu buffer
+     * @emits transaction. Event emited when a response is received.
+     */
+    processResAdu(bufferAdu, ascii = false){
+        
+        //check that client is waiting for replay (this.activerequest is diferent than null)
+        if(bufferAdu instanceof Buffer & this.activeRequest instanceof Buffer){
+            if(ascii){
+                if(bufferAdu.length >= 9){
+                    //validating error check
+                    //Modbus Ascii Frame
+                    let calcErrorCheck = this.calcLRC(bufferAdu);
+                    let frameErrorCheck = Number('0x' + bufferAdu.toString('ascii', bufferAdu.length-4, bufferAdu.length-2));
+                   
+                    if(calcErrorCheck == frameErrorCheck){
+                        
+                        //valid frame
+                        let res = this.aduAsciiToRtu(bufferAdu);
+                        let req = this.aduAsciiToRtu(this.activeRequest);
+
+                        if(res[0] == req[0]){
+                            //if address match
+                            this.clearReqTimer();                            
+                            this.activeRequest = null;
+                            this._asciiRequest = false;
+                            this.emit('transaction', req, res);
+
+                        }
+                        
+                    }
+                    
+                }
+            }
+            else{
+                if(bufferAdu.length >= 4){
+                    //validating error check
+                    //Modbus Ascii Frame
+                    let calcErrorCheck = this.calcCRC(bufferAdu);
+                    let frameErrorCheck = bufferAdu.readUInt16BE(bufferAdu.length - 2);
+                    
+                    if(calcErrorCheck == frameErrorCheck){
+                        //valid frame
+                        let res = bufferAdu;
+                        if(res[0] == this.activeRequest[0]){
+                            //if address match
+                            this.clearReqTimer();
+                            
+                            let req = this.activeRequest;
+                            this.activeRequest = null;
+                            this.emit('transaction', req, res);
+
+                        }
+                        
+                    }
+                    
+                }
+            }
+        }
+        
+        
+    }
+    
+}
+
+ModbusSerialClient.prototype.aduAsciiToRtu = require('./utils.js').aduAsciiToRtu;
+
+ModbusSerialClient.prototype.aduRtuToAscii = require('./utils.js').aduRtuToAscii;
+
+ModbusSerialClient.prototype.calcCRC = require('./utils.js').calcCRC;
+
+ModbusSerialClient.prototype.calcLRC = require('./utils.js').calcLRC;
+
+module.exports = ModbusSerialClient;

package/src/protocol/modbus_master_tcp.js

@@ -0,0 +1,219 @@
+/**
+** Modbus TCP Master Base Class module.
+* Only deal with basic ADU operations
+* @module protocol/modbus_master_tcp
+* @author Hector E. Socarras.
+* @version 1.0.0
+*/
+
+
+const ModbusClient = require('./modbus_master');
+
+/**
+ * Class representing a modbus master.
+ * @extends EventEmitter
+*/
+class ModbusTcpClient extends ModbusClient {
+    /**
+    * Create a Modbus Master.
+    */
+    constructor(){
+        super();  
+        
+        /**
+        * transaction counter
+        * @type {number}
+        */
+        this._transactionCount = 0;    
+        
+        /**
+         * Max number of transaction
+         * @type {number}
+         */
+        this.maxNumberOfTransaction = 64;
+
+        /**
+         * Pool with pending request
+         * @type {map}
+         */
+        this.reqPool = new Map();
+
+        this.reqTimersPool = new Map();
+
+        
+
+    }  
+   
+    get transactionCount(){
+        return this._transactionCount;
+    }
+
+    set transactionCount(count){
+        if(typeof count === 'number'){
+            if(count >= 0 & count <= 0xFF){
+                this._transactionCount = count;
+            }
+        }
+    }
+
+    /**
+    * Function to make the modbus tcp header
+    * @param {number} unitId Legacy modbus address  
+    * @param {number} pduLength pdu's legth in bytes    
+    * @return {buffer} header buffer.
+    */
+    makeHeader(unitId, pduLength){
+
+        let header = Buffer.alloc(7);
+        header.writeUInt16BE(this.transactionCount);
+        header.writeUInt16BE(0,2);
+        header.writeUInt16BE(pduLength + 1, 4);
+        header.writeUInt8(unitId, 6);
+
+        return header;
+    }
+
+    /**
+    * Function to extract data from modbus tcp header. 
+    * @param {Buffer} bufferHeader buffer with modbus tcp header .    
+    * @return {object} object containing header's field {transactionID, protocolID, length, unitID}.
+    * @throws {TypeError} if bufferHeader is not a Buffer.
+    * @throws {RangeError} if bufferHeader's length is diferent than 7..
+    */
+    parseHeader(bufferHeader){
+
+        let header = {};
+        if(bufferHeader instanceof Buffer){
+            if(bufferHeader.length == 7){
+                header.transactionId = bufferHeader.readUInt16BE(0);
+                header.protocolId = bufferHeader.readUInt16BE(2);
+                header.length = bufferHeader.readUInt16BE(4);
+                header.unitId = bufferHeader.readUInt8(6);
+                return header;
+            }
+            else{
+                throw new RangeError('Error: Header must be 7 bytes long');
+            }
+        }
+        else{
+            throw new TypeError('Error: Header must be a buffer instance');
+        }
+    }
+
+    /**
+     * Function to make a request buffer from pdu buffer and unit id.    
+     * @param {number} unitId Legacy modbus address
+     * @param {Buffer} pdu Buffer with modbus pdu
+     * @returns {object} buffer with request if succesfull or null.
+     */
+    makeRequest(unitId, pdu){
+
+        if(pdu instanceof Buffer & unitId <= 255){
+
+            //Increment of transaction count
+            this.transactionCount++;
+
+            let header = this.makeHeader(unitId, pdu.length);
+
+            //allocating memory for request
+            let reqBuffer = Buffer.alloc(7 + pdu.length);
+
+            //filling request buffer with data
+            header.copy(reqBuffer);
+            pdu.copy(reqBuffer, 7);
+
+            return reqBuffer;
+                        
+        }
+        else{
+            return null;
+        }
+        
+    }
+
+    /**
+     * Function to store the request on the request pool.
+     * A modbus Tcp client can have more than one request sended to same server and other server.
+     * @param {Buffer} bufferReq
+     * @returns {boolean} true if is succesful stored on the pool, false otherwise
+     */
+    storeRequest(bufferReq){
+        //storing request on the pool
+        if(this.reqPool.size <= this.maxNumberOfTransaction){
+            let transactionId = bufferReq.readUInt16BE(0);
+            //using the transaction Id as key
+            this.reqPool.set(transactionId, bufferReq);
+
+            return true;
+        }
+        else{
+            return false;
+        }
+
+    }
+
+    /**
+     * Function to initialize a timer for timeout detection.
+     * @param {number} transactionId 
+     * @param {number} timeout 
+     * @return {number} timer id for cleartimeout function or -1 if no timer was set.
+     * @emits req-timeout. Timeout event
+     */
+    setReqTimer(transactionId, timeout = 100){
+
+        let self = this;
+        
+        //first, check thar the request exist on the request pool.
+        if(this.reqPool.has(transactionId) & typeof timeout === 'number' & timeout >= 1){
+
+            let req = self.reqPool.get(transactionId);
+            let timerId = setTimeout(()=>{
+                self.emit('req-timeout', transactionId, req); //what to do when timeout occurs is decision for the user app
+            }, timeout);
+            //storing timer on the timer's pool
+            self.reqTimersPool.set(transactionId, timerId)
+
+            return timerId
+        }
+        else{
+            return -1;
+        }
+    }
+
+    /**
+     * Funcion to clear the timeout imer for a given request
+     * @param {number} transactionId 
+     */
+    clearReqTimer(transactionId){
+
+        if(this.reqTimersPool.has(transactionId)){
+            let timerId = this.reqTimersPool.get(transactionId);
+            clearTimeout(timerId);
+            this.reqTimersPool.delete(transactionId);
+        }
+    }
+
+    /**
+     * Function to make basic processing to response
+     * @param {buffer} bufferAdu adu buffer
+     * @emits transaction. Event emited when a response is received.
+     */
+    processResAdu(bufferAdu){
+
+        let transactionId = bufferAdu.readUInt16BE(0); //getting the transaction id
+        
+        if(this.reqPool.has(transactionId)){
+            
+            //removing timer
+            this.clearReqTimer(transactionId);
+            //getting the original req
+            let req = this.reqPool.get(transactionId);
+            this.reqPool.delete(transactionId);  
+            this.emit('transaction', req, bufferAdu);          
+        }
+        
+    }
+    
+}
+
+module.exports = ModbusTcpClient;