incyclist-devices 1.5.23 → 1.5.25

package/lib/antv2/ant-device.d.ts

@@ -31,12 +31,15 @@ export default class AntAdapter extends IncyclistDevice implements Device {
     onDataFn: OnDeviceDataCallback;
     protected ivDataTimeout: NodeJS.Timer;
     protected lastDataTS: number;
+    protected dataMsgCount: number;
+    private ivWaitForData;
     constructor(sensor: ISensor, protocol: AntProtocol, settings?: any);
     isBike(): boolean;
     isPower(): boolean;
     isHrm(): boolean;
     getDisplayName(): string;
     isSame(device: DeviceAdapter): boolean;
+    waitForData(timeout: number): Promise<unknown>;
     getID(): string;
     getName(): string;
     getProfile(): string;

package/lib/antv2/ant-device.js

@@ -28,6 +28,7 @@ class AntAdapter extends device_1.default {
         this.ignorePower = false;
         this.deviceData = {};
         this.data = {};
+        this.dataMsgCount = 0;
         this.updateFrequency = exports.DEFAULT_UPDATE_FREQUENCY;
         this.channel = undefined;
         this.paused = false;
@@ -52,6 +53,29 @@ class AntAdapter extends device_1.default {
         const adapter = device;
         return (adapter.getID() === this.getID() && adapter.getProfile() === this.getProfile());
     }
+    waitForData(timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTs = Date.now();
+            const timeoutTs = startTs + timeout;
+            return new Promise((resolve, reject) => {
+                if (this.ivWaitForData)
+                    return reject(new Error('busy'));
+                this.ivWaitForData = setInterval(() => {
+                    const nowTs = Date.now();
+                    if (nowTs > timeoutTs && this.dataMsgCount === 0) {
+                        clearInterval(this.ivWaitForData);
+                        this.ivWaitForData = undefined;
+                        reject(new Error('No Data Received'));
+                    }
+                    if (this.dataMsgCount > 0) {
+                        clearInterval(this.ivWaitForData);
+                        this.ivWaitForData = undefined;
+                        resolve(nowTs - startTs);
+                    }
+                }, 500);
+            });
+        });
+    }
     getID() {
         return this.sensor.getDeviceID().toString();
     }
@@ -110,9 +134,11 @@ class AntAdapter extends device_1.default {
         clearInterval(this.ivDataTimeout);
         this.ivDataTimeout = undefined;
         this.lastDataTS = undefined;
+        this.dataMsgCount = 0;
     }
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.dataMsgCount = 0;
             if (props && props.user)
                 this.userSettings = props.user;
             if (props && props.bikeSettings)

package/lib/antv2/ant-interface.js

@@ -235,9 +235,10 @@ class AntInterface extends events_1.default {
             if (!this.isConnected || !this.device)
                 return true;
             const channel = sensor.getChannel();
-            channel.removeAllListeners('data');
             if (channel) {
                 try {
+                    channel.flush();
+                    channel.removeAllListeners('data');
                     return yield channel.stopSensor(sensor);
                 }
                 catch (err) {
@@ -245,6 +246,10 @@ class AntInterface extends events_1.default {
                     return false;
                 }
             }
+            else {
+                this.logEvent({ message: 'could not stop sensor', error: 'no channel attached' });
+                return false;
+            }
         });
     }
     isScanning() {

package/lib/antv2/fe.d.ts

@@ -9,7 +9,6 @@ export default class AntFEAdapter extends AntAdapter {
     protected cyclingMode: CyclingMode;
     protected distanceInternal?: number;
     protected startProps: any;
-    protected msgCount: number;
     protected isReconnecting: boolean;
     constructor(sensor: ISensor, protocol: AntProtocol);
     isBike(): boolean;

package/lib/antv2/fe.js

@@ -30,7 +30,7 @@ class AntFEAdapter extends ant_device_1.default {
         this.deviceData = {
             DeviceID: sensor.getDeviceID()
         };
-        this.msgCount = 0;
+        this.dataMsgCount = 0;
         this.logger = new gd_eventlog_1.EventLogger('Ant+FE');
         this.isReconnecting = false;
     }
@@ -118,13 +118,14 @@ class AntFEAdapter extends ant_device_1.default {
         });
     }
     onDeviceData(deviceData) {
+        this.dataMsgCount++;
+        this.lastDataTS = Date.now();
         if (!this.started || this.isStopped())
             return;
-        this.msgCount++;
         this.deviceData = deviceData;
-        this.lastDataTS = Date.now();
-        if (!this.ivDataTimeout)
+        if (this.dataMsgCount === 1) {
             this.startDataTimeoutCheck();
+        }
         try {
             const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
             this.logger.logEvent({ message: 'onDeviceData', data: logData });
@@ -197,12 +198,12 @@ class AntFEAdapter extends ant_device_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             _super.start.call(this, props);
             this.startProps = props;
-            this.logger.logEvent({ message: 'start', props });
-            this.msgCount = 0;
+            this.logger.logEvent({ message: 'starting device', props });
             const opts = props || {};
             const { args = {}, user = {} } = opts;
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                 const { timeout = 20000 } = props || {};
+                const totalTimeout = timeout + 10000;
                 let to;
                 const stopTimeoutCheck = () => {
                     if (to) {
@@ -214,15 +215,33 @@ class AntFEAdapter extends ant_device_1.default {
                     yield this.stop();
                     reject(new Error(`could not start device, reason:timeout`));
                     to = null;
-                }), timeout);
+                }), totalTimeout);
                 this.setFEDefaultTimeout();
                 let success = false;
                 let status = { userSent: false, slopeSent: false };
                 let retry = 0;
