njs-modbus 1.2.0 → 1.3.1

package/dist/index.d.ts

@@ -156,35 +156,68 @@ interface AbstractApplicationLayerEvents {
     }, response: (data: Buffer) => Promise<void>];
 }
 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;
 }
 
 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;
 }
 
 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;
 }
 
 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;
 }
@@ -204,42 +237,41 @@ declare class ModbusMaster<A extends AbstractApplicationLayer, P extends Abstrac
     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;
@@ -251,7 +283,7 @@ declare class ModbusMaster<A extends AbstractApplicationLayer, P extends Abstrac
     }, write: {
         address: number;
         value: number[];
-    }, timeout?: number): void;
+    }, timeout?: number): Promise<void>;
     readAndWriteMultipleRegisters(unit: number, read: {
         address: number;
         length: number;
@@ -260,7 +292,7 @@ declare class ModbusMaster<A extends AbstractApplicationLayer, P extends Abstrac
         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>;