nodbus-plus 0.8.2 → 1.0.0

package/test/modbus_master.test.js

@@ -0,0 +1,279 @@
+const ModbusClient = require('../').ModbusClient
+
+describe("Read Coils status", () => {
+    let pdu1 = Buffer.from([0x01, 0x00, 0x00, 0x00, 0x03]);  
+    let pdu2 = Buffer.from([0x01, 0x00, 0x48, 0x00, 0x0A]);
+    
+    let testMaster = new ModbusClient();
+    
+    it("request 1", () => {
+       let req1 = testMaster.readCoilStatusPdu(0, 3);        
+       expect(req1[0]).toEqual(1);     
+       expect(req1[1]).toEqual(0);  
+       expect(req1[4]).toEqual(3);  
+       expect(req1.length).toEqual(5);    
+    } );
+    it("request 2", () => {
+        let req2 = testMaster.readCoilStatusPdu(0x48, 10);
+        expect(req2[0]).toEqual(1);     
+        expect(req2[2]).toEqual(0x48); 
+        expect(req2[4]).toEqual(10);  
+        expect(req2.length).toEqual(5); 
+    });
+    
+});
+
+describe("Read Input status", () => {
+       
+    let testMaster = new ModbusClient();
+    
+    it("request 1", () => {
+       let req1 = testMaster.readInputStatusPdu(0, 3);        
+       expect(req1[0]).toEqual(2);     
+       expect(req1[1]).toEqual(0);  
+       expect(req1[4]).toEqual(3);  
+       expect(req1.length).toEqual(5);    
+    } );
+    it("request 2", () => {
+        let req2 = testMaster.readInputStatusPdu(0x48, 10);
+        expect(req2[0]).toEqual(2);     
+        expect(req2[2]).toEqual(0x48); 
+        expect(req2[4]).toEqual(10);  
+        expect(req2.length).toEqual(5); 
+    });
+    
+});
+
+describe("Read Holding register status", () => {
+        
+    let testMaster = new ModbusClient();
+    
+    it("request 1", () => {
+       let req1 = testMaster.readHoldingRegistersPdu(0, 3);        
+       expect(req1[0]).toEqual(3);     
+       expect(req1[1]).toEqual(0);  
+       expect(req1[4]).toEqual(3);  
+       expect(req1.length).toEqual(5);    
+    } );
+    it("request 2", () => {
+        let req2 = testMaster.readHoldingRegistersPdu(0x48, 10);
+        expect(req2[0]).toEqual(3);     
+        expect(req2[2]).toEqual(0x48); 
+        expect(req2[4]).toEqual(10);  
+        expect(req2.length).toEqual(5); 
+    });
+    
+});
+
+describe("Read Input register status", () => {
+        
+    let testMaster = new ModbusClient();
+    
+    it("request 1", () => {
+       let req1 = testMaster.readInputRegistersPdu(0, 3);        
+       expect(req1[0]).toEqual(4);     
+       expect(req1[1]).toEqual(0);  
+       expect(req1[4]).toEqual(3);  
+       expect(req1.length).toEqual(5);    
+    } );
+    it("request 2", () => {
+        let req2 = testMaster.readInputRegistersPdu(0x48, 10);
+        expect(req2[0]).toEqual(4);     
+        expect(req2[2]).toEqual(0x48); 
+        expect(req2[4]).toEqual(10);  
+        expect(req2.length).toEqual(5); 
+    });
+    
+});
+
+describe("force single Coils", () => {
+        
+    let testMaster = new ModbusClient();
+    
+    it("request 1", () => {
+       let req1 = testMaster.forceSingleCoilPdu(testMaster.boolToBuffer(true), 3);        
+       expect(req1[0]).toEqual(5);     
+       expect(req1[2]).toEqual(3);  
+       expect(req1[3]).toEqual(0xFF);  
+       expect(req1.length).toEqual(5);    
+    } );
+    it("request 2", () => {
+        let req2 = testMaster.forceSingleCoilPdu(testMaster.boolToBuffer(false), 10);
+        expect(req2[0]).toEqual(5);     
+        expect(req2[2]).toEqual(10); 
+        expect(req2[4]).toEqual(0);  
+        expect(req2.length).toEqual(5); 
+    });
+    
+});
+
+describe("Preset single register", () => {
+        
+    let testMaster = new ModbusClient();
+    let val1 = Buffer.alloc(2);
+    val1[0] = 0x25;
+    val1[1] = 0x56;
+    it("request 1", () => {
+       let req1 = testMaster.presetSingleRegisterPdu(val1, 20); 
+       expect(req1[0]).toEqual(6);     
+       expect(req1[2]).toEqual(20);  
+       expect(req1[4]).toEqual(0x56);  
+       expect(req1.length).toEqual(5);    
+    } );
+    it("request 2", () => {
+        let req2 = testMaster.presetSingleRegisterPdu(val1, 10);        
+        expect(req2[0]).toEqual(6);     
+        expect(req2[2]).toEqual(10); 
+        expect(req2[3]).toEqual(0x25);  
+        expect(req2.length).toEqual(5); 
+    });
+    
+});
+
+describe("write multiple Coils", () => {
+        
+    let testMaster = new ModbusClient();
+    let val1 = Buffer.alloc(1);
+    let val2 = Buffer.alloc(2);
+    val1[0] = 0x36;
+    val2[0] = 0x74;
+    val2[1] = 0x25;
+
+    test("bools to buffer", () => {
+        let valBuffer = testMaster.boolsToBuffer([0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1]);
+        expect(valBuffer.length).toEqual(2);
+        expect(valBuffer[0]).toEqual(0xC2);
+        expect(valBuffer[1]).toEqual(0x04);
+    })
+
+    it("request 1", () => {
+       let req1 = testMaster.forceMultipleCoilsPdu(val1, 3, 5);        
+       expect(req1[0]).toEqual(15);     
+       expect(req1[2]).toEqual(3);  
+       expect(req1[4]).toEqual(5);  
+       expect(req1[5]).toEqual(1);  
+       expect(req1[6]).toEqual(0x36);          
+    } );
+
+    it("request 2", () => {
+        let req2 = testMaster.forceMultipleCoilsPdu(val2, 10, 12);
+        expect(req2[0]).toEqual(15);     
+        expect(req2[2]).toEqual(10); 
+        expect(req2[4]).toEqual(12);  
+        expect(req2[5]).toEqual(2); 
+        expect(req2[7]).toEqual(0x25);  
+    });
+    
+});
+
+describe("write multiple register", () => {
+        
+    let testMaster = new ModbusClient();
+    let val1 = Buffer.alloc(4);
+    val1[0] = 0x25;
+    val1[1] = 0x56;
+    val1[2] = 0x46;
+    val1[3] = 0x63;
+
+    it("request 1", () => {
+       let req1 = testMaster.presetMultipleRegistersPdu(val1, 20); 
+       expect(req1[0]).toEqual(16);     
+       expect(req1[2]).toEqual(20);  
+       expect(req1[4]).toEqual(2);  
+       expect(req1[5]).toEqual(4);  
+       expect(req1.length).toEqual(10);    
+    } );
+    it("request 2", () => {
+        let req2 = testMaster.presetMultipleRegistersPdu(val1, 10, 3);        
+        expect(req2[0]).toEqual(16);     
+        expect(req2[2]).toEqual(10); 
+        expect(req2[4]).toEqual(3); 
+        expect(req2[5]).toEqual(6);   
+        expect(req2.length).toEqual(12); 
+    });
+    
+});
+
+describe("mask holding register", () => {
+        
+    let testMaster = new ModbusClient();
+    let val1 = new Array(16);
+    val1[0] = -1;
+    val1[1] = 0;
+    val1[2] = 1;
+    val1[3] = -1;
+    val1[4] = -1;
+    val1[5] = -1;
+    val1[6] = 0;
+    val1[7] = 0;
+    val1[8] = 1;
+    val1[9] = -1;
+    val1[10] = -1;
+    val1[11] = -1;
+    val1[12] = -1;
+    val1[13] = -1;
+    val1[14] = 1;
+    val1[15] = 1;
+    
+    maskBuffer = testMaster.getMaskRegisterBuffer(val1);
+    
+    it("request 1", () => {
+       let req1 = testMaster.maskHoldingRegisterPdu(maskBuffer, 20); 
+       expect(req1[0]).toEqual(22);     
+       expect(req1[2]).toEqual(20); 
+       expect(req1.length).toEqual(7);    
+    } );
+
+    it("mask", () => {
+        //masks
+        let andMask =  maskBuffer.readUInt16BE(0);     
+        let orMask =   maskBuffer.readUInt16BE(2); 
+        let testRegister = Buffer.alloc(2)
+        testRegister[0] = 0x9A;
+        testRegister[1] = 0xFB;
+        let currentContent = testRegister.readUInt16BE(0);
+        let finalResult = (currentContent & andMask) | (orMask & (~andMask));
+        let finalBuffer = Buffer.alloc(2);
+        finalBuffer.writeUInt16BE(finalResult, 0);
+        expect(maskBuffer[0]).toEqual(0x3E);
+        expect(maskBuffer[1]).toEqual(0x39);
+        expect(maskBuffer[2]).toEqual(0xFF);
+        expect(maskBuffer[3]).toEqual(0x3D);
+        expect(finalResult).toEqual(0xDB3D);
+        expect(finalBuffer[0]).toEqual(0xDB);     
+        expect(finalBuffer[1]).toEqual(0x3D); 
+    });
+    
+});
+
+describe("read and write multiple register", () => {
+        
+    let testMaster = new ModbusClient();
+    let val1 = Buffer.alloc(4);
+    val1[0] = 0x25;
+    val1[1] = 0x56;
+    val1[2] = 0x46;
+    val1[3] = 0x63;
+
+    it("request 1", () => {
+       let req1 = testMaster.readWriteMultipleRegistersPdu(val1, 20, 5, 100); 
+       expect(req1[0]).toEqual(23);     
+       expect(req1[2]).toEqual(20);  
+       expect(req1[4]).toEqual(5);  
+       expect(req1[6]).toEqual(100);
+       expect(req1[8]).toEqual(2);  
+       expect(req1[9]).toEqual(4); 
+       expect(req1.length).toEqual(14);    
+    } );
+    it("request 2", () => {
+        let req2 = testMaster.readWriteMultipleRegistersPdu(val1, 10, 3, 20, 5);              
+        expect(req2[0]).toEqual(23);     
+        expect(req2[2]).toEqual(10); 
+        expect(req2[4]).toEqual(3); 
+        expect(req2[6]).toEqual(20);   
+        expect(req2[8]).toEqual(5);  
+        expect(req2[9]).toEqual(10);  
+        expect(req2.length).toEqual(20); 
+    });
+    
+});

