nodbus-plus 0.8.2 → 1.0.0

package/package.json

@@ -1,30 +1,39 @@
-{
-  "name": "nodbus-plus",
-  "version": "0.8.2",
-  "description": "A nodejs modbus library made in javascript",
-  "keywords": [
-    "node",
-    "modbus",
-    "library",
-    "client",
-    "master",
-    "slave",
-    "server"
-  ],
-  "main": "src/nodbus-plus.js",
-  "author": {
-    "name": "Héctor E. Socarrás Cabrera",
-    "email": "hsocarras1987@gmail.com"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/hsocarras/nodbus-plus"
-  },
-  "bugs": {
-    "url": "https://github.com/hsocarras/nodbus-plus/issues"
-  },
-  "engines": {
-    "node": ">= 6.0.0"
-  },
-  "license": "MIT"
-}
+{
+  "name": "nodbus-plus",
+  "version": "1.0.0",
+  "description": "A nodejs modbus library made in javascript",
+  "keywords": [
+    "node",
+    "modbus",
+    "library",
+    "client",
+    "master",
+    "slave",
+    "server"
+  ],
+  "main": "src/nodbus-plus.js",
+  "scripts": {
+    "test": "jest --detectOpenHandles"
+  },
+  "author": {
+    "name": "Héctor E. Socarrás Cabrera",
+    "email": "hsocarras1987@gmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hsocarras/nodbus-plus"
+  },
+  "bugs": {
+    "url": "https://github.com/hsocarras/nodbus-plus/issues"
+  },
+  "engines": {
+    "node": ">= 10.0.0"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "jest": "^29.4.3"
+  },
+  "dependencies": {
+    "serialport": "^11.0.0"
+  }
+}

package/samples/mb_serial_server.js

@@ -0,0 +1,77 @@
+const nodbus = require('../src/nodbus-plus');
+const arg = process.argv.slice(2);
+
+let cfg = {
+    address : 1,
+    transmitionMode: 0,
+    inputs : 2048,
+    coils : 2048,
+    holdingRegisters : 10000,
+    inputRegisters : 10000,  
+    port : 502,    
+    }
+
+if (arg.length > 0){
+    
+    let newAddress = Number(arg[0]);
+
+    if (typeof newAddress == 'number'){
+        cfg.address = newAddress;
+    }
+
+    if(arg[1] == '-ascii'){
+    
+        cfg.transmitionMode = 1;
+    
+    }        
+    
+    
+}
+
+let server = nodbus.createSerialServer('tcp', cfg);
+
+server.on('listening', function(port){
+    console.log('Server listening on: ' + port);        
+});
+
+if (arg.length > 0){
+    if(arg[2] == 'req'){
+        
+        server.on('request', function(sock, req){
+            console.log('Request received')
+            console.log(req)
+        });
+    }
+    else if(arg[2] == 'req-res'){
+
+        server.on('request', function(sock, req){
+            console.log('Request received')
+            console.log(req)
+        });
+
+        server.on('response', function(sock, res){
+            console.log('Responding')
+            console.log(res)
+        });
+
+    }
+    else if(arg[2] == 'raw'){
+        
+        server.on('data', function(sock, data){
+            console.log('Data received')
+            console.log(data)
+        });
+    }
+    else{
+        console.log('Blind Mode selected')
+    }
+
+}
+else{
+    server.on('error', function(err){
+        console.log(err)
+    });
+}
+
+
+server.start()

package/samples/mb_tcp_client.js

