incyclist-devices 1.5.30 → 1.5.32

package/lib/daum/DaumAdapter.js

@@ -217,6 +217,8 @@ class DaumAdapterBase extends device_1.default {
                         clearInterval(this.iv.update);
                     this.iv = undefined;
                 }
+                if (this.bike.stopWorker && typeof (this.bike.stopWorker) === 'function')
+                    this.bike.stopWorker();
                 this.logEvent({ message: 'stop request completed' });
                 this.paused = undefined;
                 resolve(true);

package/lib/daum/classic/DaumClassicAdapter.js

@@ -150,6 +150,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
         let startState = {};
         return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
             try {
+                this.logger.logEvent({ message: 'start attempt', udid: this.udid, isRelaunch, isConnected: this.bike.isConnected() });
                 if (!isRelaunch && !this.bike.isConnected())
                     yield this.bike.saveConnect();
                 yield this.getBike().resetDevice();
@@ -187,6 +188,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                 return data;
             }
             catch (err) {
+                this.logger.logEvent({ message: 'start attempt failed', udid: this.udid, error: err.message });
                 if (startState.checkRunData) {
                     startState = {};
                 }

package/lib/daum/classic/bike.d.ts

@@ -48,6 +48,7 @@ export default class Daum8008 {
     onPortClose(): void;
     onPortError(err: any): void;
     startWorker(): void;
+    stopWorker(): void;
     sendDaum8008CommandfromQueue(): any;
     sendDaum8008Command(logStr: any, payload: any, expected: any, callback?: any, callbackErr?: any, options?: any): void;
     send(cmdInfo: any): void;

package/lib/daum/classic/bike.js

@@ -139,12 +139,7 @@ class Daum8008 {
         }
         var serialPort = this.sp;
         this.closing = true;
-        if (this.bikeCmdWorker !== undefined) {
-            clearInterval(this.bikeCmdWorker);
-            this.bikeCmdWorker = undefined;
-        }
-        if (this.queue !== undefined)
-            this.queue.clear();
+        this.stopWorker();
         let connected = this.connected;
         if (connected) {
             if (serialPort) {
@@ -224,6 +219,16 @@ class Daum8008 {
             this.sendDaum8008CommandfromQueue();
         }, 50);
     }
+    stopWorker() {
+        if (this.queue !== undefined)
+            this.queue.clear();
+        if (this.bikeCmdWorker !== undefined) {
+            clearInterval(this.bikeCmdWorker);
+            this.bikeCmdWorker = undefined;
+        }
+        if (this.queue !== undefined)
+            this.queue.clear();
+    }
     sendDaum8008CommandfromQueue() {
         if (!this.connected || this.closing)
             return;

package/lib/daum/premium/bike.d.ts

@@ -60,16 +60,18 @@ declare class Daum8i {
         waitingForAck: any;
         retry: any;
     };
-    onPortError(error: any): void;
+    onPortError(error: any): Promise<void>;
     errorHandler(): void;
-    saveClose(force?: any): Promise<unknown>;
-    forceClose(updateState?: boolean): void;
-    close(): void;
+    saveClose(force?: any): Promise<void>;
+    forceClose(updateState?: boolean): Promise<void>;
+    closePort(timeout: any): Promise<boolean>;
+    close(): Promise<void>;
     sendTimeout(message: any): void;
     checkForResponse(): boolean;
     getTimeoutValue(cmd?: any): number;
-    onData(data: any): any;
+    onData(data: any, depth?: number): any;
     sendDaum8iCommand(command: any, queryType: any, payload: any): Promise<unknown>;
+    writeDone(): void;
     sendACK(): void;
     sendNAK(): void;
     sendReservedDaum8iCommand(command: ReservedCommands, cmdType: any, data?: Buffer): Promise<any[]>;

package/lib/daum/premium/bike.js

@@ -127,12 +127,7 @@ class Daum8i {
             this.state.commandsInQueue = {};
             try {
                 if (this.sp !== undefined) {
-                    try {
-                        this.sp.removeAllListeners();
-                        yield this.sp.close();
-                    }
-                    catch (err) {
-                    }
+                    yield this.forceClose();
                     this.sp = undefined;
                 }
                 if (this.sp === undefined) {
@@ -148,8 +143,8 @@ class Daum8i {
                         this.logEvent({ message: "creating SerialPort", port: this.port, settings });
                         this.sp = new __SerialPort(this.port, settings);
                     }
-                    this.sp.on('open', this.onPortOpen.bind(this));
-                    this.sp.on('close', this.onPortClose.bind(this));
+                    this.sp.once('open', this.onPortOpen.bind(this));
+                    this.sp.once('close', this.onPortClose.bind(this));
                     this.sp.on('error', (error) => { this.onPortError(error); });
                     this.sp.on('data', (data) => { this.onData(data); });
                 }
@@ -185,13 +180,12 @@ class Daum8i {
             }
             catch (_a) { }
             const tTimeout = Date.now() + TIMEOUT_START;
-            const iv = setInterval(() => {
+            const iv = setInterval(() => __awaiter(this, void 0, void 0, function* () {
                 try {
                     if (this.state.error !== undefined) {
                         clearInterval(iv);
-                        this.forceClose();
+                        yield this.forceClose();
                         reject(this.state.error);
-                        this.state = { opened: false, closed: true, busy: false };
                     }
                     else if (this.isConnected()) {
                         this.state.connecting = false;
@@ -201,14 +195,14 @@ class Daum8i {
                     else {
                         if (Date.now() > tTimeout) {
                             this.state.connecting = false;
-                            this.forceClose();
+                            yield this.forceClose();
                             clearInterval(iv);
                             reject(new Error('timeout'));
                         }
                     }
                 }
-                catch (_a) { }
-            }, 100);
+                catch (_b) { }
+            }), 100);
         }));
     }
     onPortOpen() {
@@ -246,116 +240,128 @@ class Daum8i {
         return { sending: s, busy, writeBusy, opening, connecting, waitingForStart, waitingForEnd, waitingForAck, retry };
     }
     onPortError(error) {
-        this.logEvent({ message: "port error:", port: this.portName, error: error.message, connected: this.connected, state: this.getLogState() });
-        this.error = error;
-        if (this.blocked) {
-            if (!this.state.closed) {
-                try {
-                    if (this.sp) {
-                        this.sp.removeAllListeners();
-                        this.sp.close();
-                        this.sp = undefined;
-                    }
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: "port error:", port: this.portName, error: error.message, connected: this.connected, state: this.getLogState() });
+            this.error = error;
+            if (this.blocked) {
+                if (!this.state.closed) {
+                    yield this.forceClose();
                 }
-                catch (_a) { }
-                this.state = { opened: false, closed: true, busy: false };
-            }
-            return;
-        }
-        if (this.state.closing) {
-            if (error.message === 'Port is not open') {
-                this.state = { opened: false, closed: true, busy: false };
                 return;
             }
-            else {
-                this.forceClose();
+            if (this.state.closing) {
+                if (error.message === 'Port is not open') {
+                    this.state = { opened: false, closed: true, busy: false };
+                    return;
+                }
+                else {
+                    yield this.forceClose();
+                }
             }
-        }
-        else if (this.state.opening) {
-            if (this.state.connecting) {
-                this.state.error = error;
+            else if (this.state.opening) {
+                if (this.state.connecting) {
+                    this.state.error = error;
+                }
+                else {
+                    this.onPortOpen();
+                }
             }
-            else {
-                this.onPortOpen();
+            else if (this.state.sending) {
+                if (this.state.sending.reject)
+                    this.state.sending.reject(error);
+                this.writeDone();
+                yield this.forceClose(false);
+                return;
             }
-        }
-        else if (this.state.sending) {
-            this.state.error = error;
-            this.forceClose(false);
-            return;
-        }
-        this.state.busy = false;
+            this.state.busy = false;
+        });
     }
     errorHandler() {
         throw new Error("Error");
     }
     saveClose(force) {
-        return new Promise((resolve, reject) => {
-            if (force)
-                this.blocked = true;
-            this.close();
-            const start = Date.now();
-            const iv = setInterval(() => {
-                if (this.state.closed || (Date.now() - start > DEFAULT_TIMEOUT)) {
-                    clearInterval(iv);
-                    resolve(true);
-                    return;
-                }
-            }, 50);
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.close();
         });
     }
     forceClose(updateState = false) {
-        const sp = this.sp;
-        if (!this.sp)
-            return;
-        this.sp.removeAllListeners();
-        try {
-            sp.unpipe();
-            sp.flush();
-        }
-        catch (_a) { }
-        try {
-            sp.close();
-        }
-        catch (_b) { }
-        this.connected = false;
-        if (updateState)
-            this.state = { opened: false, closed: true, busy: false };
+        return __awaiter(this, void 0, void 0, function* () {
+            const sp = this.sp;
+            if (!this.sp)
+                return;
+            this.state.closing = true;
+            sp.removeAllListeners();
+            sp.on('error', () => { });
+            try {
+                sp.unpipe();
+                sp.flush();
+            }
+            catch (_a) { }
+            try {
+                yield this.closePort(1000);
+                this.writeDone();
+                if (this.queue !== undefined)
+                    this.queue.clear();
+            }
+            catch (_b) { }
+            this.connected = false;
+            if (updateState)
+                this.state = { opened: false, closed: true, busy: false };
+        });
+    }
+    closePort(timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                let isClosed = false;
+                const to = setTimeout(() => {
+                    if (!isClosed)
+                        resolve(false);
+                }, timeout);
+                this.sp.removeAllListeners('close');
+                this.sp.removeAllListeners('error');
+                this.sp.on('error', () => { });
+                this.sp.once('close', () => {
+                    clearTimeout(to);
+                    isClosed = true;
+                    resolve(true);
+                });
+                this.sp.close();
+            });
+        });
     }
     close() {
-        this.logEvent({ message: 'close request', port: this.portName });
-        var sp = this.sp;
-        let connected = this.connected;
-        try {
-            if (connected) {
-                if (sp) {
-                    sp.unpipe();
-                    sp.flush();
-                    sp.close();
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'close request', port: this.portName });
+            var sp = this.sp;
+            if (!sp) {
+                this.state = { opened: false, closed: true, busy: false };
+                this.connected = false;
+                return;
+            }
+            let connected = this.connected;
+            try {
+                if (connected) {
+                    try {
+                        sp.removeAllListeners();
+                        sp.on('error', () => { });
+                        sp.unpipe();
+                        sp.flush();
+                    }
+                    catch (_a) { }
                 }
+                yield this.closePort(this.getTimeoutValue());
+                this.writeDone();
                 if (this.queue !== undefined) {
                     this.queue.clear();
                     this.queue = undefined;
                 }
             }
-            else {
-                if (sp)
-                    sp.close();
+            catch (err) {
+                this.logEvent({ message: 'close: Exception', port: this.portName, error: err.message });
             }
-        }
-        catch (err) {
-            this.logEvent({ message: 'close: Exception', port: this.portName, error: err.message });
-        }
-        this.connected = false;
-        const start = Date.now();
-        if (this.state.closing === undefined)
-            this.state.closing = { start, timeout: start + this.getTimeoutValue(), retry: 0, maxRetries: MAX_RETRIES };
-        else {
-            this.state.closing.start = start;
-            this.state.closing.timeout = start + this.getTimeoutValue();
-            this.state.retry = this.state.retry + 1;
-        }
-        this.state.busy = false;
+            this.state = { opened: false, closed: true, busy: false };
+            this.connected = false;
+        });
     }
     sendTimeout(message) {
         this.logEvent({ message: `sendCommand:${message || 'timeout'}`, port: this.portName, cmd: this.cmdCurrent });
@@ -413,29 +419,21 @@ class Daum8i {
         }
         return timeout;
     }
