nodbus-plus 0.8.2 → 1.0.0

package/test/nodbus_server_serial.test.js

@@ -0,0 +1,255 @@
+const net = require('node:net');
+const Nodbus = require('../src/nodbus-plus');
+
+//creating config file for basic server 1
+let serverCfg1 = {
+    inputs : 524,
+    coils : 0,
+    holdingRegisters : 512,
+    inputRegisters : 256,    
+    udpType : 'udp6', 
+    port: 503,
+    speed: 7,
+    address : 1,
+    transmitionMode : 0,
+}
+
+let serverCfg2 = {
+    inputs : 524,
+    coils : 0,
+    holdingRegisters : 512,
+    inputRegisters : 256,    
+    udpType : 'udp6', 
+    port: 504,    
+    address : 1,
+    transmitionMode : 1,
+    tcpCoalescingDetection : true,  
+    
+}
+
+describe("Instanciate a nodbus serial server with tcp net", () => {
+
+       
+    let server1 = Nodbus.createSerialServer('tcp', serverCfg1);
+    //let server2 = new ModbusTcpServer();
+    
+    it("instance", () => {
+         
+        expect(server1.port).toEqual(503);    
+        expect(server1.address).toEqual(1);  
+        expect(server1.net.tcpCoalescingDetection).toEqual(false);     
+    } );   
+    
+});
+
+describe("rtu server", () => {
+
+       
+    let server1 = Nodbus.createSerialServer('tcp', serverCfg1);
+    let testClient = new net.Socket()  
+
+    test("server", (done) => {
+
+        expect(server1.isListening).toEqual(false); 
+       
+        testClient.on('data', (data)=>{
+            //console.log('client data')
+            expect(data[0]).toEqual(1);
+            expect(data[1]).toEqual(3);
+            server1.stop() 
+        })
+
+        function listeningCallback(port){  
+            //console.log('listening')     
+            expect(server1.isListening).toEqual(true);     
+            expect(port).toEqual(503);  
+
+            testClient.connect(503);  
+
+            function connectionCallback(){
+                //console.log('connection') 
+                   
+                let adu1 = Buffer.from([0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x45, 0xD8]);  //broadcast
+                let adu2 = Buffer.from([0x0A, 0x03, 0x00, 0x00, 0x00, 0x04, 0x45, 0x72]);   //address 10 wrong address
+                let adu3 = Buffer.from([0x01, 0x03, 0x00, 0x00, 0x00, 0x04, 0x44, 0x09]);   //good
+                let adu4 = Buffer.from([0x01, 0x03, 0x00, 0x00, 0x00, 0x04, 0x44, 0x19]);   //wrong crc  
+
+                 
+                function dataCallback(socket, frame){
+                    //console.log('data')
+                    //console.log(frame)
+                    expect(frame[0] == 0 | frame[0] == 1 | frame[0] == 10).toBeTruthy(); 
+                    expect(frame[1]).toEqual(3);
+                                     
+                }
+
+                server1.on('data', dataCallback);
+
+                function reqCallback(socket, req){
+                    expect(socket).toBeInstanceOf(net.Socket)
+                    //console.log('req')
+                    expect(req.address == 0 | req.address == 1).toBeTruthy(); 
+                    expect(req.functionCode).toEqual(3);
+                    expect(req.data.length).toEqual(4);                    
+                }
+
+                server1.on('request', reqCallback);
+
+                function resCallback(sock, res){
+                    //console.log('res')
+                    expect(res.address).toEqual(1);
+                    expect(res.functionCode).toEqual(3);
+                    expect(res.data.length).toEqual(9);   
+                }
+
+                server1.on('response', resCallback);
+
+                function writeCallback(socket, frame){
+                    expect(socket).toBeInstanceOf(net.Socket)
+                    expect(frame[0]).toEqual(0);
+                    expect(frame[1]).toEqual(3);
+                }
+                
+                //server1.on('write', writeCallback);
+
+                testClient.write(adu1)  
+
+                setTimeout(() => {
+                    testClient.write(adu2)
+                }, 100) 
+
+                setTimeout(() => {
+                    testClient.write(adu4)
+                }, 200) 
+                    
+                setTimeout(() => {
+                    testClient.write(adu3) 
+                }, 300)   
+                  
+                
+            }
+
+            testClient.on('connect', connectionCallback)
+        }
+
+        server1.on('listening', listeningCallback);
+
+        function closedCallback(){
+            //console.log('closed') 
+            expect(server1.isListening).toEqual(false);
+            done()
+        }
+        server1.on('closed', closedCallback)
+
+        server1.start()  
+
+    });    
+    
+    
+});
+
+describe("ascii server", () => {
+
+       
+    let server1 = Nodbus.createSerialServer('tcp', serverCfg2);
+    let testClient = new net.Socket()  
+
+    test("server", (done) => {
+
+        expect(server1.isListening).toEqual(false); 
+       
+        testClient.on('data', (data)=>{
+            //console.log('client data')
+            expect(data[0]).toEqual(0x3A);
+            
+            server1.stop() 
+        })
+
+        function listeningCallback(port){  
+            //console.log('listening')     
+            expect(server1.isListening).toEqual(true);     
+            expect(port).toEqual(504);  
+
+            testClient.connect(504);  
+
+            function connectionCallback(){
+                //console.log('connection') 
+                   
+                let adu1 = Buffer.from([0x3A, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x46, 0x39, 0x0D, 0x0A]);  //broadcast 0 3 0 0 0 4 45 d8
+                let adu2 = Buffer.from([0x3A, 0x30, 0x41, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x45, 0x36, 0x0D, 0x0A]);   //address 10 wrong address
+                let adu3 = Buffer.from([0x3A, 0x30, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x46, 0x38, 0x0D, 0x0A]);   //good
+                let adu4 = Buffer.from([0x3A, 0x30, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x46, 0x36, 0x0D, 0x0A]);   //wrong crc  
+
+                 
+                function dataCallback(socket, frame){
+                    //console.log('data')
+                    //console.log(frame)
+                    expect(frame[0]).toEqual(0x3A);
+                    expect(frame[1]).toEqual(0x30);
+                                     
+                }
+
+                server1.on('data', dataCallback);
+
+                function reqCallback(socket, req){
+                    expect(socket).toBeInstanceOf(net.Socket)
+                    //console.log('req')
+                    expect(req.address == 0 | req.address == 1).toBeTruthy(); 
+                    expect(req.functionCode).toEqual(3);
+                    expect(req.data.length).toEqual(4);                    
+                }
+
+                server1.on('request', reqCallback);
+
+                function resCallback(sock, res){
+                    //console.log('res')
+                    expect(res.address).toEqual(1);
+                    expect(res.functionCode).toEqual(3);
+                    expect(res.data.length).toEqual(9);   
+                }
+
+                server1.on('response', resCallback);
+
+                function writeCallback(socket, frame){
+                    expect(socket).toBeInstanceOf(net.Socket)
+                    expect(frame[0]).toEqual(0);
+                    expect(frame[1]).toEqual(3);
+                }
+                
+                //server1.on('write', writeCallback);
+
+                testClient.write(adu1)  
+
+                setTimeout(() => {
+                    testClient.write(adu2)
+                }, 100) 
+
+                setTimeout(() => {
+                    testClient.write(adu4)
+                }, 200) 
+                    
+                setTimeout(() => {
+                    testClient.write(adu3) 
+                }, 300)   
+                  
+                
+            }
+
+            testClient.on('connect', connectionCallback)
+        }
+
+        server1.on('listening', listeningCallback);
+
+        function closedCallback(){
+            //console.log('closed') 
+            expect(server1.isListening).toEqual(false);
+            done()
+        }
+        server1.on('closed', closedCallback)
+
+        server1.start()  
+
+    });    
+    
+    
+});