@@ -0,0 +1,114 @@
+const nodbus = require('../src/nodbus-plus');
+
+channelCfg = {
+    ip:'127.0.0.1',
+    port:502,
+    timeout:250,
+}
+
+let client = nodbus.createTcpClient();
+client.addChannel('device', 'tcp1', channelCfg);
+
+client.on('connection', (id)=>{
+    console.log('connection stablish')
+    process.stdout.write("device >> ")
+})
+
+client.on('connection-closed', (id)=>{
+    console.log('client disconnected')
+    process.stdout.write(">>> ")
+})
+
+client.on('error', (e)=>{
+    console.log('Error')
+    console.log(e)
+    process.stdout.write("device >> ")
+})
+
+client.on('request', (id, req)=>{
+    console.log('request sended to device');
+    console.log('Awaiting for response ...');
+})
+
+client.on('req-timeout', (id, adu)=>{
+    console.log('timeout')
+    process.stdout.write("device >> ")
+})
+
+client.on('response', (id, res)=>{
+    console.log(res)
+    process.stdout.write("device >> ")
+})
+
+function repl(){
+
+    process.stdout.write(">>> ")
+    const stdin = process.openStdin();
+
+    stdin.addListener("data", (data) => {
+        
+        let lineBuffer = data.subarray(0, data.length - 2);  //removing 0d 0a characters
+        let input = lineBuffer.toString();
+        
+
+        let comands = input.split(' ');
+        
+        let success;
+        let start;
+        let cuantity;
+
+        switch(comands[0]){            
+
+            case 'exit':                
+                process.exit();
+                break;
+            case 'q':                
+                process.exit();
+                break;
+            case 'connect':
+                client.connect('device')
+                break
+            case 'disconnect':
+                client.disconnect('device')
+                break
+            case 'readcoils':
+                start = comands[1];
+                cuantity = comands[2];
+                success = client.readCoils('device', 255, start, cuantity);
+                if(success == false){
+                    console.log('the client must connect first')
+                    process.stdout.write(">>> ")
+                }
+                break
+            case 'readholding':
+                start = comands[1];
+                cuantity = comands[2];
+                success = client.readHoldingRegisters('device', 255, start, cuantity);
+                if(success == false){
+                    console.log('the client must connect first')
+                    process.stdout.write(">>> ")
+                }
+                break
+            case 'preset':
+                let value = Buffer.alloc(2);
+                value.writeInt16BE(Number(comands[1]));
+                start= comands[2];
+                cuantity = comands[3];
+                success = client.presetSingleRegister(value, 'device', 255, start);
+                if(success == false){
+                    console.log('the client must connect first')
+                    process.stdout.write(">>> ")
+                }
+                break
+            default:
+                console.log('unknow comand')
+                process.stdout.write(">>> ")
+                
+        }
+        
+        
+
+    })
+}
+
+repl()

package/samples/mb_tcp_server.js

@@ -0,0 +1,58 @@
+const nodbus = require('../src/nodbus-plus');
+const arg = process.argv.slice(2);
+
+const cfg = {
+    inputs : 2048,
+    coils : 2048,
+    holdingRegisters : 10000,
+    inputRegisters : 10000,  
+    port : 502,    
+    }
+
+let server = nodbus.createTcpServer('tcp', cfg);
+
+server.on('listening', function(port){
+    console.log('Server listening on: ' + port);        
+});
+
+if (arg.length > 0){
+    if(arg[0] == 'req'){
+        
+        server.on('request', function(sock, req){
+            console.log('Request received')
+            console.log(req)
+        });
+    }
+    else if(arg[0] == 'req-res'){
+
+        server.on('request', function(sock, req){
+            console.log('Request received')
+            console.log(req)
+        });
+
+        server.on('response', function(sock, res){
+            console.log('Responding')
+            console.log(res)
+        });
+
+    }
+    else if(arg[0] == 'raw'){
+        
+        server.on('data', function(sock, data){
+            console.log('Data received')
+            console.log(data)
+        });
+    }
+    else{
+        console.log('Blind Mode selected')
+    }
+
+}
+else{
+    server.on('error', function(err){
+        console.log(err)
+    });
+}
+
+
+server.start()

package/src/client/net/serialchannel.js