package/test/modbus_master_serial.test.js

@@ -0,0 +1,124 @@
+const ModbusSerialClient = require('../').ModbusSerialClient
+
+
+describe("Make reqest Buffer", () => {
+    let pdu1 = Buffer.from([0x01, 0x00, 0x00, 0x00, 0x03]);  
+    let pdu2 = [0x01, 0x00, 0x48, 0x00, 0x0A, 0x05];
+    
+    let testMaster = new ModbusSerialClient();
+    
+    it("fail to make request", () => {        
+        
+        req1 = testMaster.makeRequest(10, pdu2);
+        req2 = testMaster.makeRequest(258, pdu1);
+        expect(req1).toEqual(null);     
+        expect(req2).toEqual(null);
+          
+            
+    } );
+
+    it("successful request", () => {
+
+        req1 = testMaster.makeRequest(2, pdu1);       
+        expect(req1[0]).toEqual(2);     
+        expect(req1[1]).toEqual(1);  
+        expect(req1[3]).toEqual(0);  
+        expect(req1[5]).toEqual(3);
+        expect(req1[6]).toEqual(0x7C);
+        expect(req1[7]).toEqual(0x38);
+        expect(req1.length).toEqual(8);  
+    });
+
+    it("successful request Ascii", () => {
+
+        req = testMaster.makeRequest(2, pdu1);   
+        req1 = testMaster.aduRtuToAscii(req)    
+        expect(req1[0]).toEqual(0x3A);     
+        expect(req1[2]).toEqual(0x32);  
+        expect(req1[4]).toEqual(0x31);  
+        expect(req1[12]).toEqual(0x33);
+        expect(req1[13]).toEqual(0x46);
+        expect(req1[14]).toEqual(0x41);
+        expect(req1.length).toEqual(17);  
+    });
+    
+});
+
+
+describe("setReqTimer", () => {
+    let pdu1 = Buffer.from([0x01, 0x00, 0x00, 0x00, 0x03]);     
+    
+    let testMaster = new ModbusSerialClient();
+    
+    it("successful request", () => {
+
+        req1 = testMaster.makeRequest(2, pdu1);       
+        
+        let timed1 = testMaster.setReqTimer(1500);
+        expect(timed1).toEqual(-1);
+
+        testMaster.activeRequest = req1;
+        let timed3 = testMaster.setReqTimer(100);
+        let stored = testMaster.activeRequestTimerId;
+        expect(stored).toEqual(timed3); 
+
+        testMaster.on('req-timeout', (req) =>{            
+            expect(req[0]).toEqual(2);
+            expect(req[1]).toEqual(1);
+        })
+        
+
+    });
+    
+});
+
+describe('calc crc', () => {
+
+    let adu1 = Buffer.from([0x02, 0x07, 0x00, 0x00]); 
+    let adu2 = Buffer.from([0x02, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03]);
+    let adu3 = Buffer.from([0x02, 0x01, 0x01, 0x00, 0x00, 0x03]);
+    
+    let testMaster = new ModbusSerialClient();
+
+    it('crc', ()=>{
+        crc1 = testMaster.calcCRC(adu1);
+        crc2 = testMaster.calcCRC(adu2);
+        crc3 = testMaster.calcCRC(adu3);
+
+        expect(crc1).toEqual(0x4112);
+        expect(crc2).toEqual(0x7C38);
+        expect(crc3).toEqual(0x51CC);
+
+    })
+    
+
+})
+
+describe("processResAdu", () => {
+    let pdu1 = Buffer.from([0x01, 0x00, 0x00, 0x00, 0x03]); 
+    
+    let testMaster = new ModbusSerialClient();
+    
+    it("response", () => {
+
+        
+        req1 = testMaster.makeRequest(2, pdu1);       
+        testMaster.activeRequest = req1;
+                
+        let timed3 = testMaster.setReqTimer(100);        
+        
+        let res = Buffer.from([0x02, 0x01, 0x01, 0x00,  0x05, 0x80]); 
+
+        testMaster.processResAdu(res);
+        
+        testMaster.on('transaction', (req, res) =>{            
+            
+            expect(req[0]).toEqual(2); 
+            expect(req[5]).toEqual(3);
+            expect(res[0]).toEqual(2); 
+            expect(stored[5]).toEqual(80);
+        })
+
+    });
+    
+});