package/test/nodbus_server_tcp.test.js

@@ -0,0 +1,216 @@
+const net = require('node:net');
+const dgram = require('node:dgram');
+const Nodbus = require('../src/nodbus-plus');
+
+//creating config file for basic server 1
+let serverCfg = {
+    inputs : 524,
+    coils : 0,
+    holdingRegisters : 512,
+    inputRegisters : 256,
+    tcpCoalescingDetection : false,   
+    udpType : 'udp6', 
+}
+
+describe("Instanciate a nodbus tcp server with tcp net", () => {
+
+       
+    let server1 = Nodbus.createTcpServer('tcp', serverCfg);
+    //let server2 = new ModbusTcpServer();
+    
+    it("instanciate transaction", () => {
+         
+        expect(server1.port).toEqual(502);    
+        expect(server1.maxConnections).toEqual(32);
+             
+    } );   
+    
+});
+
+describe("tcp server", () => {
+
+       
+    let server1 = Nodbus.createTcpServer();
+    //let server2 = Nodbus.CreateTcpServer('tcp', serverCfg);
+    let testClient = new net.Socket()  
+
+    test("callbacks", (done) => {
+        expect(server1.isListening).toEqual(false); 
+                
+       
+        testClient.on('data', (data)=>{
+            server1.stop() 
+        })
+
+        function listeningCallback(port){  
+            //console.log('listening')     
+            expect(server1.isListening).toEqual(true);     
+            expect(port).toEqual(502);
+            testClient.connect(502);           
+            
+
+            function connectionCallback(socket){
+                //console.log('connection') 
+                expect(socket.localPort).toEqual(502); 
+                let adu1 = Buffer.from([0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x03, 
+                    0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x03]);      
+                
+
+                              
+
+                function dataCallback(socket, frame){
+                    expect(socket).toBeInstanceOf(net.Socket)
+                    expect(frame.length).toEqual(24);
+                    expect(frame[2]).toEqual(0);
+                    expect(frame[6]).toEqual(255);
+                    expect(frame[9]).toEqual(0);
+                    expect(frame[15]).toEqual(0);
+                    expect(frame[21]).toEqual(0);  
+                                     
+                }
+
+                server1.on('data', dataCallback);
+
+                function reqCallback(socket, req){
+                    expect(socket).toBeInstanceOf(net.Socket)
+                    expect(req.unitId).toEqual(255);
+                    expect(req.functionCode).toEqual(1);
+                    expect(req.data.length).toEqual(4);                    
+                }
+
+                server1.on('request', reqCallback);
+
+                function resCallback(sock, res){
+                    expect(res.unitId).toEqual(255);
+                    expect(res.functionCode).toEqual(1);
+                    expect(res.data.length).toEqual(2);   
+                }
+
+                server1.on('response', resCallback);
+
+                function writeCallback(socket, frame){
+                    expect(socket).toBeInstanceOf(net.Socket)
+                    expect(frame[2]).toEqual(0);
+                    expect(frame[6]).toEqual(255);
+                }
+                
+                testClient.write(adu1)    
+                
+            }
+
+            server1.on('connection', connectionCallback)
+        }
+
+        server1.on('listening', listeningCallback);
+
+        function closedCallback(){
+            //console.log('closed') 
+            expect(server1.isListening).toEqual(false);
+            done()
+        }
+        server1.on('closed', closedCallback)
+
+        server1.start()  
+
+    });    
+    
+    
+});
+
+describe("udp server", () => {
+
+       
+    let server2 = Nodbus.createTcpServer('udp6', serverCfg);
+    server2.port = 1502;
+    
+    let testClient2 = dgram.createSocket('udp6');
+    
+    
+    
+    testClient2.once('message', (data, rinfo)=>{
+        //console.log('stopping server udp')
+        testClient2.disconnect()
+        server2.stop();        
+        testClient2.close();
+    })
+    
+   
+    test("callbacks", (done) => {
+
+        expect(server2.isListening).toEqual(false); 
+        
+
+        function listeningCallback(port){  
+            
+            const address = server2.net.coreServer.address();
+            //console.log(`server listening ${address.address}:${address.port} for ${address.family}`);    
+            expect(server2.isListening).toEqual(true);     
+            expect(port).toEqual(1502);
+            expect(address.family).toEqual('IPv6')
+
+            testClient2.connect(1502, 'localhost', connectionCallback);  
+           
+            function connectionCallback(){
+                //console.log('connection') 
+                     
+                let adu1 = Buffer.from([0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x03, 
+                                        0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x03]);  
+
+                let conectedClients = server2.net.activeConnections;                 
+                expect(conectedClients.length).toEqual(0);                     
+
+                function dataCallback(socket, frame){
+                    //console.log('data')
+                    
+                    expect(frame.length).toEqual(24);
+                    expect(frame[2]).toEqual(0);
+                    expect(frame[6]).toEqual(255);
+                    expect(frame[9]).toEqual(0);
+                    expect(frame[15]).toEqual(0);
+                    expect(frame[21]).toEqual(0);  
+                                     
+                }
+
+                server2.on('data', dataCallback);
+
+                function reqCallback(socket, req){
+                    //console.log('request')
+                    
+                    expect(req.unitId).toEqual(255);
+                    expect(req.functionCode).toEqual(1);
+                    expect(req.data.length).toEqual(4);                    
+                }
+
+                server2.on('request', reqCallback);
+
+                function writeCallback(socket, frame){
+                    expect(socket).toBeInstanceOf(net.Socket)
+                    expect(frame[2]).toEqual(0);
+                    expect(frame[6]).toEqual(255);
+                    
+                }
+                 
+                testClient2.send(adu1, 1502, 'localhost');  
+                
+            }   
+            
+        }
+
+        server2.on('listening', listeningCallback);
+
+        function closedCallback(){
+            //console.log('closed') 
+            expect(server2.isListening).toEqual(false);
+            
+            done()
+        }
+
+        server2.on('closed', closedCallback)
+
+        server2.start()  
+             
+    });    
+    
+    
+    
+});

