incyclist-devices 2.0.29 → 2.0.31

package/lib/ble/wahoo/adapter.js

@@ -83,9 +83,6 @@ class BleWahooAdapter extends fm_1.BleFmAdapter {
                     comms.on('data', (data) => {
                         this.onDeviceData(data);
                     });
-                    if (comms.features.heartrate && !this.hasCapability(capabilities_1.IncyclistCapability.HeartRate)) {
-                        this.capabilities.push(capabilities_1.IncyclistCapability.HeartRate);
-                    }
                     this.resetData();
                     this.stopped = false;
                     this.started = true;

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/daum/premium/adapter.js

@@ -92,10 +92,13 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
     }
     isEqual(settings) {
         if (this.getInterface() === device_1.INTERFACE.TCPIP) {
-            const equal = super.isEqual(settings);
-            if (!equal)
-                return false;
             const as = this.settings;
+            if (settings.interface !== this.getInterface())
+                return false;
+            if (settings.protocol !== as.protocol)
+                return false;
+            if ((settings.port || DAUM_PREMIUM_DEFAULT_PORT) !== (as.port || DAUM_PREMIUM_DEFAULT_PORT))
+                return false;
             return (settings.host === as.host);
         }
         else {

package/lib/serial/daum/premium/mock.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { MockBindingInterface, MockPortBinding, CreatePortOptions } from '@serialport/binding-mock';
-import { BindingInterface, PortInfo } from '@serialport/bindings-interface';
+import { BindingInterface } from '@serialport/bindings-interface';
 import { User } from '../../../types/user';
 export type MockProps = {
     interface: string;
@@ -25,7 +25,7 @@ export declare class Daum8iMockImpl {
     getSimulator(path: any): Daum8MockSimulator;
     reset(): void;
     createPort(path: string, options?: CreatePortOptions): void;
-    list(): Promise<PortInfo[]>;
+    list(): Promise<import("@serialport/bindings-interface").PortInfo[]>;
     open(options: any): Promise<Daum8iMockBinding>;
 }
 export declare class Daum8MockSimulator {

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.31",
   "dependencies": {
     "@serialport/bindings-interface": "^1.2.2",
     "@serialport/parser-byte-length": "^9.0.1",