package/test/modbus_master_tcp.test.js

@@ -0,0 +1,178 @@
+const ModbusTcpClient = require('../').ModbusTcpClient
+
+describe("Make Mbap header", () => {
+    let pdu1 = Buffer.from([0x01, 0x00, 0x00, 0x00, 0x03]);  
+    let pdu2 = Buffer.from([0x01, 0x00, 0x48, 0x00, 0x0A, 0x05]);
+    
+    let testMaster = new ModbusTcpClient();
+    
+    it("header 1", () => {
+        testMaster.transactionCount = 1;
+        let header = testMaster.makeHeader(2, pdu1.length);        
+        expect(header[0]).toEqual(0);     
+        expect(header[1]).toEqual(1);  
+        expect(header[3]).toEqual(0);  
+        expect(header[5]).toEqual(6);
+        expect(header[6]).toEqual(2);
+        expect(header.length).toEqual(7);    
+    } );
+    it("header 2", () => {
+        testMaster.transactionCount = 10;
+        let header = testMaster.makeHeader(20, pdu2.length);        
+        expect(header[0]).toEqual(0);     
+        expect(header[1]).toEqual(10);  
+        expect(header[3]).toEqual(0);  
+        expect(header[5]).toEqual(7);
+        expect(header[6]).toEqual(20);
+        expect(header.length).toEqual(7);  
+    });
+    
+});
+
+describe("Parse Mbap header", () => {
+    let header1 = [0x01, 0x01, 0x00, 0x00, 0x00, 0x05, 0x02];
+    let header2 = Buffer.from([0x01, 0x00, 0x00, 0x00, 0x00, 0x03]); 
+    let header3 = Buffer.from([0x00, 0x10, 0x00, 0x00, 0x00, 0x07, 0x05]); 
+    
+    
+    let testMaster = new ModbusTcpClient();
+    
+    it("header 1", () => {        
+                
+        expect(()=>{testMaster.parseHeader(header1)}).toThrow(TypeError);
+        expect(()=>{testMaster.parseHeader(header1)}).toThrow('Error: Header must be a buffer instance');     
+            
+    } );
+
+    it("header 2", () => {        
+                
+        expect(()=>{testMaster.parseHeader(header2)}).toThrow(RangeError);
+        expect(()=>{testMaster.parseHeader(header2)}).toThrow('Error: Header must be 7 bytes long');     
+            
+    } );
+    
+    it("header 3", () => {
+        
+        let header = testMaster.parseHeader(header3);        
+        expect(header.transactionId).toEqual(16);
+        expect(header.protocolId).toEqual(0);    
+        expect(header.length).toEqual(7);    
+        expect(header.unitId).toEqual(5);
+    });
+    
+});
+
+describe("Make reqest Buffer", () => {
+    let pdu1 = Buffer.from([0x01, 0x00, 0x00, 0x00, 0x03]);  
+    let pdu2 = [0x01, 0x00, 0x48, 0x00, 0x0A, 0x05];
+    
+    let testMaster = new ModbusTcpClient();
+    
+    it("fail to make request", () => {        
+        
+        req1 = testMaster.makeRequest(10, pdu2);
+        req2 = testMaster.makeRequest(258, pdu1);
+        expect(req1).toEqual(null);     
+        expect(req2).toEqual(null);
+          
+            
+    } );
+
+    it("successful request", () => {
+
+        testMaster.transactionCount = 10;
+
+        req1 = testMaster.makeRequest(2, pdu1);       
+        expect(req1[1]).toEqual(11);     
+        expect(req1[5]).toEqual(6);  
+        expect(req1[6]).toEqual(2);  
+        expect(req1[7]).toEqual(1);
+        expect(req1[11]).toEqual(3);
+        expect(req1.length).toEqual(12);  
+    });
+    
+});
+
+describe("storeRequest", () => {
+    let pdu1 = Buffer.from([0x01, 0x00, 0x00, 0x00, 0x03]);     
+    
+    let testMaster = new ModbusTcpClient();
+    
+    it("successful request", () => {
+
+        testMaster.transactionCount = 10;
+
+        req1 = testMaster.makeRequest(2, pdu1);       
+        let store = testMaster.storeRequest(req1);
+        expect(store).toEqual(true);
+        expect(testMaster.reqPool.has(11)).toEqual(true);
+        let stored = testMaster.reqPool.get(11);
+        expect(stored[1]).toEqual(11); 
+        expect(stored[11]).toEqual(3);
+
+    });
+    
+});
+
+describe("setReqTimer", () => {
+    let pdu1 = Buffer.from([0x01, 0x00, 0x00, 0x00, 0x03]);     
+    
+    let testMaster = new ModbusTcpClient();
+    
+    it("successful request", () => {
+
+        testMaster.transactionCount = 10;
+
+        req1 = testMaster.makeRequest(2, pdu1);       
+        testMaster.storeRequest(req1);
+        expect(testMaster.reqPool.has(11)).toEqual(true);
+        let timed1 = testMaster.setReqTimer(10, 1500);
+        let timed2 = testMaster.setReqTimer(11, 0);
+        let timed3 = testMaster.setReqTimer(11, 10);
+        expect(timed1).toEqual(-1);
+        expect(timed2).toEqual(-1);
+        expect(testMaster.reqTimersPool.has(11)).toEqual(true);
+        let stored = testMaster.reqTimersPool.get(11);
+        expect(stored).toEqual(timed3);
+
+        testMaster.on('req-timeout', (transactionId) =>{            
+            expect(transactionId).toEqual(11);
+        })
+        
+
+    });
+    
+});
+
+describe("processResAdu", () => {
+    let pdu1 = Buffer.from([0x01, 0x00, 0x00, 0x00, 0x03]); 
+    
+    let testMaster = new ModbusTcpClient();
+    
+    it("response", () => {
+
+        testMaster.transactionCount = 10;
+
+        req1 = testMaster.makeRequest(2, pdu1);       
+        testMaster.storeRequest(req1);
+        expect(testMaster.reqPool.has(11)).toEqual(true);
+        
+        let timed3 = testMaster.setReqTimer(11, 10);        
+        expect(testMaster.reqTimersPool.has(11)).toEqual(true);
+
+        let res = Buffer.from([0x00, 0x0B, 0x00, 0x00, 0x00, 0x06, 0x02, 0x01, 0x00, 0x00, 0x00, 0x03]); 
+        testMaster.processResAdu(res);
+        expect(testMaster.reqTimersPool.has(11)).toEqual(false);
+        expect(testMaster.reqPool.has(11)).toEqual(false);
+        
+        testMaster.on('transaction', (req, res) =>{            
+            
+            expect(req[1]).toEqual(11); 
+            expect(req[11]).toEqual(3);
+            expect(res[1]).toEqual(11); 
+            expect(res[11]).toEqual(3);
+        })
+
+    });
+    
+});