njs-modbus 1.2.0 → 1.3.1

package/dist/index.cjs

@@ -546,8 +546,20 @@ function lrc(data) {
 }
 
 class RtuApplicationLayer extends AbstractApplicationLayer {
-    constructor(physicalLayer, bitsBetweenFrames) {
+    constructor(physicalLayer, 
+    /**
+     * The time interval between two frames, support two formats:
+     * - bit: `48bit` as default
+     * - millisecond: `20ms`
+     */
+    intervalBetweenFrames) {
         super();
+        Object.defineProperty(this, "_waitingResponse", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "_timerThreePointFive", {
             enumerable: true,
             configurable: true,
@@ -568,25 +580,42 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
         });
         let threePointFiveT = 0;
         if (physicalLayer.TYPE === 'SERIAL') {
-            threePointFiveT = Math.ceil(physicalLayer.baudRate > 19200
-                ? 1.8
-                : getThreePointFiveT(physicalLayer.baudRate, bitsBetweenFrames));
+            if (intervalBetweenFrames && intervalBetweenFrames.endsWith('ms')) {
+                threePointFiveT = Number(intervalBetweenFrames.slice(0, -2));
+            }
+            else {
+                threePointFiveT = Math.ceil(physicalLayer.baudRate > 19200
+                    ? 1.8
+                    : getThreePointFiveT(physicalLayer.baudRate, intervalBetweenFrames ? Number(intervalBetweenFrames.slice(0, -3)) : 48));
+            }
         }
         const handleData = (data, response) => {
             this._bufferRx = Buffer.concat([this._bufferRx, data]);
-            clearTimeout(this._timerThreePointFive);
-            const handleData = () => {
-                const frame = this.framing(this._bufferRx);
-                if (frame) {
-                    this.emit('framing', frame, response);
-                }
-                this._bufferRx = Buffer.alloc(0);
-            };
-            if (threePointFiveT) {
-                this._timerThreePointFive = setTimeout(handleData, threePointFiveT);
+            if (this._waitingResponse) {
+                this.framing(this._bufferRx, (error, frame) => {
+                    if (error && error.message === 'Insufficient data length') {
+                        return;
+                    }
+                    this._waitingResponse.callback(error, frame);
+                    this._bufferRx = Buffer.alloc(0);
+                });
             }
             else {
-                handleData();
+                clearTimeout(this._timerThreePointFive);
+                const handleData = () => {
+                    this.framing(this._bufferRx, (error, frame) => {
+                        if (!error) {
+                            this.emit('framing', frame, response);
+                        }
+                        this._bufferRx = Buffer.alloc(0);
+                    });
+                };
+                if (threePointFiveT) {
+                    this._timerThreePointFive = setTimeout(handleData, threePointFiveT);
+                }
+                else {
+                    handleData();
+                }
             }
         };
         physicalLayer.on('data', handleData);
@@ -602,18 +631,56 @@ class RtuApplicationLayer extends AbstractApplicationLayer {
             physicalLayer.removeListener('close', handleClose);
         });
     }
-    framing(buffer) {
+    framing(buffer, callback) {
         if (buffer.length >= 4) {
+            const frame = {
+                unit: buffer[0],
+                fc: buffer[1],
+                data: Array.from(buffer.subarray(2, buffer.length - 2)),
+                buffer,
+            };
+            if (this._waitingResponse) {
+                for (const check of this._waitingResponse.preCheck) {
+                    const res = check(frame);
+                    if (typeof res === 'undefined') {
+                        callback(new Error('Insufficient data length'));
+                        return;
+                    }
+                    if (typeof res === 'number') {
+                        if (res < frame.data.length) {
+                            callback(new Error('Insufficient data length'));
+                            return;
+                        }
+                        if (res !== frame.data.length) {
+                            callback(new Error('Invalid response'));
+                            return;
+                        }
+                    }
+                    if (!res) {
+                        callback(new Error('Invalid response'));
+                        return;
+                    }
+                }
+            }
             const crcPassed = buffer.readUInt16LE(buffer.length - 2) === crc(buffer.subarray(0, buffer.length - 2));
             if (crcPassed) {
-                return {
-                    unit: buffer[0],
-                    fc: buffer[1],
-                    data: Array.from(buffer.subarray(2, buffer.length - 2)),
-                    buffer,
-                };
+                callback(null, frame);
+            }
+            else {
+                callback(new Error('CRC check failed'));
             }
         }
+        else {
+            callback(new Error('Insufficient data length'));
+        }
+    }
+    startWaitingResponse(preCheck, callback) {
+        this._waitingResponse = { preCheck, callback };
+        clearTimeout(this._timerThreePointFive);
+        this._bufferRx = Buffer.alloc(0);
+    }
+    stopWaitingResponse() {
+        this._waitingResponse = undefined;
     }
     encode(data) {
         const buffer = Buffer.alloc(data.data.length + 4);
@@ -642,6 +709,12 @@ const CHAR_CODE = {
 class AsciiApplicationLayer extends AbstractApplicationLayer {
     constructor(physicalLayer) {
         super();
+        Object.defineProperty(this, "_waitingResponse", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "_status", {
             enumerable: true,
             configurable: true,
@@ -690,10 +763,14 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
                         else {
                             this._status = 'idle';
                             if (value === CHAR_CODE.LF) {
-                                const frame = this.framing(Buffer.from(this._frame));
-                                if (frame) {
-                                    this.emit('framing', frame, response);
-                                }
+                                this.framing(Buffer.from(this._frame), (error, frame) => {
+                                    if (this._waitingResponse) {
+                                        this._waitingResponse.callback(error, frame);
+                                    }
+                                    else if (!error) {
+                                        this.emit('framing', frame, response);
+                                    }
+                                });
                             }
                         }
                         break;
@@ -706,7 +783,7 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
             physicalLayer.removeListener('data', handleData);
         });
         const handleClose = () => {
-            this._status = 'reception';
+            this._status = 'idle';
             this._frame = [];
         };
         physicalLayer.on('close', handleClose);
@@ -714,29 +791,72 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
             physicalLayer.removeListener('close', handleClose);
         });
     }
-    framing(_buffer) {
-        if (_buffer.length >= 6 && _buffer.length % 2 === 0) {
-            const frame = [];
-            let num = '';
-            for (const value of _buffer) {
-                num += String.fromCharCode(value);
-                if (num.length === 2) {
-                    frame.push(Number('0x' + num));
-                    num = '';
+    framing(_buffer, callback) {
+        if (_buffer.length >= 6) {
+            if (_buffer.length % 2 === 0) {
+                const ascii = [];
+                let num = '';
+                for (const value of _buffer) {
+                    num += String.fromCharCode(value);
+                    if (num.length === 2) {
+                        ascii.push(Number('0x' + num));
+                        num = '';
+                    }
                 }
-            }
-            const buffer = Buffer.from(frame);
-            const lrcPassed = buffer[buffer.length - 1] === lrc(buffer.subarray(0, buffer.length - 1));
-            if (lrcPassed) {
-                return {
+                const buffer = Buffer.from(ascii);
+                const frame = {
                     unit: buffer[0],
                     fc: buffer[1],
                     data: Array.from(buffer.subarray(2, buffer.length - 1)),
                     buffer: _buffer,
                 };
+                if (this._waitingResponse) {
+                    for (const check of this._waitingResponse.preCheck) {
+                        const res = check(frame);
+                        if (typeof res === 'undefined') {
+                            callback(new Error('Insufficient data length'));
+                            return;
+                        }
+                        if (typeof res === 'number') {
+                            if (res < frame.data.length) {
+                                callback(new Error('Insufficient data length'));
+                                return;
+                            }
+                            if (res !== frame.data.length) {
+                                callback(new Error('Invalid response'));
+                                return;
+                            }
+                        }
+                        if (!res) {
+                            callback(new Error('Invalid response'));
+                            return;
+                        }
+                    }
+                }
+                const lrcPassed = buffer[buffer.length - 1] === lrc(buffer.subarray(0, buffer.length - 1));
+                if (lrcPassed) {
+                    callback(null, frame);
+                }
+                else {
+                    callback(new Error('LRC check failed'));
+                }
             }
+            else {
+                callback(new Error('Invalid data'));
+            }
+        }
+        else {
+            callback(new Error('Insufficient data length'));
         }
     }
+    startWaitingResponse(preCheck, callback) {
+        this._waitingResponse = { preCheck, callback };
+        this._status = 'idle';
+        this._frame = [];
+    }
+    stopWaitingResponse() {
+        this._waitingResponse = undefined;
+    }
     encode(data) {
         const buffer = Buffer.alloc(data.data.length + 3);
         buffer.writeUInt8(data.unit, 0);
@@ -763,6 +883,12 @@ class AsciiApplicationLayer extends AbstractApplicationLayer {
 class TcpApplicationLayer extends AbstractApplicationLayer {
     constructor(physicalLayer) {
         super();
+        Object.defineProperty(this, "_waitingResponse", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "_transactionId", {
             enumerable: true,
             configurable: true,
@@ -776,28 +902,68 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
             value: []
         });
         const handleData = (data, response) => {
-            const frame = this.framing(data);
-            if (frame) {
-                this.emit('framing', frame, response);
-            }
+            this.framing(data, (error, frame) => {
+                if (this._waitingResponse) {
+                    this._waitingResponse.callback(error, frame);
+                }
+                else if (!error) {
+                    this.emit('framing', frame, response);
+                }
+            });
         };
         physicalLayer.on('data', handleData);
         this._removeAllListeners.push(() => {
             physicalLayer.removeListener('data', handleData);
         });
     }
-    framing(buffer) {
+    framing(buffer, callback) {
         if (buffer.length >= 8) {
             if (buffer[2] === 0 && buffer[3] === 0 && buffer.readUInt16BE(4) === buffer.length - 6) {
-                return {
+                const frame = {
                     transaction: buffer.readUInt16BE(0),
                     unit: buffer[6],
                     fc: buffer[7],
                     data: Array.from(buffer.subarray(8)),
                     buffer,
                 };
+                if (this._waitingResponse) {
+                    for (const check of this._waitingResponse.preCheck) {
+                        const res = check(frame);
+                        if (typeof res === 'undefined') {
+                            callback(new Error('Insufficient data length'));
+                            return;
+                        }
+                        if (typeof res === 'number') {
+                            if (res < frame.data.length) {
+                                callback(new Error('Insufficient data length'));
+                                return;
+                            }
+                            if (res !== frame.data.length) {
+                                callback(new Error('Invalid response'));
+                                return;
+                            }
+                        }
+                        if (!res) {
+                            callback(new Error('Invalid response'));
+                            return;
+                        }
+                    }
+                }
+                callback(null, frame);
+            }
+            else {
+                callback(new Error('Invalid data'));
             }
         }
+        else {
+            callback(new Error('Insufficient data length'));
+        }
+    }
+    startWaitingResponse(preCheck, callback) {
+        this._waitingResponse = { preCheck, callback };
+    }
+    stopWaitingResponse() {
+        this._waitingResponse = undefined;
     }
     encode(data) {
         var _a;
@@ -821,38 +987,6 @@ class TcpApplicationLayer extends AbstractApplicationLayer {
     }
 }
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 class ModbusMaster extends EventEmitter {
     get isOpen() {
         return this.physicalLayer.isOpen;
@@ -880,12 +1014,6 @@ class ModbusMaster extends EventEmitter {
             writable: true,
             value: timeout
         });
-        Object.defineProperty(this, "_responses", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Set()
-        });
         Object.defineProperty(this, "writeFC1", {
             enumerable: true,
             configurable: true,
@@ -970,11 +1098,6 @@ class ModbusMaster extends EventEmitter {
         this.handleFC22 = this.maskWriteRegister;
         this.handleFC23 = this.readAndWriteMultipleRegisters;
         this.handleFC43_14 = this.readDeviceIdentification;
-        applicationLayer.on('framing', (frame) => __awaiter(this, void 0, void 0, function* () {
-            for (const response of this._responses) {
-                response(frame);
-            }
-        }));
         physicalLayer.on('error', (error) => {
             this.emit('error', error);
         });
@@ -982,46 +1105,55 @@ class ModbusMaster extends EventEmitter {
             this.emit('close');
         });
     }
-    waitResponse(timeout, cb) {
+    waitResponse(request, response, timeout) {
         return new Promise((resolve, reject) => {
-            const tid = setTimeout(() => {
-                this._responses.delete(response);
-                reject('Timeout');
-            }, timeout);
-            const response = (frame) => {
-                const data = cb(frame);
-                if (typeof data !== 'undefined') {
-                    clearTimeout(tid);
-                    this._responses.delete(response);
-                    resolve({
-                        transaction: frame.transaction,
-                        unit: frame.unit,
-                        fc: frame.fc,
-                        data,
-                        buffer: frame.buffer,
+            this.physicalLayer
+                .write(request.data)
+                .then(() => {
+                if (request.broadcast) {
+                    resolve();
+                }
+                else {
+                    const tid = setTimeout(() => {
+                        this.applicationLayer.stopWaitingResponse();
+                        reject(new Error('Timeout'));
+                    }, timeout);
+                    this.applicationLayer.startWaitingResponse(response.preCheck, (error, frame) => {
+                        clearTimeout(tid);
+                        this.applicationLayer.stopWaitingResponse();
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            resolve(frame);
+                        }
                     });
                 }
-            };
-            this._responses.add(response);
+            })
+                .catch((error) => {
+                reject(error);
+            });
         });
     }
     writeFC1Or2(unit, fc, address, length, timeout) {
+        const byteCount = Math.ceil(length / 8);
         const bufferTx = Buffer.alloc(4);
         bufferTx.writeUInt16BE(address, 0);
         bufferTx.writeUInt16BE(length, 2);
-        this.physicalLayer.write(this.applicationLayer.encode({
-            unit,
-            fc,
-            data: Array.from(bufferTx),
-        }));
-        if (unit !== 0) {
-            return this.waitResponse(timeout, (frame) => {
-                const byteCount = Math.ceil(length / 8);
-                if (frame.unit === unit && frame.fc === fc && frame.data.length === 1 + byteCount && frame.data[0] === byteCount) {
-                    return Array.from({ length }).map((_, index) => (frame.data[1 + ~~(index / 8)] & (1 << index % 8)) > 0);
-                }
-            });
-        }
+        return this.waitResponse({
+            data: this.applicationLayer.encode({
+                unit,
+                fc,
+                data: Array.from(bufferTx),
+            }),
+            broadcast: unit === 0,
+        }, {
+            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 1 + byteCount, (frame) => frame.data[0] === byteCount],
+        }, timeout).then((frame) => {
+            if (frame) {
+                return Object.assign(Object.assign({}, frame), { data: Array.from({ length }).map((_, index) => (frame.data[1 + ~~(index / 8)] & (1 << index % 8)) > 0) });
+            }
+        });
     }
     readCoils(unit, address, length, timeout = this.timeout) {
         return this.writeFC1Or2(unit, 0x01, address, length, timeout);
@@ -1030,23 +1162,25 @@ class ModbusMaster extends EventEmitter {
         return this.writeFC1Or2(unit, 0x02, address, length, timeout);
     }
     writeFC3Or4(unit, fc, address, length, timeout) {
+        const byteCount = length * 2;
         const bufferTx = Buffer.alloc(4);
         bufferTx.writeUInt16BE(address, 0);
         bufferTx.writeUInt16BE(length, 2);
-        this.physicalLayer.write(this.applicationLayer.encode({
-            unit,
-            fc,
-            data: Array.from(bufferTx),
-        }));
-        if (unit !== 0) {
-            return this.waitResponse(timeout, (frame) => {
-                const byteCount = length * 2;
-                if (frame.unit === unit && frame.fc === fc && frame.data.length === 1 + byteCount && frame.data[0] === byteCount) {
-                    const bufferRx = Buffer.from(frame.data.slice(1));
-                    return Array.from({ length }).map((_, index) => bufferRx.readUInt16BE(index * 2));
-                }
-            });
-        }
+        return this.waitResponse({
+            data: this.applicationLayer.encode({
+                unit,
+                fc,
+                data: Array.from(bufferTx),
+            }),
+            broadcast: unit === 0,
+        }, {
+            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 1 + byteCount, (frame) => frame.data[0] === byteCount],
+        }, timeout).then((frame) => {
+            if (frame) {
+                const bufferRx = Buffer.from(frame.data.slice(1));
+                return Object.assign(Object.assign({}, frame), { data: Array.from({ length }).map((_, index) => bufferRx.readUInt16BE(index * 2)) });
+            }
+        });
     }
     readHoldingRegisters(unit, address, length, timeout = this.timeout) {
         return this.writeFC3Or4(unit, 0x03, address, length, timeout);
@@ -1059,42 +1193,48 @@ class ModbusMaster extends EventEmitter {
         const bufferTx = Buffer.alloc(4);
         bufferTx.writeUInt16BE(address, 0);
         bufferTx.writeUInt16BE(value ? 0xff00 : 0x0000, 2);
-        this.physicalLayer.write(this.applicationLayer.encode({
-            unit,
-            fc,
-            data: Array.from(bufferTx),
-        }));
-        if (unit !== 0) {
-            return this.waitResponse(timeout, (frame) => {
-                if (frame.unit === unit &&
-                    frame.fc === fc &&
-                    frame.data.length === bufferTx.length &&
-                    frame.data.every((v, i) => v === bufferTx[i])) {
-                    return value;
-                }
-            });
-        }
+        return this.waitResponse({
+            data: this.applicationLayer.encode({
+                unit,
+                fc,
+                data: Array.from(bufferTx),
+            }),
+            broadcast: unit === 0,
+        }, {
+            preCheck: [
+                (frame) => frame.unit === unit && frame.fc === fc,
+                () => bufferTx.length,
+                (frame) => frame.data.every((v, i) => v === bufferTx[i]),
+            ],
+        }, timeout).then((frame) => {
+            if (frame) {
+                return Object.assign(Object.assign({}, frame), { data: value });
+            }
+        });
     }
     writeSingleRegister(unit, address, value, timeout = this.timeout) {
         const fc = 0x06;
         const bufferTx = Buffer.alloc(4);
         bufferTx.writeUInt16BE(address, 0);
         bufferTx.writeUInt16BE(value, 2);
-        this.physicalLayer.write(this.applicationLayer.encode({
-            unit,
-            fc,
-            data: Array.from(bufferTx),
-        }));
-        if (unit !== 0) {
-            return this.waitResponse(timeout, (frame) => {
-                if (frame.unit === unit &&
-                    frame.fc === fc &&
-                    frame.data.length === bufferTx.length &&
-                    frame.data.every((v, i) => v === bufferTx[i])) {
-                    return value;
-                }
-            });
-        }
+        return this.waitResponse({
+            data: this.applicationLayer.encode({
+                unit,
+                fc,
+                data: Array.from(bufferTx),
+            }),
+            broadcast: unit === 0,
+        }, {
+            preCheck: [
+                (frame) => frame.unit === unit && frame.fc === fc,
+                () => bufferTx.length,
+                (frame) => frame.data.every((v, i) => v === bufferTx[i]),
+            ],
+        }, timeout).then((frame) => {
+            if (frame) {
+                return Object.assign(Object.assign({}, frame), { data: value });
+            }
+        });
     }
     writeMultipleCoils(unit, address, value, timeout = this.timeout) {
         const fc = 0x0f;
@@ -1108,18 +1248,20 @@ class ModbusMaster extends EventEmitter {
                 bufferTx[5 + ~~(i / 8)] |= 1 << i % 8;
             }
         });
-        this.physicalLayer.write(this.applicationLayer.encode({
-            unit,
-            fc,
-            data: Array.from(bufferTx),
-        }));
-        if (unit !== 0) {
-            return this.waitResponse(timeout, (frame) => {
-                if (frame.unit === unit && frame.fc === fc && frame.data.length === 4 && frame.data.every((v, i) => v === bufferTx[i])) {
-                    return value;
-                }
-            });
-        }
+        return this.waitResponse({
+            data: this.applicationLayer.encode({
+                unit,
+                fc,
+                data: Array.from(bufferTx),
+            }),
+            broadcast: unit === 0,
+        }, {
+            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 4, (frame) => frame.data.every((v, i) => v === bufferTx[i])],
+        }, timeout).then((frame) => {
+            if (frame) {
+                return Object.assign(Object.assign({}, frame), { data: value });
+            }
+        });
     }
     writeMultipleRegisters(unit, address, value, timeout = this.timeout) {
         const fc = 0x10;
@@ -1131,40 +1273,48 @@ class ModbusMaster extends EventEmitter {
         value.forEach((v, i) => {
             bufferTx.writeUInt16BE(v, 5 + i * 2);
         });
-        this.physicalLayer.write(this.applicationLayer.encode({
-            unit,
-            fc,
-            data: Array.from(bufferTx),
-        }));
-        if (unit !== 0) {
-            return this.waitResponse(timeout, (frame) => {
-                if (frame.unit === unit && frame.fc === fc && frame.data.length === 4 && frame.data.every((v, i) => v === bufferTx[i])) {
-                    return value;
-                }
-            });
-        }
+        return this.waitResponse({
+            data: this.applicationLayer.encode({
+                unit,
+                fc,
+                data: Array.from(bufferTx),
+            }),
+            broadcast: unit === 0,
+        }, {
+            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 4, (frame) => frame.data.every((v, i) => v === bufferTx[i])],
+        }, timeout).then((frame) => {
+            if (frame) {
+                return Object.assign(Object.assign({}, frame), { data: value });
+            }
+        });
     }
     reportServerId(unit, timeout = this.timeout) {
         const fc = 0x11;
-        this.physicalLayer.write(this.applicationLayer.encode({
-            unit,
-            fc,
-            data: [],
-        }));
-        if (unit !== 0) {
-            return this.waitResponse(timeout, (frame) => {
-                if (frame.unit === unit && frame.fc === fc && frame.data.length >= 3) {
-                    const byteCount = frame.data[0];
-                    if (frame.data.length - 1 === byteCount) {
-                        return {
-                            serverId: frame.data[1],
-                            runIndicatorStatus: frame.data[2] === 0xff,
-                            additionalData: frame.data.slice(3),
-                        };
+        return this.waitResponse({
+            data: this.applicationLayer.encode({
+                unit,
+                fc,
+                data: [],
+            }),
+            broadcast: unit === 0,
+        }, {
+            preCheck: [
+                (frame) => frame.unit === unit && frame.fc === fc,
+                (frame) => {
+                    if (frame.data.length >= 3) {
+                        return 1 + frame.data[0];
                     }
-                }
-            });
-        }
+                },
+            ],
+        }, timeout).then((frame) => {
+            if (frame) {
+                return Object.assign(Object.assign({}, frame), { data: {
+                        serverId: frame.data[1],
+                        runIndicatorStatus: frame.data[2] === 0xff,
+                        additionalData: frame.data.slice(3),
+                    } });
+            }
+        });
     }
     maskWriteRegister(unit, address, andMask, orMask, timeout = this.timeout) {
         const fc = 0x16;
@@ -1172,18 +1322,20 @@ class ModbusMaster extends EventEmitter {
         bufferTx.writeUInt16BE(address, 0);
         bufferTx.writeUInt16BE(andMask, 2);
         bufferTx.writeUInt16BE(orMask, 4);
-        this.physicalLayer.write(this.applicationLayer.encode({
-            unit,
-            fc,
-            data: Array.from(bufferTx),
-        }));
-        if (unit !== 0) {
-            return this.waitResponse(timeout, (frame) => {
-                if (frame.unit === unit && frame.fc === fc && frame.data.length === 6 && frame.data.every((v, i) => v === bufferTx[i])) {
-                    return { andMask, orMask };
-                }
-            });
-        }
+        return this.waitResponse({
+            data: this.applicationLayer.encode({
+                unit,
+                fc,
+                data: Array.from(bufferTx),
+            }),
+            broadcast: unit === 0,
+        }, {
+            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 6, (frame) => frame.data.every((v, i) => v === bufferTx[i])],
+        }, timeout).then((frame) => {
+            if (frame) {
+                return Object.assign(Object.assign({}, frame), { data: { andMask, orMask } });
+            }
+        });
     }
     readAndWriteMultipleRegisters(unit, read, write, timeout = this.timeout) {
         const fc = 0x17;
@@ -1197,73 +1349,104 @@ class ModbusMaster extends EventEmitter {
         write.value.forEach((v, i) => {
             bufferTx.writeUInt16BE(v, 9 + i * 2);
         });
-        this.physicalLayer.write(this.applicationLayer.encode({
-            unit,
-            fc,
-            data: Array.from(bufferTx),
-        }));
-        if (unit !== 0) {
-            return this.waitResponse(timeout, (frame) => {
-                if (frame.unit === unit && frame.fc === fc && frame.data.length === 1 + byteCount && frame.data[0] === byteCount) {
-                    const bufferRx = Buffer.from(frame.data.slice(1));
-                    return Array.from({ length: read.length }).map((_, index) => bufferRx.readUInt16BE(index * 2));
-                }
-            });
-        }
+        return this.waitResponse({
+            data: this.applicationLayer.encode({
+                unit,
+                fc,
+                data: Array.from(bufferTx),
+            }),
+            broadcast: unit === 0,
+        }, {
+            preCheck: [(frame) => frame.unit === unit && frame.fc === fc, () => 1 + byteCount, (frame) => frame.data[0] === byteCount],
+        }, timeout).then((frame) => {
+            if (frame) {
+                const bufferRx = Buffer.from(frame.data.slice(1));
+                return Object.assign(Object.assign({}, frame), { data: Array.from({ length: read.length }).map((_, index) => bufferRx.readUInt16BE(index * 2)) });
+            }
+        });
     }
     readDeviceIdentification(unit, readDeviceIDCode, objectId, timeout = this.timeout) {
         const fc = 0x2b;
-        this.physicalLayer.write(this.applicationLayer.encode({
-            unit,
-            fc,
-            data: [0x0e, readDeviceIDCode, objectId],
-        }));
-        if (unit !== 0) {
-            return this.waitResponse(timeout, (frame) => {
-                if (frame.unit === unit &&
-                    frame.fc === fc &&
-                    frame.data.length >= 6 &&
-                    frame.data[0] === 0x0e &&
-                    frame.data[1] === readDeviceIDCode) {
-                    const conformityLevel = frame.data[2];
-                    const moreFollows = frame.data[3] === 0xff;
-                    const nextObjectId = frame.data[4];
-                    const objectLength = frame.data[5];
-                    const objects = [];
-                    let object = [];
-                    for (const v of frame.data.slice(6)) {
-                        switch (object.length) {
-                            case 0:
-                            case 1: {
-                                object.push(v);
-                                break;
+        return this.waitResponse({
+            data: this.applicationLayer.encode({
+                unit,
+                fc,
+                data: [0x0e, readDeviceIDCode, objectId],
+            }),
+            broadcast: unit === 0,
+        }, {
+            preCheck: [
+                (frame) => frame.unit === unit && frame.fc === fc,
+                (frame) => {
+                    if (frame.data.length >= 6) {
+                        if (frame.data[0] === 0x0e && frame.data[1] === readDeviceIDCode) {
+                            const objects = [];
+                            let object = [];
+                            for (const v of frame.data.slice(6)) {
+                                switch (object.length) {
+                                    case 0:
+                                    case 1: {
+                                        object.push(v);
+                                        break;
+                                    }
+                                    case 2: {
+                                        object.push([v]);
+                                        break;
+                                    }
+                                    case 3: {
+                                        object[2].push(v);
+                                        if (object[1] === object[2].length) {
+                                            objects.push(2 + object[1]);
+                                            object = [];
+                                        }
+                                        break;
+                                    }
+                                }
                             }
-                            case 2: {
-                                object.push([v]);
-                                break;
-                            }
-                            case 3: {
-                                object[2].push(v);
-                                break;
+                            if (objects.length === frame.data[5]) {
+                                return 6 + objects.reduce((previous, current) => previous + current, 0);
                             }
                         }
-                        if (object.length === 3 && object[1] === object[2].length) {
-                            objects.push({ id: object[0], value: Buffer.from(object[2]).toString() });
-                            object = [];
+                        else {
+                            return false;
                         }
                     }
-                    if (objects.length === objectLength) {
-                        return {
-                            readDeviceIDCode,
-                            conformityLevel,
-                            moreFollows,
-                            nextObjectId,
-                            objects,
-                        };
+                },
+            ],
+        }, timeout).then((frame) => {
+            if (frame) {
+                const objects = [];
+                let object = [];
+                for (const v of frame.data.slice(6)) {
+                    switch (object.length) {
+                        case 0:
+                        case 1: {
+                            object.push(v);
+                            break;
+                        }
+                        case 2: {
+                            object.push([v]);
+                            break;
+                        }
+                        case 3: {
+                            object[2].push(v);
+                            if (object[1] === object[2].length) {
+                                objects.push({ id: object[0], value: Buffer.from(object[2]).toString() });
+                                object = [];
+                            }
+                            break;
+                        }
                     }
                 }
-            });
-        }
+                return Object.assign(Object.assign({}, frame), { data: {
+                        readDeviceIDCode,
+                        conformityLevel: frame.data[2],
+                        moreFollows: frame.data[3] === 0xff,
+                        nextObjectId: frame.data[4],
+                        objects,
+                    } });
+            }
+        });
     }
     open(...args) {
         return this.physicalLayer.open(...args);
@@ -1278,6 +1461,38 @@ class ModbusMaster extends EventEmitter {
     }
 }
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
 class ModbusSlave extends EventEmitter {
     get isOpen() {
         return this.physicalLayer.isOpen;
@@ -1318,7 +1533,15 @@ class ModbusSlave extends EventEmitter {
             if (!(frame.unit === 0x00 || frame.unit === this.unit)) {
                 return;
             }
-            const response = frame.unit === 0x00 ? () => Promise.resolve() : _response;
+            const response = (data) => __awaiter(this, void 0, void 0, function* () {
+                if (frame.unit === 0x00) {
+                    return;
+                }
+                try {
+                    yield _response(data);
+                }
+                catch (error) { }
+            });
             if (model.interceptor) {
                 try {
                     const data = yield model.interceptor(frame.fc, frame.data);