@willieee802/zigbee-herdsman 0.34.3 → 0.48.1

package/dist/adapter/ember/uart/ash.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UartAsh = exports.AshEvents = void 0;
 /* istanbul ignore file */
-const debug_1 = __importDefault(require("debug"));
 const stream_1 = require("stream");
 const net_1 = require("net");
 const socketPortUtils_1 = __importDefault(require("../../socketPortUtils"));
@@ -18,7 +17,8 @@ const queues_1 = require("./queues");
 const writer_1 = require("./writer");
 const parser_1 = require("./parser");
 const utils_1 = require("../../../utils");
-const debug = (0, debug_1.default)('zigbee-herdsman:adapter:ember:uart:ash');
+const logger_1 = require("../../../utils/logger");
+const NS = 'zh:ember:uart:ash';
 /** ASH get rflag in control byte */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const ashGetRFlag = (ctrl) => ((ctrl & consts_1.ASH_RFLAG_MASK) >> consts_1.ASH_RFLAG_BIT);
@@ -31,12 +31,10 @@ const ashGetFrmNum = (ctrl) => ((ctrl & consts_1.ASH_FRMNUM_MASK) >> consts_1.AS
 const ashGetACKNum = (ctrl) => ((ctrl & consts_1.ASH_ACKNUM_MASK) >> consts_1.ASH_ACKNUM_BIT);
 var AshEvents;
 (function (AshEvents) {
-    /** When the host detects a fatal error */
-    AshEvents["hostError"] = "hostError";
-    /** When the NCP reports a fatal error */
-    AshEvents["ncpError"] = "ncpError";
+    /** When the ASH protocol detects a fatal error (bubbles up to restart adapter). */
+    AshEvents["FATAL_ERROR"] = "fatalError";
     /** When a frame has been parsed and queued in the rxQueue. */
-    AshEvents["frame"] = "frame";
+    AshEvents["FRAME"] = "frame";
 })(AshEvents || (exports.AshEvents = AshEvents = {}));
 var SendState;
 (function (SendState) {
@@ -207,7 +205,12 @@ class UartAsh extends stream_1.EventEmitter {
         if (this.closing) {
             return false;
         }
-        return this.serialPort != null ? this.serialPort.isOpen : !this.socketPort?.closed;
+        if (socketPortUtils_1.default.isTcpPath(this.portOptions.path)) {
+            return this.socketPort && !this.socketPort.closed;
+        }
+        else {
+            return this.serialPort && this.serialPort.isOpen;
+        }
     }
     /**
      * Get max wait time before response is considered timed out.
@@ -248,10 +251,6 @@ class UartAsh extends stream_1.EventEmitter {
      */
     initVariables() {
         this.closing = false;
-        this.serialPort = null;
-        this.socketPort = null;
-        this.writer = null;
-        this.parser = null;
         this.txSHBuffer = Buffer.alloc(consts_1.SH_TX_BUFFER_LEN);
         this.rxSHBuffer = Buffer.alloc(consts_1.SH_RX_BUFFER_LEN);
         this.ackTimer = 0;
@@ -338,11 +337,13 @@ class UartAsh extends stream_1.EventEmitter {
             this.rxFree.freeBuffer(this.rxPool[i] = new queues_1.EzspBuffer());
         }
     }
+    /**
+     * Init the serial or socket port and hook parser/writer.
+     * NOTE: This is the only function that throws/rejects in the ASH layer (caught by resetNcp and turned into an EzspStatus).
+     */
     async initPort() {
+        await this.closePort(); // will do nothing if nothing's open
         if (!socketPortUtils_1.default.isTcpPath(this.portOptions.path)) {
-            if (this.serialPort != null) {
-                this.serialPort.close();
-            }
             const serialOpts = {
                 path: this.portOptions.path,
                 baudRate: typeof this.portOptions.baudRate === 'number' ? this.portOptions.baudRate : 115200,
@@ -355,7 +356,7 @@ class UartAsh extends stream_1.EventEmitter {
             };
             // enable software flow control if RTS/CTS not enabled in config
             if (!serialOpts.rtscts) {
-                debug(`RTS/CTS config is off, enabling software flow control.`);
+                logger_1.logger.info(`RTS/CTS config is off, enabling software flow control.`, NS);
                 serialOpts.xon = true;
                 serialOpts.xoff = true;
             }
@@ -364,7 +365,7 @@ class UartAsh extends stream_1.EventEmitter {
                 //@ts-expect-error Jest testing
                 serialOpts.binding = this.portOptions.binding;
             }
-            debug(`Opening SerialPort with ${JSON.stringify(serialOpts)}`);
+            logger_1.logger.debug(`Opening serial port with ${JSON.stringify(serialOpts)}`, NS);
             this.serialPort = new serialPort_1.SerialPort(serialOpts);
             this.writer = new writer_1.AshWriter({ highWaterMark: CONFIG_HIGHWATER_MARK });
             this.writer.pipe(this.serialPort);
@@ -373,7 +374,7 @@ class UartAsh extends stream_1.EventEmitter {
             this.parser.on('data', this.onFrame.bind(this));
             try {
                 await this.serialPort.asyncOpen();
-                debug('Serialport opened');
+                logger_1.logger.info(`Serial port opened`, NS);
                 this.serialPort.once('close', this.onPortClose.bind(this));
                 this.serialPort.on('error', this.onPortError.bind(this));
             }
@@ -383,11 +384,8 @@ class UartAsh extends stream_1.EventEmitter {
             }
         }
         else {
-            if (this.socketPort != null) {
-                this.socketPort.destroy();
-            }
             const info = socketPortUtils_1.default.parseTcpPath(this.portOptions.path);
-            debug(`Opening TCP socket with ${info.host}:${info.port}`);
+            logger_1.logger.debug(`Opening TCP socket with ${info.host}:${info.port}`, NS);
             this.socketPort = new net_1.Socket();
             this.socketPort.setNoDelay(true);
             this.socketPort.setKeepAlive(true, 15000);
@@ -402,10 +400,10 @@ class UartAsh extends stream_1.EventEmitter {
                     reject(err);
                 };
                 this.socketPort.on('connect', () => {
-                    debug('Socket connected');
+                    logger_1.logger.debug(`Socket connected`, NS);
                 });
                 this.socketPort.on('ready', async () => {
-                    debug('Socket ready');
+                    logger_1.logger.info(`Socket ready`, NS);
                     this.socketPort.removeListener('error', openError);
                     this.socketPort.once('close', this.onPortClose.bind(this));
                     this.socketPort.on('error', this.onPortError.bind(this));
@@ -421,16 +419,15 @@ class UartAsh extends stream_1.EventEmitter {
      * @param err A boolean for Socket, an Error for serialport
      */
     async onPortClose(err) {
-        console.log(`Port closed. Error? ${err ?? 'no'}`);
+        logger_1.logger.info(`Port closed. Error? ${err ?? 'no'}`, NS);
     }
     /**
      * Handle port error
      * @param error
      */
     async onPortError(error) {
-        console.log(`Port error: ${error}`);
-        this.hostDisconnect(enums_1.EzspStatus.ERROR_SERIAL_INIT);
-        await this.stop();
+        logger_1.logger.info(`Port error: ${error}`, NS);
+        this.emit(AshEvents.FATAL_ERROR, enums_1.EzspStatus.ERROR_SERIAL_INIT);
     }
     /**
      * Handle received frame from AshParser.
@@ -442,7 +439,7 @@ class UartAsh extends stream_1.EventEmitter {
             // ignore the cancel before RSTACK
             if (this.flags & Flag.CONNECTED) {
                 this.counters.rxCancelled += 1;
-                console.warn(`Frame(s) in progress cancelled in [${buffer.toString('hex')}]`);
+                logger_1.logger.warning(`Frame(s) in progress cancelled in [${buffer.toString('hex')}]`, NS);
             }
             // get rid of everything up to the CAN flag and start reading frame from there, no need to loop through bytes in vain
             buffer = buffer.subarray(iCAN + 1);
@@ -450,15 +447,14 @@ class UartAsh extends stream_1.EventEmitter {
         if (!buffer.length) {
             // skip any CANCEL that results in empty frame (have yet to see one, but just in case...)
             // shouldn't happen for any other reason, unless receiving bad stuff from port?
-            debug(`Received empty frame. Skipping.`);
+            logger_1.logger.debug(`Received empty frame. Skipping.`, NS);
             return;
         }
         const status = this.receiveFrame(buffer);
-        if (status === enums_1.EzspStatus.SUCCESS) {
-            // ?
-        }
-        else if ((status !== enums_1.EzspStatus.ASH_IN_PROGRESS) && (status !== enums_1.EzspStatus.NO_RX_DATA)) {
-            throw new Error(enums_1.EzspStatus[status]);
+        if ((status !== enums_1.EzspStatus.SUCCESS) && (status !== enums_1.EzspStatus.ASH_IN_PROGRESS) && (status !== enums_1.EzspStatus.NO_RX_DATA)) {
+            logger_1.logger.error(`Error while parsing received frame, status=${enums_1.EzspStatus[status]}.`, NS);
+            this.emit(AshEvents.FATAL_ERROR, enums_1.EzspStatus.HOST_FATAL_ERROR);
+            return;
         }
     }
     /**
@@ -470,24 +466,34 @@ class UartAsh extends stream_1.EventEmitter {
      * - EzspStatus.ASH_NCP_FATAL_ERROR)
      */
     async start() {
-        if (this.closing || (this.flags & Flag.CONNECTED)) {
+        if (!this.portOpen || (this.flags & Flag.CONNECTED)) {
             return enums_1.EzspStatus.ERROR_INVALID_CALL;
         }
-        console.log(`======== ASH starting ========`);
-        if (this.serialPort != null) {
-            this.serialPort.flush(); // clear read/write buffers
+        logger_1.logger.info(`======== ASH starting ========`, NS);
+        try {
+            if (this.serialPort != null) {
+                await this.serialPort.asyncFlush(); // clear read/write buffers
+            }
+            else {
+                // XXX: Socket equiv?
+            }
         }
-        else {
-            // XXX: Socket equiv?
+        catch (err) {
+            logger_1.logger.error(`Error while flushing before start: ${err}`, NS);
         }
-        this.sendExec();
-        // block til RSTACK or timeout
+        // block til RSTACK, fatal error or timeout
+        // NOTE: on average, this seems to take around 1000ms when successful
         for (let i = 0; i < CONFIG_TIME_RST; i += CONFIG_TIME_RST_CHECK) {
+            this.sendExec();
             if ((this.flags & Flag.CONNECTED)) {
-                console.log(`======== ASH started ========`);
+                logger_1.logger.info(`======== ASH started ========`, NS);
                 return enums_1.EzspStatus.SUCCESS;
             }
-            debug(`Waiting for RSTACK... ${i}/${CONFIG_TIME_RST}`);
+            else if ((this.hostError !== enums_1.EzspStatus.NO_ERROR) || (this.ncpError !== enums_1.EzspStatus.NO_ERROR)) {
+                // don't wait for inevitable fail, bail early, let retry logic in EZSP layer do its thing
+                break;
+            }
+            logger_1.logger.debug(`Waiting for RSTACK... ${i}/${CONFIG_TIME_RST}`, NS);
             await (0, utils_1.Wait)(CONFIG_TIME_RST_CHECK);
         }
         return enums_1.EzspStatus.HOST_FATAL_ERROR;
@@ -497,24 +503,29 @@ class UartAsh extends stream_1.EventEmitter {
      */
     async stop() {
         this.closing = true;
-        this.printCounters();
+        this.logCounters();
+        await this.closePort();
+        this.initVariables();
+        logger_1.logger.info(`======== ASH stopped ========`, NS);
+    }
+    /**
+     * Close port and remove listeners.
+     * Does nothing if port not defined/open.
+     */
+    async closePort() {
         if (this.serialPort?.isOpen) {
             try {
                 await this.serialPort.asyncFlushAndClose();
-                debug(`Serial port closed.`);
             }
             catch (err) {
-                debug(`Failed to close serial port ${err}.`);
+                logger_1.logger.error(`Failed to close serial port ${err}.`, NS);
             }
             this.serialPort.removeAllListeners();
         }
         else if (this.socketPort != null && !this.socketPort.closed) {
             this.socketPort.destroy();
             this.socketPort.removeAllListeners();
-            debug(`Socket port closed.`);
         }
-        this.initVariables();
-        console.log(`======== ASH stopped ========`);
     }
     /**
      * Initializes the ASH serial port and (if enabled) resets the NCP.
@@ -530,16 +541,19 @@ class UartAsh extends stream_1.EventEmitter {
         if (this.closing) {
             return enums_1.EzspStatus.ERROR_INVALID_CALL;
         }
-        console.log(`======== ASH NCP reset ========`);
+        logger_1.logger.info(`======== ASH NCP reset ========`, NS);
         this.initVariables();
         let status;
         // ask ncp to reset itself using RST frame
         try {
-            await this.initPort();
+            if (!this.portOpen) {
+                await this.initPort();
+            }
             this.flags = Flag.RST | Flag.CAN;
             return enums_1.EzspStatus.SUCCESS;
         }
         catch (err) {
+            logger_1.logger.error(`Failed to init port with error ${err}`, NS);
             this.hostError = status;
             return enums_1.EzspStatus.HOST_FATAL_ERROR;
         }
@@ -606,7 +620,7 @@ class UartAsh extends stream_1.EventEmitter {
                 if (this.ackRx !== expectedFrm) {
                     this.counters.rxAckTimeouts += 1;
                     this.adjustAckPeriod(true);
-                    debug(`Timer expired waiting for ACK for ${expectedFrm}, current=${this.ackRx}`);
+                    logger_1.logger.debug(`Timer expired waiting for ACK for ${expectedFrm}, current=${this.ackRx}`, NS);
                     if (++this.timeouts >= consts_1.ASH_MAX_TIMEOUTS) {
                         this.hostDisconnect(enums_1.EzspStatus.ASH_ERROR_TIMEOUTS);
                         return;
@@ -663,18 +677,18 @@ class UartAsh extends stream_1.EventEmitter {
                         len = 1;
                         this.flags &= ~(Flag.RST | Flag.NAK | Flag.ACK);
                         this.sendState = SendState.SHFRAME;
-                        debug(`---> [FRAME type=RST]`);
+                        logger_1.logger.debug(`---> [FRAME type=RST]`, NS);
                     }
                     else if (this.flags & (Flag.NAK | Flag.ACK)) {
                         if (this.flags & Flag.NAK) {
                             this.txSHBuffer[0] = enums_2.AshFrameType.NAK + (this.frmRx << consts_1.ASH_ACKNUM_BIT);
                             this.flags &= ~(Flag.NRTX | Flag.NAK | Flag.ACK);
-                            debug(`---> [FRAME type=NAK frmRx=${this.frmRx}]`);
+                            logger_1.logger.debug(`---> [FRAME type=NAK frmRx=${this.frmRx}]`, NS);
                         }
                         else {
                             this.txSHBuffer[0] = enums_2.AshFrameType.ACK + (this.frmRx << consts_1.ASH_ACKNUM_BIT);
                             this.flags &= ~(Flag.NRTX | Flag.ACK);
-                            debug(`---> [FRAME type=ACK frmRx=${this.frmRx}]`);
+                            logger_1.logger.debug(`---> [FRAME type=ACK frmRx=${this.frmRx}]`, NS);
                         }
                         if (this.flags & Flag.NR) {
                             this.txSHBuffer[0] |= consts_1.ASH_NFLAG_MASK;
@@ -691,7 +705,7 @@ class UartAsh extends stream_1.EventEmitter {
                         len = buffer.len + 1;
                         this.txSHBuffer[0] = enums_2.AshFrameType.DATA | (this.frmReTx << consts_1.ASH_FRMNUM_BIT) | (this.frmRx << consts_1.ASH_ACKNUM_BIT) | consts_1.ASH_RFLAG_MASK;
                         this.sendState = SendState.RETX_DATA;
-                        debug(`---> [FRAME type=DATA_RETX frmReTx=${this.frmReTx} frmRx=${this.frmRx}]`);
+                        logger_1.logger.debug(`---> [FRAME type=DATA_RETX frmReTx=${this.frmReTx} frmRx=${this.frmRx}]`, NS);
                     }
                     else if (this.ackTx != this.frmRx) {
                         // An ACK should be generated
@@ -705,7 +719,7 @@ class UartAsh extends stream_1.EventEmitter {
                         this.counters.txData += (len - 1);
                         this.txSHBuffer[0] = enums_2.AshFrameType.DATA | (this.frmTx << consts_1.ASH_FRMNUM_BIT) | (this.frmRx << consts_1.ASH_ACKNUM_BIT);
                         this.sendState = SendState.TX_DATA;
-                        debug(`---> [FRAME type=DATA frmTx=${this.frmTx} frmRx=${this.frmRx}]`);
+                        logger_1.logger.debug(`---> [FRAME type=DATA frmTx=${this.frmTx} frmRx=${this.frmRx}]`, NS);
                     }
                     else {
                         // Otherwise there's nothing to send
@@ -792,27 +806,28 @@ class UartAsh extends stream_1.EventEmitter {
             case enums_1.EzspStatus.ASH_BAD_CRC:
                 this.counters.rxCrcErrors += 1;
                 this.rejectFrame();
-                console.error(`Received frame with CRC error`);
+                logger_1.logger.error(`Received frame with CRC error`, NS);
                 return enums_1.EzspStatus.NO_RX_DATA;
             case enums_1.EzspStatus.ASH_COMM_ERROR:
                 this.counters.rxCommErrors += 1;
                 this.rejectFrame();
-                console.error(`Received frame with comm error`);
+                logger_1.logger.error(`Received frame with comm error`, NS);
                 return enums_1.EzspStatus.NO_RX_DATA;
             case enums_1.EzspStatus.ASH_TOO_SHORT:
                 this.counters.rxTooShort += 1;
                 this.rejectFrame();
-                console.error(`Received frame shorter than minimum`);
+                logger_1.logger.error(`Received frame shorter than minimum`, NS);
                 return enums_1.EzspStatus.NO_RX_DATA;
             case enums_1.EzspStatus.ASH_TOO_LONG:
                 this.counters.rxTooLong += 1;
                 this.rejectFrame();
-                console.error(`Received frame longer than maximum`);
+                logger_1.logger.error(`Received frame longer than maximum`, NS);
                 return enums_1.EzspStatus.NO_RX_DATA;
             case enums_1.EzspStatus.ASH_ERROR_XON_XOFF:
                 return this.hostDisconnect(status);
             default:
-                throw new Error(`Unhandled error while receiving frame.`);
+                logger_1.logger.error(`Unhandled error while receiving frame, status=${enums_1.EzspStatus[status]}.`, NS);
+                return this.hostDisconnect(enums_1.EzspStatus.HOST_FATAL_ERROR);
         }
         // Got a complete frame - validate its control and length.
         // On an error the type returned will be TYPE_INVALID.
@@ -830,7 +845,7 @@ class UartAsh extends stream_1.EventEmitter {
             this.freeNonNullRxBuffer();
         }
         const frameTypeStr = enums_2.AshFrameType[frameType];
-        debug(`<--- [FRAME type=${frameTypeStr}]`);
+        logger_1.logger.debug(`<--- [FRAME type=${frameTypeStr}]`, NS);
         this.countFrame(false);
         // Process frames received while not in the connected state -
         // ignore everything except RSTACK and ERROR frames
@@ -850,11 +865,11 @@ class UartAsh extends stream_1.EventEmitter {
                 this.timeouts = 0;
                 this.setAckPeriod(CONFIG_ACK_TIME_INIT);
                 this.flags = Flag.CONNECTED | Flag.ACK;
-                console.log(`======== ASH connected ========`);
+                logger_1.logger.info(`======== ASH connected ========`, NS);
                 return enums_1.EzspStatus.SUCCESS;
             }
             else if (frameType === enums_2.AshFrameType.ERROR) {
-                console.error(`Received ERROR from NCP while connecting, with code=${enums_2.NcpFailedCode[this.rxSHBuffer[2]]}.`);
+                logger_1.logger.error(`Received ERROR from NCP while connecting, with code=${enums_2.NcpFailedCode[this.rxSHBuffer[2]]}.`, NS);
                 return this.ncpDisconnect(enums_1.EzspStatus.ASH_NCP_FATAL_ERROR);
             }
             return enums_1.EzspStatus.ASH_IN_PROGRESS;
@@ -862,10 +877,10 @@ class UartAsh extends stream_1.EventEmitter {
         // Connected - process the ackNum in ACK, NAK and DATA frames
         if ((frameType === enums_2.AshFrameType.DATA) || (frameType === enums_2.AshFrameType.ACK) || (frameType === enums_2.AshFrameType.NAK)) {
             ackNum = ashGetACKNum(this.rxSHBuffer[0]);
-            debug(`<--- [FRAME type=${frameTypeStr} ackNum=${ackNum}]`);
+            logger_1.logger.debug(`<--- [FRAME type=${frameTypeStr} ackNum=${ackNum}]`, NS);
             if (!(0, math_1.withinRange)(this.ackRx, ackNum, this.frmTx)) {
                 this.counters.rxBadAckNumber += 1;
-                debug(`<-x- [FRAME type=${frameTypeStr} ackNum=${ackNum}] Invalid ACK num; not within <${this.ackRx}-${this.frmTx}>`);
+                logger_1.logger.debug(`<-x- [FRAME type=${frameTypeStr} ackNum=${ackNum}] Invalid ACK num; not within <${this.ackRx}-${this.frmTx}>`, NS);
                 frameType = enums_2.AshFrameType.INVALID;
             }
             else if (ackNum !== this.ackRx) {
@@ -899,7 +914,7 @@ class UartAsh extends stream_1.EventEmitter {
                     if (this.rxDataBuffer == null) {
                         // valid frame but no memory?
                         this.counters.rxNoBuffer += 1;
-                        debug(`<-x- ${frameStr} No buffer available`);
+                        logger_1.logger.debug(`<-x- ${frameStr} No buffer available`, NS);
                         this.rejectFrame();
                         return enums_1.EzspStatus.NO_RX_SPACE;
                     }
@@ -911,10 +926,10 @@ class UartAsh extends stream_1.EventEmitter {
                     this.frmRx = (0, math_1.inc8)(this.frmRx);
                     this.randomizeBuffer(this.rxDataBuffer.data, this.rxDataBuffer.len); // IN/OUT data
                     this.rxQueue.addTail(this.rxDataBuffer); // add frame to receive queue
-                    debug(`<--- ${frameStr} Added to rxQueue`);
+                    logger_1.logger.debug(`<--- ${frameStr} Added to rxQueue`, NS);
                     this.counters.rxData += this.rxDataBuffer.len;
                     setImmediate(() => {
-                        this.emit(AshEvents.frame);
+                        this.emit(AshEvents.FRAME);
                     });
                     return enums_1.EzspStatus.SUCCESS;
                 }
@@ -929,7 +944,7 @@ class UartAsh extends stream_1.EventEmitter {
                         // 1st OOS? then set REJ, send NAK
                         if ((this.flags & Flag.REJ) === 0) {
                             this.counters.rxOutOfSequence += 1;
-                            debug(`<-x- ${frameStr} Out of sequence: expected ${this.frmRx}; got ${frmNum}.`);
+                            logger_1.logger.debug(`<-x- ${frameStr} Out of sequence: expected ${this.frmRx}; got ${frmNum}.`, NS);
                         }
                         this.rejectFrame();
                     }
@@ -944,16 +959,16 @@ class UartAsh extends stream_1.EventEmitter {
                 break;
             case enums_2.AshFrameType.RSTACK:
                 // unexpected ncp reset
-                console.error(`Received unexpected reset from NCP, with reason=${enums_2.NcpFailedCode[this.rxSHBuffer[2]]}.`);
+                logger_1.logger.error(`Received unexpected reset from NCP, with reason=${enums_2.NcpFailedCode[this.rxSHBuffer[2]]}.`, NS);
                 this.ncpError = enums_1.EzspStatus.ASH_NCP_FATAL_ERROR;
                 return this.hostDisconnect(enums_1.EzspStatus.ASH_ERROR_NCP_RESET);
             case enums_2.AshFrameType.ERROR:
                 // ncp error
-                console.error(`Received ERROR from NCP, with code=${enums_2.NcpFailedCode[this.rxSHBuffer[2]]}.`);
+                logger_1.logger.error(`Received ERROR from NCP, with code=${enums_2.NcpFailedCode[this.rxSHBuffer[2]]}.`, NS);
                 return this.ncpDisconnect(enums_1.EzspStatus.ASH_NCP_FATAL_ERROR);
             case enums_2.AshFrameType.INVALID:
                 // reject invalid frames
-                debug(`<-x- [FRAME type=${frameTypeStr}] Rejecting. ${this.rxSHBuffer.toString('hex')}`);
+                logger_1.logger.debug(`<-x- [FRAME type=${frameTypeStr}] Rejecting. ${this.rxSHBuffer.toString('hex')}`, NS);
                 this.rejectFrame();
                 break;
         }
@@ -1073,12 +1088,11 @@ class UartAsh extends stream_1.EventEmitter {
             // Set/clear NR flag based on the number of buffers free
             if (this.rxFree.length < CONFIG_NR_LOW_LIMIT) {
                 this.flags |= Flag.NR;
-                debug(`NOT READY - Signaling NCP`);
+                logger_1.logger.warning(`NOT READY - Signaling NCP`, NS);
             }
             else if (this.rxFree.length > CONFIG_NR_HIGH_LIMIT) {
                 this.flags &= ~Flag.NR;
                 this.stopNrTimer(); // needed??
-                // debug(`READY - Signaling NCP`);// spams-a-lot
             }
             // Force an ACK (or possibly NAK) if we need to send an updated nFlag
             // due to either a changed NR status or to refresh a set nFlag
@@ -1109,8 +1123,7 @@ class UartAsh extends stream_1.EventEmitter {
     hostDisconnect(error) {
         this.flags = 0;
         this.hostError = error;
-        console.error(`ASH disconnected: ${enums_1.EzspStatus[error]} | NCP status: ${enums_1.EzspStatus[this.ncpError]}`);
-        this.emit(AshEvents.hostError, error);
+        logger_1.logger.error(`ASH disconnected: ${enums_1.EzspStatus[error]} | NCP status: ${enums_1.EzspStatus[this.ncpError]}`, NS);
         return enums_1.EzspStatus.HOST_FATAL_ERROR;
     }
     /**
@@ -1121,8 +1134,7 @@ class UartAsh extends stream_1.EventEmitter {
     ncpDisconnect(error) {
         this.flags = 0;
         this.ncpError = error;
-        console.error(`ASH disconnected | NCP status: ${enums_1.EzspStatus[this.ncpError]}`);
-        this.emit(AshEvents.ncpError, error);
+        logger_1.logger.error(`ASH disconnected | NCP status: ${enums_1.EzspStatus[this.ncpError]}`, NS);
         return enums_1.EzspStatus.ASH_NCP_FATAL_ERROR;
     }
     /**
@@ -1195,11 +1207,11 @@ class UartAsh extends stream_1.EventEmitter {
         }
         else {
             this.counters.rxBadControl += 1;
-            debug(`Frame illegal control ${control}.`); // EzspStatus.ASH_BAD_CONTROL
+            logger_1.logger.debug(`Frame illegal control ${control}.`, NS); // EzspStatus.ASH_BAD_CONTROL
             return enums_2.AshFrameType.INVALID;
         }
         this.counters.rxBadLength += 1;
-        debug(`Frame illegal length ${len} for control ${control}.`); // EzspStatus.ASH_BAD_LENGTH
+        logger_1.logger.debug(`Frame illegal length ${len} for control ${control}.`, NS); // EzspStatus.ASH_BAD_LENGTH
         return enums_2.AshFrameType.INVALID;
     }
     /**
@@ -1552,32 +1564,69 @@ class UartAsh extends stream_1.EventEmitter {
         }
     }
     /**
-     * Prints counters in a nicely formatted table.
+     * Read and clear ASH layer counters in the same manner as the NCP ones.
+     * @returns
+     */
+    readAndClearCounters() {
+        const counters = [
+            this.counters.txData,
+            this.counters.txAllFrames,
+            this.counters.txDataFrames,
+            this.counters.txAckFrames,
+            this.counters.txNakFrames,
+            this.counters.txReDataFrames,
+            this.counters.txN1Frames,
+            this.counters.txCancelled,
+            this.counters.rxData,
+            this.counters.rxAllFrames,
+            this.counters.rxDataFrames,
+            this.counters.rxAckFrames,
+            this.counters.rxNakFrames,
+            this.counters.rxReDataFrames,
+            this.counters.rxN1Frames,
+            this.counters.rxCancelled,
+            this.counters.rxCrcErrors,
+            this.counters.rxCommErrors,
+            this.counters.rxTooShort,
+            this.counters.rxTooLong,
+            this.counters.rxBadControl,
+            this.counters.rxBadLength,
+            this.counters.rxBadAckNumber,
+            this.counters.rxNoBuffer,
+            this.counters.rxDuplicates,
+            this.counters.rxOutOfSequence,
+            this.counters.rxAckTimeouts,
+        ];
+        for (const c in this.counters) {
+            this.counters[c] = 0;
+        }
+        return counters;
+    }
+    /**
+     * Log counters (pretty-formatted) as they are since last time they were cleared.
+     * Used on ASH layer stop to get 'pre-stop state'.
      */
-    printCounters() {
-        console.table({
-            "Total frames": { "Received": this.counters.rxAllFrames, "Transmitted": this.counters.txAllFrames },
-            "Cancelled": { "Received": this.counters.rxCancelled, "Transmitted": this.counters.txCancelled },
-            "DATA frames": { "Received": this.counters.rxDataFrames, "Transmitted": this.counters.txDataFrames },
-            "DATA bytes": { "Received": this.counters.rxData, "Transmitted": this.counters.txData },
-            "Retry frames": { "Received": this.counters.rxReDataFrames, "Transmitted": this.counters.txReDataFrames },
-            "ACK frames": { "Received": this.counters.rxAckFrames, "Transmitted": this.counters.txAckFrames },
-            "NAK frames": { "Received": this.counters.rxNakFrames, "Transmitted": this.counters.txNakFrames },
-            "nRdy frames": { "Received": this.counters.rxN1Frames, "Transmitted": this.counters.txN1Frames },
-        });
-        console.table({
-            "CRC errors": { "Received": this.counters.rxCrcErrors },
-            "Comm errors": { "Received": this.counters.rxCommErrors },
-            "Length < minimum": { "Received": this.counters.rxTooShort },
-            "Length > maximum": { "Received": this.counters.rxTooLong },
-            "Bad controls": { "Received": this.counters.rxBadControl },
-            "Bad lengths": { "Received": this.counters.rxBadLength },
-            "Bad ACK numbers": { "Received": this.counters.rxBadAckNumber },
-            "Out of buffers": { "Received": this.counters.rxNoBuffer },
-            "Retry dupes": { "Received": this.counters.rxDuplicates },
-            "Out of sequence": { "Received": this.counters.rxOutOfSequence },
-            "ACK timeouts": { "Received": this.counters.rxAckTimeouts },
-        });
+    logCounters() {
+        logger_1.logger.info(`ASH COUNTERS since last clear:`, NS);
+        logger_1.logger.info(`  Total frames: RX=${this.counters.rxAllFrames}, TX=${this.counters.txAllFrames}`, NS);
+        logger_1.logger.info(`  Cancelled   : RX=${this.counters.rxCancelled}, TX=${this.counters.txCancelled}`, NS);
+        logger_1.logger.info(`  DATA frames : RX=${this.counters.rxDataFrames}, TX=${this.counters.txDataFrames}`, NS);
+        logger_1.logger.info(`  DATA bytes  : RX=${this.counters.rxData}, TX=${this.counters.txData}`, NS);
+        logger_1.logger.info(`  Retry frames: RX=${this.counters.rxReDataFrames}, TX=${this.counters.txReDataFrames}`, NS);
+        logger_1.logger.info(`  ACK frames  : RX=${this.counters.rxAckFrames}, TX=${this.counters.txAckFrames}`, NS);
+        logger_1.logger.info(`  NAK frames  : RX=${this.counters.rxNakFrames}, TX=${this.counters.txNakFrames}`, NS);
+        logger_1.logger.info(`  nRdy frames : RX=${this.counters.rxN1Frames}, TX=${this.counters.txN1Frames}`, NS);
+        logger_1.logger.info(`  CRC errors      : RX=${this.counters.rxCrcErrors}`, NS);
+        logger_1.logger.info(`  Comm errors     : RX=${this.counters.rxCommErrors}`, NS);
+        logger_1.logger.info(`  Length < minimum: RX=${this.counters.rxTooShort}`, NS);
+        logger_1.logger.info(`  Length > maximum: RX=${this.counters.rxTooLong}`, NS);
+        logger_1.logger.info(`  Bad controls    : RX=${this.counters.rxBadControl}`, NS);
+        logger_1.logger.info(`  Bad lengths     : RX=${this.counters.rxBadLength}`, NS);
+        logger_1.logger.info(`  Bad ACK numbers : RX=${this.counters.rxBadAckNumber}`, NS);
+        logger_1.logger.info(`  Out of buffers  : RX=${this.counters.rxNoBuffer}`, NS);
+        logger_1.logger.info(`  Retry dupes     : RX=${this.counters.rxDuplicates}`, NS);
+        logger_1.logger.info(`  Out of sequence : RX=${this.counters.rxOutOfSequence}`, NS);
+        logger_1.logger.info(`  ACK timeouts    : RX=${this.counters.rxAckTimeouts}`, NS);
     }
 }
 exports.UartAsh = UartAsh;