package/CHANGELOG.md

@@ -1,27 +0,0 @@
-# Nodbus-Plus Changelog
-
-## Verion 0.6.2
-* ### Client
-
-Se implementa el evento idle en el modbus master.
-Se agrega la propiedad isIdle
-
-## Verion 0.6.4
-* ### Slave
-
-Se implementa la propiedad modbusAddress en modbus_slave con chequeo de rango.
-
-
-## Verison 0.7.2
-* ### Nodbus
-
-Se agrega el modbus slave a lo objetos exportados por nodbus.
-
-## Version 0.8.0
-* ### ModbusMaster
-
-Add retries when a modbus indication has timeout.
-Add suport for multiples slaves.
-
-
-

package/src/client/m_stcp_client.js

@@ -1,214 +0,0 @@
-/**
-** Modbus Serial over Tcp Client  module.
-* @module client/modbus_stcp_client
-* @author Hector E. Socarras.
-* @version 0.6.0
-*/
-
-const ModbusMaster = require('../protocol/modbus_master');
-const TcpClient = require('../net/tcpclient');
-const RTU_ADU = require('../protocol/rtu_adu');
-const ASCII_ADU = require('../protocol/ascii_adu');
-var ADU ;
-
-/**
- * Class representing a modbus master over tcp.
- * @extends ModbusMaster
-*/
-class ModbusTCPClient extends  ModbusMaster {
-  /**
-  * Create a Modbus Serial over Tcp Client.
-  */
-    constructor(mode = 'rtu'){
-        super();
-
-        var self = this;
-
-        var serialMode = mode;
-
-        /**
-        * tcp layer
-        * @type {object}
-        */
-        this.netClient = new TcpClient();
-
-        //asociando el evento data del netClient con la funcion ProcessResponse
-        this.netClient.onData = this.ProcessResponse.bind(this);
-
-        /**
-        * Emit connect and ready events
-        * @param {object} target Socket object
-        * @fires ModbusTCPClient#connect {object}
-        * @fires ModbusTCPClient#ready
-        */
-        this.netClient.onConnect = self._EmitConnect.bind(this);
-
-
-        /**
-        *Emit disconnect event
-        * @param {object} had_error
-        * @fires ModbusTCPClient#disconnect {object}
-        */
-        function EmitDisconnect(id, had_error){
-          let slave = this.slaveList.get(id);
-
-            /**
-           * disconnect event.
-           * @event ModbusTCPClient#disconnect
-           */
-          this.emit('disconnect',id, had_error);
-          slave.isReady = false;
-
-        }
-        this.netClient.onClose = EmitDisconnect.bind(this);
-
-        /**
-        *Emit error event
-        * @param {object} error
-        * @fires ModbusTCPClient#error {object}
-        */
-        function EmitError (id, err){
-
-          /**
-         * error event.
-         * @event ModbusTCPClient#error
-         * @type {object}
-         */
-            this.emit('error',id, err);
-        }
-        this.netClient.onError = EmitError.bind(this);
-
-        /**
-        * Emit timeout event        *
-        * @fires ModbusTCPClient#timeout
-        */
-        this.netClient.onTimeOut =  self._EmitTimeout.bind(this);;
-
-        /**
-        * Emit Indication event        *
-        * @fires ModbusTCPClient#indication
-        */
-        function EmitIndication(id, data){
-          /**
-         * indication event.
-         * @event ModbusTCPClient#indication
-         */
-          this.emit('indication',id, data);
-        }
-        this.netClient.onWrite = EmitIndication.bind(this);        
-        
-    }
-
-
-    /**
-    * function to create a adu
-    * @param {object} pdu of request
-    * @return {object} adu request
-    */
-    CreateADU(id, pdu){
-      let slave = this.slaveList.get(id);
-      var ADU;
-      
-      if(slave.serialMode == 'ascii'){
-        ADU = ASCII_ADU;
-      }
-      else{
-        ADU = RTU_ADU;
-      }
-      let adu = new ADU();
-      adu.address = slave.modbusAddress;
-      adu.pdu = pdu;
-
-      adu.MakeBuffer();
-
-      return adu;
-    }
-
-    /**
-    * function to pasrse server response
-    * @param {Buffer} aduBuffer frame of response
-    * @return {object} map Object whit register:value pairs
-    * @fires ModbusTCPClient#modbus_exception {object}
-    * @fires ModbusTCPClient#error {object}
-    */
-    ParseResponse(id, aduBuffer) {
-
-      let slave = this.slaveList.get(id);
-      var ADU;
-      if(slave.serialMode == 'ascii'){
-        ADU = ASCII_ADU;
-      }
-      else{
-        ADU = RTU_ADU;
-      }
-
-      let resp = new ADU(aduBuffer);
-      try{
-        resp.ParseBuffer();
-        return this.ParseResponsePDU(id, resp.pdu);
-      }
-      catch(err){
-        if(err.description == 'checksum error'){
-          this.emit('modbus_exception', id, "CHEKSUM ERROR");
-          return false;
-        }
-        else throw err;
-      }
-
-    }
-
-
-    Start(id){
-      let self = this;
-      let successPromise;
-
-      if(id){
-        let slave = self.slaveList.get(id);
-        if(slave.isReady){
-          return Promise.resolve(id);
-        }
-        else{
-          return self.netClient.Connect(slave);
-        }
-      }
-      else{
-        let promiseList = [];
-        this.slaveList.forEach(function(slave, key){
-          let promise;          
-          promise = self.netClient.Connect(slave);
-          promiseList.push(promise);
-        })
-        successPromise = Promise.all(promiseList);        
-        
-        return successPromise;
-      }
-		  
-	  }
-    /**
-    *disconnect from server
-    */
-	  Stop(id){
-		  if(id){
-        let slave = this.slaveList.get(id);
-        if(slave.isReady){
-          return Promise.resolve(id);
-        }
-        else{
-          return this.netClient.Disconnet(id);
-        }        
-      }
-      else{
-        let promiseList = [];
-        this.slaveList.forEach(function(slave, key){
-          let promise;
-          promise = this.netClient.Disconnet(id);
-          promiseList.push(promise);
-        })
-        successPromise = Promise.all(promiseList);
-        return successPromise;
-      }
-	  }
-
-}
-
-module.exports = ModbusTCPClient;