njs-modbus 1.2.0 → 1.3.1

package/dist/src/layers/application/abstract-application-layer.d.ts

@@ -6,6 +6,12 @@ interface AbstractApplicationLayerEvents {
     }, response: (data: Buffer) => Promise<void>];
 }
 export declare abstract class AbstractApplicationLayer extends EventEmitter<AbstractApplicationLayerEvents> {
+    abstract startWaitingResponse(preCheck: ((frame: ApplicationDataUnit & {
+        buffer: Buffer;
+    }) => boolean | number | undefined)[], callback: (error: Error | null, frame?: ApplicationDataUnit & {
+        buffer: Buffer;
+    }) => void): void;
+    abstract stopWaitingResponse(): void;
     abstract encode(data: ApplicationDataUnit): Buffer;
     abstract destroy(): void;
 }

package/dist/src/layers/application/ascii-application-layer.d.ts

@@ -3,11 +3,18 @@ import type { TcpClientPhysicalLayer, TcpServerPhysicalLayer, UdpPhysicalLayer }
 import type { SerialPhysicalLayer } from '../physical';
 import { AbstractApplicationLayer } from './abstract-application-layer';
 export declare class AsciiApplicationLayer extends AbstractApplicationLayer {
+    private _waitingResponse?;
     private _status;
     private _frame;
     private _removeAllListeners;
     constructor(physicalLayer: SerialPhysicalLayer | TcpServerPhysicalLayer | TcpClientPhysicalLayer | UdpPhysicalLayer);
     private framing;
+    startWaitingResponse(preCheck: ((frame: ApplicationDataUnit & {
+        buffer: Buffer;
+    }) => boolean | number | undefined)[], callback: (error: Error | null, frame?: ApplicationDataUnit & {
+        buffer: Buffer;
+    }) => void): void;
+    stopWaitingResponse(): void;
     encode(data: ApplicationDataUnit): Buffer;
     destroy(): void;
 }

package/dist/src/layers/application/rtu-application-layer.d.ts

@@ -3,11 +3,24 @@ import type { TcpClientPhysicalLayer, TcpServerPhysicalLayer, UdpPhysicalLayer }
 import type { SerialPhysicalLayer } from '../physical';
 import { AbstractApplicationLayer } from './abstract-application-layer';
 export declare class RtuApplicationLayer extends AbstractApplicationLayer {
+    private _waitingResponse?;
     private _timerThreePointFive?;
     private _bufferRx;
     private _removeAllListeners;
-    constructor(physicalLayer: SerialPhysicalLayer | TcpServerPhysicalLayer | TcpClientPhysicalLayer | UdpPhysicalLayer, bitsBetweenFrames?: number);
+    constructor(physicalLayer: SerialPhysicalLayer | TcpServerPhysicalLayer | TcpClientPhysicalLayer | UdpPhysicalLayer, 
+    /**
+     * The time interval between two frames, support two formats:
+     * - bit: `48bit` as default
+     * - millisecond: `20ms`
+     */
+    intervalBetweenFrames?: `${number}bit` | `${number}ms`);
     private framing;
+    startWaitingResponse(preCheck: ((frame: ApplicationDataUnit & {
+        buffer: Buffer;
+    }) => boolean | number | undefined)[], callback: (error: Error | null, frame?: ApplicationDataUnit & {
+        buffer: Buffer;
+    }) => void): void;
+    stopWaitingResponse(): void;
     encode(data: ApplicationDataUnit): Buffer;
     destroy(): void;
 }

package/dist/src/layers/application/tcp-application-layer.d.ts

@@ -2,10 +2,17 @@ import type { ApplicationDataUnit } from '../../types';
 import type { TcpClientPhysicalLayer, TcpServerPhysicalLayer, UdpPhysicalLayer } from '../physical';
 import { AbstractApplicationLayer } from './abstract-application-layer';
 export declare class TcpApplicationLayer extends AbstractApplicationLayer {
+    private _waitingResponse?;
     private _transactionId;
     private _removeAllListeners;
     constructor(physicalLayer: TcpServerPhysicalLayer | TcpClientPhysicalLayer | UdpPhysicalLayer);
     private framing;
+    startWaitingResponse(preCheck: ((frame: ApplicationDataUnit & {
+        buffer: Buffer;
+    }) => boolean | number | undefined)[], callback: (error: Error | null, frame?: ApplicationDataUnit & {
+        buffer: Buffer;
+    }) => void): void;
+    stopWaitingResponse(): void;
     encode(data: ApplicationDataUnit): Buffer;
     destroy(): void;
 }

package/dist/src/master/master.d.ts

@@ -17,42 +17,41 @@ export declare class ModbusMaster<A extends AbstractApplicationLayer, P extends
     private applicationLayer;
     private physicalLayer;
     timeout: number;
-    private _responses;
     get isOpen(): boolean;
     get destroyed(): boolean;
     constructor(applicationLayer: A, physicalLayer: P, timeout?: number);
     private waitResponse;
     private writeFC1Or2;
     writeFC1: this['readCoils'];