+                let startSuccess = 0;
                 while (!success && retry < MAX_RETRIES) {
                     retry++;
                     if (!this.started) {
                         this.started = yield this.ant.startSensor(this.sensor, this.onDeviceData.bind(this));
+                        if (this.started) {
+                            startSuccess++;
+                        }
+                        if (this.started && startSuccess === 1) {
+                            try {
+                                yield this.waitForData(timeout);
+                            }
+                            catch (err) {
+                                stopTimeoutCheck();
+                                try {
+                                    yield yield this.ant.stopSensor(this.sensor);
+                                }
+                                catch (_a) { }
+                                this.started = false;
+                                return reject(new Error(`could not start device, reason: ${err.message}`));
+                            }
+                        }
                         status = { userSent: false, slopeSent: false };
                     }
                     if (!this.started) {
@@ -242,14 +261,14 @@ class AntFEAdapter extends ant_device_1.default {
                     catch (err) {
                         this.logger.logEvent({ message: 'sending FE message error', error: err.message });
                         try {
-                            yield yield this.ant.stopSensor(this.sensor);
+                            yield this.ant.stopSensor(this.sensor);
                         }
-                        catch (_a) { }
+                        catch (_b) { }
                         this.started = false;
                     }
                     success = status.userSent && status.slopeSent;
                 }
-                while (success && this.msgCount === 0) {
+                while (success && this.dataMsgCount === 0) {
                     yield (0, utils_2.sleep)(500);
                 }
                 if (success) {
@@ -260,7 +279,10 @@ class AntFEAdapter extends ant_device_1.default {
                 else {
                     this.logger.logEvent({ message: 'start failed' });
                     stopTimeoutCheck();
-                    reject(new Error('could not start device, reason: could not send FE commands'));
+                    if (this.started)
+                        reject(new Error('could not start device, reason: could not send FE commands'));
+                    else
+                        reject(new Error('could not start device, reason: could not connect'));
                 }
             }));
         });
@@ -274,8 +296,10 @@ class AntFEAdapter extends ant_device_1.default {
             stop: { get: () => super.stop }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            const stopped = yield this.ant.stopSensor(this.sensor);
-            _super.stop.call(this);
+            this.logger.logEvent({ message: 'stopping device' });
+            let stopped = yield this.ant.stopSensor(this.sensor);
+            yield _super.stop.call(this);
+            this.logger.logEvent({ message: 'stopping device done', success: stopped });
             return stopped;
         });
     }

package/lib/antv2/hr.js

@@ -37,10 +37,11 @@ class AntHrAdapter extends ant_device_1.default {
         return `${(0, utils_1.getBrand)(manID)} Hrm ${DeviceID}${hrmStr}`;
     }
     onDeviceData(deviceData) {
+        this.dataMsgCount++;
+        this.lastDataTS = Date.now();
         if (!this.started)
             return;
         this.deviceData = deviceData;
-        this.lastDataTS = Date.now();
         if (!this.ivDataTimeout)
             this.startDataTimeoutCheck();
         try {
@@ -67,7 +68,7 @@ class AntHrAdapter extends ant_device_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             _super.start.call(this, props);
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                const { timeout } = props || {};
+                const { timeout = 20000 } = props || {};
                 let to;
                 if (timeout) {
                     to = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
@@ -76,9 +77,14 @@ class AntHrAdapter extends ant_device_1.default {
                     }), timeout);
                 }
                 this.started = yield this.ant.startSensor(this.sensor, this.onDeviceData.bind(this));
-                if (to)
-                    clearTimeout(to);
-                resolve(this.started);
+                try {
+                    yield this.waitForData(timeout - 100);
+                    if (to)
+                        clearTimeout(to);
+                    resolve(this.started);
+                }
+                catch (err) {
+                }
             }));
         });
     }

package/lib/antv2/pwr.js

@@ -55,10 +55,11 @@ class AntPwrAdapter extends ant_device_1.default {
         return logData;
     }
     onDeviceData(deviceData) {
+        this.dataMsgCount++;
+        this.lastDataTS = Date.now();
         if (!this.started)
             return;
         this.deviceData = deviceData;
-        this.lastDataTS = Date.now();
         if (!this.ivDataTimeout)
             this.startDataTimeoutCheck();
         try {
@@ -135,7 +136,7 @@ class AntPwrAdapter extends ant_device_1.default {
                 return true;
             _super.start.call(this, props);
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                const { timeout } = props || {};
+                const { timeout = 20000 } = props || {};
                 let to;
                 if (timeout) {
                     to = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
@@ -144,9 +145,14 @@ class AntPwrAdapter extends ant_device_1.default {
                     }), timeout);
                 }
                 this.started = yield this.ant.startSensor(this.sensor, this.onDeviceData.bind(this));
-                if (to)
-                    clearTimeout(to);
-                resolve(this.started);
+                try {
+                    yield this.waitForData(timeout - 100);
+                    if (to)
+                        clearTimeout(to);
+                    resolve(this.started);
+                }
+                catch (err) {
+                }
             }));
         });
     }

package/package.json

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