nodbus-plus 0.8.2 → 1.0.0

package/src/protocol/utils.js

@@ -0,0 +1,296 @@
+/**
+* Calculate the crc from a modbus rtu's frame.
+* @param {Buffer} frame The complete modbus rtu frame.
+* @return {number} The CRC.
+*/
+function calcCRC(frame){
+  
+    var crc_hi = 0xFF;
+    var crc_lo = 0xFF;
+    var index;
+
+    var auxcrc_hi = [0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
+         0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
+         0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
+         0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
+         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,
+         0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
+         0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
+         0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
+         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
+         0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
+         0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
+         0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+         0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
+         0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
+         0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
+         0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
+                    0x40];
+
+    var auxcrc_lo = [0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,
+         0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
+         0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,
+         0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
+         0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,
+         0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
+         0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,
+         0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
+         0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,
+         0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
+         0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,
+         0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
+         0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,
+         0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
+         0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
+         0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
+         0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,
+                    0x40];
+
+    for(var i = 0; i< frame.length-2; i++) {
+        index = crc_hi ^ frame[i];
+        crc_hi = crc_lo ^ auxcrc_hi[index];
+        crc_lo = auxcrc_lo[index];
+    }
+    return (crc_hi << 8 | crc_lo);
+
+}
+
+/**
+* Calculate de LRC from a modbus ascii's frame.
+* @param {Buffer} frame The complete modbus ascii frame.
+* @return {number} The LRC.
+*/
+function calcLRC(frame){
+
+    var bufferBytes = Buffer.alloc(Math.floor((frame.length-5)/2));
+    var  byteLRC = Buffer.alloc(1);
+
+    for(var i = 0; i < bufferBytes.length; i++){
+        bufferBytes[i]=Number('0x'+ frame.toString('ascii',2*i+1 ,2*i+3));
+    }
+
+    for(var i = 0; i < bufferBytes.length;i++){
+        byteLRC[0] = byteLRC[0] + bufferBytes[i];
+    }
+
+    var lrc_temp = Buffer.alloc(1);
+    lrc_temp[0] = -byteLRC[0];
+    var lrc = lrc_temp.readUInt8(0)
+    return lrc;
+
+}
+
+/**
+*function to convert a uint8 in 2 chars lenght buffer
+*@param {number}  uint8Val;
+*@return {Buffer}
+*/
+function valByte2Chars (uint8Val){
+
+    let temp = Buffer.alloc(2);
+        
+    //get LSB part
+    temp.write((uint8Val & 0x0F).toString(16).toUpperCase(), 1);
+    //get msb
+    temp.write((uint8Val >> 4).toString(16).toUpperCase());
+    
+    return temp;
+}
+
+/**
+* This function calculate the necesary buffer to realize the desired mask function
+* @param {Array} valueArray Array of numbers, values 1 on position that want to be true, 0 on position that
+* want to be false and -1 in position that must be unchanged.
+* example register value:           [0 1 1 0   1 1 0 0    0 1 1 1   1 0 0 1] 0x9E36
+*         set register value:       [1 0 0 1  -1 0 1 -1  -1 -1 0 0  1 1 -1 0]
+*         final register value:     [1 0 0 1   1 0 1 0    0 1 0 0   1 1 0 0] 0x3259
+* @returns {Buffer} Buffer value with AND MASK and OR MASK for modbus 0x16 function.
+*/
+function getMaskRegisterBuffer(valueArray){
+
+    let value = Buffer.alloc(4);
+    let AND_Mask = 0;
+    let OR_Mask = 0xFFFF;
+    let tempMask = 1;
+    let iteratorLimit = 16;
+
+    if(valueArray.length < 16){
+        iteratorLimit = valueArray.length;
+    }
+    
+
+    for (let i = 0; i < iteratorLimit; i++){
+        
+        if(valueArray[i] == 1){
+        //AND_MASK = 0;
+        //OR_Mask = 1;              
+        }
+        else if(valueArray[i] == 0){ 
+            //AND_MASK = 0;  
+            //OR_MASK = 0     
+            OR_Mask = OR_Mask  & (~tempMask);   //temp mask negated is 1111 1110 for i = 0
+          
+        }
+        else{
+            //AND_MASK = 1;  
+            //OR_MASK = 1 
+            AND_Mask = AND_Mask | tempMask;                
+        }
+        
+        tempMask = tempMask << 1; 
+    }   
+
+    value.writeUInt16BE(AND_Mask);
+    value.writeUInt16BE(OR_Mask, 2);
+
+    return value;
+
+}
+
+/**
+ * Function to get a Buffer from an Array of boolean
+ * @param {Array} boolArray Boolena Array to encoded to a buffer
+ * @return {Buffer}
+ */
+function boolsToBuffer(boolArray){
+
+    let bufValue = Buffer.alloc(Math.ceil(boolArray.length/8)); //Example 10 bools arrays need two bytes length buffer
+    let index = 0;
+    let byteOffset = 0;
+    let orMask = 0x01;
+   
+
+    for(i = 0; i < boolArray.length; i++){
+        index = Math.floor((i)/8); //get the index in the buffer. example 0 for values between 0 -7;
+        byteOffset = i % 8;
+        orMask = 0x01;
+       
+
+        if(boolArray[i]){            
+            bufValue[index] = bufValue[index] | (orMask << byteOffset);            
+        }
+        
+    }
+
+    return bufValue;
+}
+
+
+/**
+ * Function to convert a asccii frame to rtu to be processed
+ * @param {Buffer} asciiFrame 
+ * @returns {Buffer} a equivalent rtu buffer
+ */
+function aduAsciiToRtu(asciiFrame){
+
+        
+    //creating rtu frame. content frame + 2 bytes for crc
+    let rtuFrame = Buffer.alloc((asciiFrame.length-1)/2);
+
+    //droping first character (:), lrc and ending character(CR, LF) see Mover over serial line 1.02 b
+    for(let i = 0; i < asciiFrame.length - 4; i++){
+        rtuFrame[i] = Number('0x'+ asciiFrame.toString('ascii', 2*i + 1 , 2*i + 3));
+    }
+    
+    let crc = calcCRC(rtuFrame);
+    rtuFrame.writeUInt16BE(crc,rtuFrame.length - 2);
+
+    return rtuFrame;
+
+}
+
+/**
+ * Function to convert a rtu frame to ascii to be responsed
+ * @param {Buffre} rtuFrame
+ * @returns {Buffer} a equivalent ascii buffer
+ */
+function aduRtuToAscii(rtuFrame){
+
+    //creating ascii frame. rtu frame * 2  + 1bytes for ':'
+    let asciiFrame = Buffer.alloc(rtuFrame.length * 2 + 1);
+    asciiFrame[0] = 0x3A;
+    asciiFrame[asciiFrame.length - 2] = 0x0D;
+    asciiFrame[asciiFrame.length - 1] = 0x0A;
+
+    //LRC calculation
+    let byteLRC = Buffer.alloc(1);
+
+    //chars value
+    let charsBuffer = Buffer.alloc(2);
+
+    for(let i = 0; i < rtuFrame.length - 2; i++){
+        byteLRC[0] = byteLRC[0] + rtuFrame[i];
+        charsBuffer = valByte2Chars(rtuFrame[i])
+        charsBuffer.copy(asciiFrame, 2*i + 1)
+    }
+
+    byteLRC[0] = -byteLRC[0]
+    //get lrc chars 
+    charsBuffer = valByte2Chars(byteLRC[0]);
+    charsBuffer.copy(asciiFrame, asciiFrame.length - 4);
+
+    return asciiFrame;
+}
+
+/**
+    * Low level api function to get a 2 bytes  word value from buffer.
+    * @param {Buffer} targetBuffer buffer object to read
+    * @param {number} offset integer value with bit address.
+    * @return {Buffer} 2 bytes length buffer
+    * @throws {RangeError} if offset is out of buffer's bound.
+    */
+function getWordFromBuffer(targetBuffer, offset = 0){
+
+    if(offset < targetBuffer.length / 2){
+      
+      let value = Buffer.alloc(2);
+      value[0] = targetBuffer[offset * 2];
+      value[1] = targetBuffer[offset*2 + 1];
+
+      return value;
+
+    }
+    else{
+      throw new RangeError("offset is out of buffer bounds");
+    }
+}
+
+/**
+* Low level api function to set a 2 bytes  word value into buffer.
+* @param {Buffer} value 2 bytes long buffer object to write
+* @param {Buffer} targetBuffer buffer object to write
+* @param {number} offset integer value with offset in the buffer.    
+* @throws {RangeError} if offset is out of buffer's bound.
+*/
+function setWordToBuffer(value, targetBuffer, offset = 0){
+
+  if(offset < targetBuffer.length / 2){        
+   
+      targetBuffer[offset * 2] = value[0];
+      targetBuffer[offset*2 + 1] = value[1];
+
+
+  }
+  else{
+    throw new RangeError("offset is out of buffer bounds");
+  }
+}
+
+module.exports.calcCRC = calcCRC;
+
+module.exports.calcLRC = calcLRC;
+
+module.exports.valByteToChars = valByte2Chars;
+
+module.exports.getMaskRegisterBuffer = getMaskRegisterBuffer;
+
+module.exports.boolsToBuffer = boolsToBuffer;
+
+module.exports.aduAsciiToRtu = aduAsciiToRtu;
+
+module.exports.aduRtuToAscii = aduRtuToAscii;
+
+module.exports.getWordFromBuffer = getWordFromBuffer;
+
+module.exports.setWordToBuffer = setWordToBuffer