-    readCoils(unit: 0, address: number, length: number, timeout?: number): void;
+    readCoils(unit: 0, address: number, length: number, timeout?: number): Promise<void>;
     readCoils(unit: number, address: number, length: number, timeout?: number): Promise<ReturnValue<boolean[]>>;
     writeFC2: this['readDiscreteInputs'];
-    readDiscreteInputs(unit: 0, address: number, length: number, timeout?: number): void;
+    readDiscreteInputs(unit: 0, address: number, length: number, timeout?: number): Promise<void>;
     readDiscreteInputs(unit: number, address: number, length: number, timeout?: number): Promise<ReturnValue<boolean[]>>;
     private writeFC3Or4;
     writeFC3: this['readHoldingRegisters'];
-    readHoldingRegisters(unit: 0, address: number, length: number, timeout?: number): void;
+    readHoldingRegisters(unit: 0, address: number, length: number, timeout?: number): Promise<void>;
     readHoldingRegisters(unit: number, address: number, length: number, timeout?: number): Promise<ReturnValue<number[]>>;
     writeFC4: this['readInputRegisters'];
-    readInputRegisters(unit: 0, address: number, length: number, timeout?: number): void;
+    readInputRegisters(unit: 0, address: number, length: number, timeout?: number): Promise<void>;
     readInputRegisters(unit: number, address: number, length: number, timeout?: number): Promise<ReturnValue<number[]>>;
     writeFC5: this['writeSingleCoil'];
-    writeSingleCoil(unit: 0, address: number, value: boolean, timeout?: number): void;
+    writeSingleCoil(unit: 0, address: number, value: boolean, timeout?: number): Promise<void>;
     writeSingleCoil(unit: number, address: number, value: boolean, timeout?: number): Promise<ReturnValue<boolean>>;
     writeFC6: this['writeSingleRegister'];
-    writeSingleRegister(unit: 0, address: number, value: number, timeout?: number): void;
+    writeSingleRegister(unit: 0, address: number, value: number, timeout?: number): Promise<void>;
     writeSingleRegister(unit: number, address: number, value: number, timeout?: number): Promise<ReturnValue<number>>;
     writeFC15: this['writeMultipleCoils'];
-    writeMultipleCoils(unit: 0, address: number, value: boolean[], timeout?: number): void;
+    writeMultipleCoils(unit: 0, address: number, value: boolean[], timeout?: number): Promise<void>;
     writeMultipleCoils(unit: number, address: number, value: boolean[], timeout?: number): Promise<ReturnValue<boolean[]>>;
     writeFC16: this['writeMultipleRegisters'];
-    writeMultipleRegisters(unit: 0, address: number, value: number[], timeout?: number): void;
+    writeMultipleRegisters(unit: 0, address: number, value: number[], timeout?: number): Promise<void>;
     writeMultipleRegisters(unit: number, address: number, value: number[], timeout?: number): Promise<ReturnValue<number[]>>;
     handleFC17: this['reportServerId'];
-    reportServerId(unit: 0, timeout?: number): void;
+    reportServerId(unit: 0, timeout?: number): Promise<void>;
     reportServerId(unit: number, timeout?: number): Promise<ReturnValue<ServerId>>;
     handleFC22: this['maskWriteRegister'];
-    maskWriteRegister(unit: 0, address: number, andMask: number, orMask: number, timeout?: number): void;
+    maskWriteRegister(unit: 0, address: number, andMask: number, orMask: number, timeout?: number): Promise<void>;
     maskWriteRegister(unit: number, address: number, andMask: number, orMask: number, timeout?: number): Promise<ReturnValue<{
         andMask: number;
         orMask: number;
@@ -64,7 +63,7 @@ export declare class ModbusMaster<A extends AbstractApplicationLayer, P extends
     }, write: {
         address: number;
         value: number[];
-    }, timeout?: number): void;
+    }, timeout?: number): Promise<void>;
     readAndWriteMultipleRegisters(unit: number, read: {
         address: number;
         length: number;
@@ -73,7 +72,7 @@ export declare class ModbusMaster<A extends AbstractApplicationLayer, P extends
         value: number[];
     }, timeout?: number): Promise<ReturnValue<number[]>>;
     handleFC43_14: this['readDeviceIdentification'];
-    readDeviceIdentification(unit: 0, readDeviceIDCode: number, objectId: number, timeout?: number): void;
+    readDeviceIdentification(unit: 0, readDeviceIDCode: number, objectId: number, timeout?: number): Promise<void>;
     readDeviceIdentification(unit: number, readDeviceIDCode: number, objectId: number, timeout?: number): Promise<ReturnValue<DeviceIdentification>>;
     open(...args: Parameters<P['open']>): Promise<void>;
     close(): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "njs-modbus",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "A pure JavaScript implemetation of Modbus for NodeJS.",
   "keywords": [
     "modbus",