-    onData(data) {
+    onData(data, depth = 0) {
         let cmd = '';
+        const MAX_DEPTH = 5;
         if (this.state.waitingForEnd) {
             cmd = this.state.partialCmd;
         }
         const bufferData = Buffer.isBuffer(data) ? data : Buffer.from(data, 'latin1');
         const s = this.state.sending;
         if (s === undefined) {
-            if (this.state.input === undefined)
-                this.state.input = bufferData;
+            this.logEvent({ message: 'onData:IGNORED', data: bufferData.toString('hex') });
             return;
         }
         const { portName, resolve } = this.state.sending;
-        let incoming;
-        if (this.state.input !== undefined) {
-            const arr = [this.state.input, bufferData];
-            incoming = Buffer.concat(arr);
-        }
-        else {
-            incoming = bufferData;
-        }
-        const response = [...incoming];
-        this.logEvent({ message: 'sendCommand:RECV', data: (0, utils_1.hexstr)(response) });
+        let incoming = bufferData;
+        this.logEvent({ message: 'sendCommand:RECV', data: (0, utils_1.hexstr)(incoming) });
         for (let i = 0; i < incoming.length; i++) {
             const getRemaining = () => {
                 let remaining = '';
@@ -448,53 +446,59 @@ class Daum8i {
             };
             const c = incoming.readUInt8(i);
             if (c === 0x06) {
-                this.logEvent({ message: "sendCommand:ACK received:", port: portName });
                 this.state.waitingForStart = true;
                 this.state.waitingForACK = false;
                 const remaining = getRemaining();
-                if (remaining && remaining !== '')
-                    return this.onData(remaining);
+                this.logEvent({ message: "sendCommand:ACK received:", port: portName, remaining: (0, utils_1.hexstr)(remaining) });
+                if (remaining && remaining !== '' && depth < MAX_DEPTH)
+                    return this.onData(remaining, depth + 1);
             }
             else if (c === 0x15) {
                 this.state.waitingForStart = true;
                 this.state.waitingForACK = false;
-                this.logEvent({ message: "sendCommand:NAK received:", port: portName });
                 const remaining = getRemaining();
-                if (remaining && remaining !== '')
-                    return this.onData(remaining);
+                this.logEvent({ message: "sendCommand:NAK received:", port: portName, remaining: (0, utils_1.hexstr)(remaining) });
+                if (remaining && remaining !== '' && depth < MAX_DEPTH)
+                    return this.onData(remaining, depth + 1);
             }
             else if (c === 0x01) {
                 this.state.waitingForEnd = true;
             }
             else if (c === 0x17) {
                 const remaining = getRemaining();
-                this.logEvent({ message: "sendCommand:received:", duration: Date.now() - this.state.sending.tsRequest, port: portName, cmd: `${cmd} [${(0, utils_1.hexstr)(cmd)}]`, remaining: (0, utils_1.hexstr)(remaining) });
-                this.state.waitingForEnd = false;
-                const cmdStr = cmd.substring(0, cmd.length - 2);
-                const checksumExtracted = cmd.slice(-2);
-                const checksumCalculated = (0, utils_1.checkSum)((0, utils_1.getAsciiArrayFromStr)(cmdStr), []);
-                if (checksumExtracted === checksumCalculated) {
-                    this.sendACK();
-                    if (this.state.sending && this.state.sending.responseCheckIv) {
-                        clearInterval(this.state.sending.responseCheckIv);
-                    }
-                    this.state = {
-                        sending: undefined,
-                        busy: false,
-                        writeBusy: false,
-                        waitingForStart: false,
-                        waitingForEnd: false,
-                        waitingForACK: false,
-                    };
-                    const payload = cmd.substring(3, cmd.length - 2);
-                    resolve(payload);
+                if (this.state.waitingForACK) {
+                    this.logEvent({ message: "sendCommand:ignored:", duration: Date.now() - this.state.sending.tsRequest, port: portName, cmd: `${cmd} [${(0, utils_1.hexstr)(cmd)}]`, remaining: (0, utils_1.hexstr)(remaining) });
+                    this.state.waitingForEnd = false;
                 }
                 else {
-                    this.sendNAK();
+                    this.logEvent({ message: "sendCommand:received:", duration: Date.now() - this.state.sending.tsRequest, port: portName, cmd: `${cmd} [${(0, utils_1.hexstr)(cmd)}]`, remaining: (0, utils_1.hexstr)(remaining) });
+                    this.state.waitingForEnd = false;
+                    const cmdStr = cmd.substring(0, cmd.length - 2);
+                    const checksumExtracted = cmd.slice(-2);
+                    const checksumCalculated = (0, utils_1.checkSum)((0, utils_1.getAsciiArrayFromStr)(cmdStr), []);
+                    if (checksumExtracted === checksumCalculated) {
+                        this.sendACK();
+                        if (this.state.sending && this.state.sending.responseCheckIv) {
+                            clearInterval(this.state.sending.responseCheckIv);
+                        }
+                        this.state = {
+                            sending: undefined,
+                            busy: false,
+                            writeBusy: false,
+                            waitingForStart: false,
+                            waitingForEnd: false,
+                            waitingForACK: false,
+                        };
+                        const payload = cmd.substring(3, cmd.length - 2);
+                        resolve(payload);
+                    }
+                    else {
+                        this.sendNAK();
+                    }
                 }
                 cmd = '';
-                if (remaining)
-                    return this.onData(remaining);
+                if (remaining && depth < 5)
+                    return this.onData(remaining, depth + 1);
             }
             else {
                 if (this.state.waitingForEnd)
@@ -541,15 +545,6 @@ class Daum8i {
                 }
                 this.state.busy = true;
             }
-            const writeDone = () => {
-                this.state.sending = undefined;
-                this.state.writeBusy = false;
-                this.state.busy = false;
-                this.state.sending = undefined;
-                this.state.waitingForStart = false;
-                this.state.waitingForEnd = false;
-                this.state.waitingForACK = false;
-            };
             const port = this.sp;
             const portName = this.portName;
             this.state.received = [];
@@ -561,7 +556,7 @@ class Daum8i {
                 this.state.writeBusy = true;
                 if (!this.connected || port === undefined) {
                     this.logEvent({ message: "sendCommand:error: not connected", port: this.portName });
-                    writeDone();
+                    this.writeDone();
                     return reject(new Error('not connected'));
                 }
                 port.write(message);
@@ -570,21 +565,33 @@ class Daum8i {
                 this.state.retry = 0;
                 this.state.ack = { start, timeout };
                 this.state.sending = { command, payload, start, timeout, port, portName, tsRequest, resolve, reject };
-                const iv = this.state.sending.responseCheckIv = setInterval(() => {
+                const iv = setInterval(() => {
                     const stillWaiting = this.checkForResponse();
                     if (!stillWaiting) {
                         clearInterval(iv);
-                        writeDone();
+                        this.writeDone();
                     }
                 }, 10);
+                this.state.sending.responseCheckIv = iv;
             }
             catch (err) {
                 this.logEvent({ message: "sendCommand:error:", port: portName, error: err.message, stack: err.stack });
-                writeDone();
+                this.writeDone();
                 reject(err);
             }
         }));
     }
+    writeDone() {
+        this.state.writeBusy = false;
+        this.state.busy = false;
+        if (this.state.sending && this.state.sending.responseCheckIv) {
+            clearInterval(this.state.sending.responseCheckIv);
+        }
+        this.state.sending = undefined;
+        this.state.waitingForStart = false;
+        this.state.waitingForEnd = false;
+        this.state.waitingForACK = false;
+    }
     sendACK() {
         const port = this.portName;
         this.state.writeBusy = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "1.5.30",
+  "version": "1.5.32",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",