incyclist-devices 2.0.29 → 2.0.30

package/lib/serial/daum/DaumAdapter.js

@@ -174,6 +174,7 @@ class DaumAdapterBase extends adapter_1.SerialIncyclistDevice {
                 return connected;
             }
             catch (err) {
+                yield this.bike.close();
                 return false;
             }
         });

package/lib/serial/daum/classic/adapter.d.ts

@@ -11,6 +11,7 @@ export default class DaumClassicAdapter extends DaumAdapter {
     id: string;
     started: boolean;
     startPromise: Promise<unknown>;
+    checkPromise: Promise<boolean>;
     constructor(settings: SerialDeviceSettings, props?: DeviceProperties);
     setID(id: any): void;
     getID(): string;
@@ -21,6 +22,7 @@ export default class DaumClassicAdapter extends DaumAdapter {
     getSupportedCyclingModes(): Array<any>;
     getDefaultCyclingMode(): CyclingMode;
     check(): Promise<boolean>;
+    performCheck(): Promise<boolean>;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
     startRide(props?: DaumClassicDeviceProperties): Promise<boolean>;

package/lib/serial/daum/classic/adapter.js

@@ -51,6 +51,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
         this.iv = undefined;
         this.distanceInternal = undefined;
         this.startPromise = undefined;
+        this.checkPromise = undefined;
         this.initData();
     }
     setID(id) {
@@ -81,9 +82,32 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
     }
     check() {
         return __awaiter(this, void 0, void 0, function* () {
-            var info = {};
             if (this.isStopped())
                 return false;
+            if (this.checkPromise) {
+                this.logEvent({ message: "waiting for previous check device", port: this.getPort() });
+                try {
+                    yield this.checkPromise;
+                }
+                catch (_a) { }
+                this.logEvent({ message: "previous check device completed", port: this.getPort() });
+                this.checkPromise = undefined;
+            }
+            this.checkPromise = this.performCheck();
+            try {
+                const res = yield this.checkPromise;
+                this.checkPromise = undefined;
+                return res;
+            }
+            catch (err) {
+                this.checkPromise = undefined;
+                throw err;
+            }
+        });
+    }
+    performCheck() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var info = {};
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                 this.logEvent({ message: "checking device", port: this.getPort() });
                 const iv = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
@@ -109,6 +133,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                     resolve(true);
                 }
                 catch (err) {
+                    clearTimeout(iv);
                     this.logEvent({ message: "checking device failed", port: this.getPort(), reason: err.message || err });
                     resolve(false);
                 }

package/lib/serial/daum/classic/comms.js

@@ -94,20 +94,27 @@ class Daum8008 {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.serial)
                 return;
+            this.closing = true;
             this.stopWorker();
-            yield this.flush();
-            try {
-                yield this.serial.closePort(this.portName);
+            if (this.isConnected()) {
+                try {
+                    yield this.flush();
+                }
+                catch (_a) { }
+                try {
+                    yield this.serial.closePort(this.portName);
+                }
+                catch (_b) { }
             }
-            catch (_a) { }
             this.connected = false;
-            if (this.sp)
+            this.cmdBusy = false;
+            if (this.sp) {
                 this.sp.removeAllListeners();
-            this.sp = null;
+                this.sp = null;
+            }
             this.error = undefined;
             this.closing = false;
             this.closed = true;
-            this.cmdBusy = false;
             return;
         });
     }
@@ -116,8 +123,9 @@ class Daum8008 {
             if (!this.cmdBusy)
                 return;
             return new Promise(done => {
+                const tsStart = Date.now();
                 const iv = setInterval(() => {
-                    if (!this.cmdBusy) {
+                    if (!this.cmdBusy || (Date.now() - tsStart > TIMEOUT_SEND + 500)) {
                         clearInterval(iv);
                         done();
                     }
@@ -176,7 +184,7 @@ class Daum8008 {
                 }
             }
         }
-        if (this.connected && this.cmdBusy) {
+        if (this.connected && this.cmdBusy && !this.closing) {
             if (this.cmdCurrent !== undefined && this.cmdCurrent.start !== undefined) {
                 const cmdInfo = this.cmdCurrent;
                 const timeout = (cmdInfo.options && cmdInfo.options.timeout) ? cmdInfo.options.timeout : this._timeoutSend;
@@ -205,7 +213,8 @@ class Daum8008 {
             return;
         }
         const cmd = this.queue.dequeue();
-        this.send(cmd);
+        if (this.connected && !this.closing && !this.closed)
+            this.send(cmd);
     }
     sendDaum8008Command(logStr, payload, expected, callback, callbackErr, options) {
         let cmdInfo = {

package/lib/serial/serial-interface.js

@@ -175,12 +175,12 @@ class SerialInterface extends events_1.default {
     }
     openPort(path) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'opening port', path });
+            this.logEvent({ message: 'opening port', port: path });
             const existing = this.ports.findIndex(p => p.path === path);
             if (existing !== -1) {
                 const port = this.ports[existing].port;
                 if (port.isOpen) {
-                    this.logEvent({ message: 'opening port - port already exists', path });
+                    this.logEvent({ message: 'opening port - port already exists', port: path });
                     return port;
                 }
                 else {
@@ -189,7 +189,7 @@ class SerialInterface extends events_1.default {
             }
             const port = serialport_1.default.getInstance().getSerialPort(this.ifaceName, { path });
             if (!port) {
-                this.logEvent({ message: 'opening port - port does not exist', path });
+                this.logEvent({ message: 'opening port - port does not exist', port: path });
                 return null;
             }
             return new Promise((resolve) => {
@@ -210,7 +210,7 @@ class SerialInterface extends events_1.default {
     }
     closePort(path) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'closing port' });
+            this.logEvent({ message: 'closing port', port: path });
             const existing = this.ports.findIndex(p => p.path === path);
             if (existing === -1)
                 return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "2.0.29",
+  "version": "2.0.30",
   "dependencies": {
     "@serialport/bindings-interface": "^1.2.2",
     "@serialport/parser-byte-length": "^9.0.1",