package/src/server/net/serialserver.js

@@ -0,0 +1,184 @@
+/**
+**  Serial server module.
+* @module net/tcpserver.
+* @author Hector E. Socarras.
+* @version 1.0.0
+*/
+
+const { SerialPort } = require('serialport');
+const { InterByteTimeoutParser } = require('@serialport/parser-inter-byte-timeout')
+const { ReadlineParser } = require('@serialport/parser-readline')
+
+//Default Server's Configuration object
+const defaultCfg = {
+    
+    speed : 7, //Enum startin at 0
+    dataBits : 8,    
+    stopBits : 1,
+    parity : 1,    
+    timeBetweenFrame : 20,
+}
+
+//No operation default function for listeners
+const noop = () => {};
+
+//BaudRates Map
+const allowedBaudRates = [110, 300, 1200, 2400, 4800, 9600, 14400, 19200, 38400, 57600, 115200];
+const allowedParity = ['none', 'even', 'odd'];
+
+/**
+ * Class to wrap a serial port.
+ */
+class SerialServer {
+    /**
+    * Create a Serial Server.
+    * @param {object} netCfg configuration object.
+    */
+    constructor(netCfg = defaultCfg){
+
+        netCfg.autoOpen = false;
+        netCfg.path = netCfg.port;
+        if(netCfg.speed == undefined){ netCfg.speed = defaultCfg.speed}
+        netCfg.baudRate = allowedBaudRates[netCfg.speed];
+        if(netCfg.dataBits == undefined){ netCfg.dataBits = defaultCfg.dataBits}
+        if(netCfg.stopBits == undefined){ netCfg.stopBits = defaultCfg.stopBits}
+        if(netCfg.parity == undefined | netCfg.parity < 0 | netCfg.parity > 2){ netCfg.parity = allowedParity[defaultCfg.parity]}
+        if(netCfg.timeBetweenFrame == undefined){netCfg.timeBetweenFrame = defaultCfg.timeBetweenFrame}
+
+        let self = this;
+        
+        /**
+        * tcp server
+        * @type {Object}
+        */
+        this.coreServer = new SerialPort(netCfg);
+       
+        this.parser = this.coreServer.pipe(new InterByteTimeoutParser({ interval: netCfg.timeBetweenFrame }));
+               
+
+      
+        /**
+        * port
+        * @type {number}
+        */
+        this.port = netCfg.port;  
+                
+        
+
+        //API Callback interfaces****************************************************************************************************************************************
+
+         /**
+        *  function to executed when event data is emited
+        * @param {Buffer} data
+        */
+        this.onDataHook = noop;
+
+        /**
+        *  function to executed when modbus message is detected
+        * @param {Buffer} data
+        */
+        this.onMbAduHook = noop;
+
+        /**
+        *  function to executed when event listening is emited
+        */
+        this.onListeningHook = noop;
+        this.coreServer.on('open', () => {          
+            self.onListeningHook();          
+        });
+
+        
+        /**
+        *  function to executed when event error is emited
+        * @param {Object} error
+        */
+        this.onErrorHook = noop;
+        this.coreServer.on('error', (e) => {            
+            self.onErrorHook(e);            
+        });
+
+        /**
+        *  function to executed when event close is emited
+        */
+        this.onServerCloseHook = noop;
+        this.coreServer.on('close', function(){            
+             
+            self.onServerCloseHook();
+               
+        });
+
+
+        /**
+        *  function to executed when event write is emited
+        * @param {Buffer} buff
+        */
+        this.onWriteHook = noop;
+        //******************************************************************************************************************************************************
+
+        //function for validating data****************************************************************
+        this.validateFrame = ()=>{           
+            return false
+        }
+        
+        this.parser.on('data',function(data){
+            
+            if(self.onDataHook instanceof Function){
+                self.onDataHook(self, data);
+            }      
+
+                     
+            if(self.onMbAduHook  instanceof Function & self.validateFrame(data)){                
+                self.onMbAduHook(self, data);
+            }                 
+                    
+        });
+
+    }     
+
+    /**
+    * listening status
+    * @type {boolean}
+    */
+    get isListening(){
+        return this.coreServer.isOpen;
+    }
+
+      
+    /**
+    * Start the tcp server
+    */
+    start (){       
+        
+        this.coreServer.open(function (err) {
+            if (err) {
+                self.onErrorHook(e); 
+            }
+        })
+          
+    }
+
+    /**
+    * Stop the tcp server
+    */
+    stop (){
+        //cerrando el server 
+        this.coreServer.close(); 
+    }
+
+    /**
+    * function to write in a conection. Callback to onWriteHook hook function.
+    * @param {number} socketIndex. Index to socket in connections array
+    * @param {buffer} data
+    */
+    write (socket, frame){
+        let self = this;   
+        
+        this.coreServer.write(frame, function(){
+            self.onWriteHook(socket, frame);
+        });        
+    }
+    
+
+}
+
+module.exports = SerialServer;