@@ -0,0 +1,195 @@
+/**
+* Serial Channel  module.
+* @module net/serialchannel.
+* @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') 
+
+//No operation default function for listeners
+const noop = () => {};
+
+//default config
+//Default Server's Configuration object
+const defaultCfg = {
+    
+    speed : 7, //Enum startin at 0
+    dataBits : 8,    
+    stopBits : 1,
+    parity : 1,    
+    timeBetweenFrame : 20,
+}
+
+//BaudRates Map
+const allowedBaudRates = [110, 300, 1200, 2400, 4800, 9600, 14400, 19200, 38400, 57600, 115200];
+const allowedParity = ['none', 'even', 'odd'];
+
+/**
+ * Class representing a serial channel.
+*/
+class SerialChannel {
+  /**
+  * Create a serial channel.
+  */
+    constructor(channelCfg){
+
+        let self = this;
+
+        channelCfg.autoOpen = false;
+        channelCfg.path = channelCfg.port;
+        if(channelCfg.speed == undefined){ channelCfg.speed = defaultCfg.speed}
+        channelCfg.baudRate = allowedBaudRates[channelCfg.speed];
+        if(channelCfg.dataBits == undefined){ channelCfg.dataBits = defaultCfg.dataBits}
+        if(channelCfg.stopBits == undefined){ channelCfg.stopBits = defaultCfg.stopBits}
+        if(channelCfg.parity == undefined | channelCfg.parity < 0 | channelCfg.parity > 2){ channelCfg.parity = allowedParity[defaultCfg.parity]}
+        if(channelCfg.timeBetweenFrame == undefined){channelCfg.timeBetweenFrame = defaultCfg.timeBetweenFrame}
+        
+       
+
+        this.name = channelCfg.name;
+
+       
+        this.port = channelCfg.port;
+
+        
+
+        /**
+        *net.socket Object
+        * @type {object}
+        */
+        this.coreChannel = new SerialPort(netCfg);
+        this.parser = this.coreChannel.pipe(new InterByteTimeoutParser({ interval: netCfg.timeBetweenFrame }));
+
+        //Hooks functions *****************************************************************************************************************************
+
+        /**
+        *  function to executed when modbus message is detected
+        * @param {Buffer} data
+        */       
+        this.onMbAduHook = noop;
+        this.onDataHook = noop;
+        this.parser.on('data', (data)=>{
+
+            self.onDataHook(data);
+            
+            
+                    
+            if(self.validateFrame(data)){
+                self.onMbAduHook(data);
+            }
+                                           
+            
+        });
+        
+        this.onConnectHook = noop;
+        this.coreChannel.on('open', ()=>{  
+            self.onConnectHook();
+        })
+
+        this.onErrorHook = noop;
+        this.coreChannel.on('error', (e)=>{
+            this.onErrorHook(e);
+        })
+
+        /*
+        this.onEndHook = noop;
+        this.coreChannel.on('end', () =>{
+            
+        })
+
+        this.onTimeOutHook = noop;
+        */
+        this.onCloseHook =  noop;
+        this.coreChannel.on('close', (e) =>{
+            self.onCloseHook();
+        })
+        
+        this.onWriteHook = noop;
+
+        this.validateFrame = noop;
+
+    }
+
+    isConnected(){        
+        
+        return this.coreChannel.isOpen;
+        
+    }
+
+    /**
+    * Init a connection with a server 
+    * @returns {Promise} A promise that will be resolve once the connection is stablished with the socket as argument, or will 
+    * be rejected with ip and port as parameters.
+    */
+    connect(){
+        
+        let self = this;
+        let promise = new Promise(function(resolve, reject){
+
+            try{                
+               
+                self.coreChannel.open((err)=>{
+                    
+                    if(err){
+                        self.onErrorHook(e);                
+                        reject('serial', self.port);
+                    }
+                    else{
+                        resolve(self.coreChannel);
+                    }                                       
+                   
+                });
+                     
+                
+            }
+            catch(e){                
+                self.onErrorHook(e);                
+                reject('serial', self.port);
+            }
+        })
+
+        return promise;
+    }
+
+
+    disconnect(){
+        let self = this;
+       
+        this.coreChannel.close();
+
+        return Promise.resolve();
+               
+    }
+
+    /**
+    * Write data to a server 
+    * @param {Buffer} frame data to send to server.
+    * @returns {bool} True if success, otherwise false
+    * be rejected with ip and por as parameters.
+    */
+    write(frame){
+
+        let self = this;
+        if(self.isConnected() == false){
+            return false;
+        }
+        else{
+
+            this.coreChannel.write(frame, function(){
+              
+                self.onWriteHook(frame);               
+              
+            });            
+
+            return true;
+        }
+    }
+
+   
+
+}
+
+module.exports = SerialChannel;