incyclist-devices 1.5.19 → 1.5.21

package/lib/antv2/ant-device.js

@@ -97,7 +97,6 @@ class AntAdapter extends device_1.default {
         if (this.ivDataTimeout)
             return;
         this.ivDataTimeout = setInterval(() => {
-            console.log('~~~ check', this.lastDataTS);
             if (!this.lastDataTS)
                 return;
             if (this.lastDataTS + NO_DATA_TIMEOUT < Date.now()) {
@@ -110,6 +109,7 @@ class AntAdapter extends device_1.default {
             return;
         clearInterval(this.ivDataTimeout);
         this.ivDataTimeout = undefined;
+        this.lastDataTS = undefined;
     }
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/antv2/ant-interface.js

@@ -64,7 +64,7 @@ class AntInterface extends events_1.default {
                     const device = new this.Binding(Object.assign(Object.assign({}, this.props), { logger: this.logger }));
                     const opened = yield device.open();
                     if (!opened) {
-                        this.logEvent({ message: 'could not connect' });
+                        this.logEvent({ message: 'ANT+ not connected' });
                         this.isConnecting = false;
                         return false;
                     }

package/lib/antv2/fe.d.ts

@@ -8,7 +8,9 @@ export default class AntFEAdapter extends AntAdapter {
     protected logger: EventLogger;
     protected cyclingMode: CyclingMode;
     protected distanceInternal?: number;
+    protected startProps: any;
     protected msgCount: number;
+    protected isReconnecting: boolean;
     constructor(sensor: ISensor, protocol: AntProtocol);
     isBike(): boolean;
     isHrm(): boolean;
@@ -25,6 +27,7 @@ export default class AntFEAdapter extends AntAdapter {
     mapData(deviceData: any): IncyclistBikeData;
     transformData(bikeData: any): any;
     start(props?: any): Promise<any>;
-    initTimeoutHandler(): void;
+    setFEDefaultTimeout(): void;
     stop(): Promise<boolean>;
+    reconnect(): Promise<boolean>;
 }

package/lib/antv2/fe.js

@@ -18,9 +18,11 @@ const gd_eventlog_1 = require("gd-eventlog");
 const ant_fe_st_mode_1 = __importDefault(require("../ant/antfe/ant-fe-st-mode"));
 const ant_fe_erg_mode_1 = __importDefault(require("../ant/antfe/ant-fe-erg-mode"));
 const ant_fe_adv_st_mode_1 = __importDefault(require("../ant/antfe/ant-fe-adv-st-mode"));
+const utils_2 = require("../utils");
 const DEFAULT_USER_WEIGHT = 75;
 const DEFAULT_BIKE_WEIGHT = 10;
 const DEFAULT_BIKE_WEIGHT_MOUNTAIN = 14.5;
+const MAX_RETRIES = 3;
 class AntFEAdapter extends ant_device_1.default {
     constructor(sensor, protocol) {
         super(sensor, protocol);
@@ -30,6 +32,7 @@ class AntFEAdapter extends ant_device_1.default {
         };
         this.msgCount = 0;
         this.logger = new gd_eventlog_1.EventLogger('Ant+FE');
+        this.isReconnecting = false;
     }
     isBike() { return true; }
     isHrm() { return false; }
@@ -79,7 +82,7 @@ class AntFEAdapter extends ant_device_1.default {
     }
     sendUpdate(request) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.paused)
+            if (this.paused || this.isReconnecting)
                 return;
             const update = this.getCyclingMode().sendBikeUpdate(request);
             this.logger.logEvent({ message: 'send bike update requested', update, request });
@@ -106,6 +109,9 @@ class AntFEAdapter extends ant_device_1.default {
             catch (err) {
                 if (err.message && err.message.toLowerCase() === 'timeout') {
                     this.emit('timeout');
+                    if (this.startProps.automaticReconnect) {
+                        yield this.reconnect();
+                    }
                 }
                 this.logger.logEvent({ message: 'sendBikeUpdate() error', error: err.message });
             }
@@ -114,6 +120,7 @@ class AntFEAdapter extends ant_device_1.default {
     onDeviceData(deviceData) {
         if (!this.started || this.isStopped())
             return;
+        this.msgCount++;
         this.deviceData = deviceData;
         this.lastDataTS = Date.now();
         if (!this.ivDataTimeout)
@@ -189,73 +196,74 @@ 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;
             const opts = props || {};
             const { args = {}, user = {} } = opts;
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                 const { timeout = 20000 } = props || {};
-                let start = Date.now();
-                let startTimeout = start + timeout;
-                const status = { userSent: false, slopeSent: false };
-                let iv;
-                const stopInterval = () => {
-                    if (iv)
-                        clearInterval(iv);
-                    iv = undefined;
+                let to;
+                const stopTimeoutCheck = () => {
+                    if (to) {
+                        clearTimeout(to);
+                        to = null;
+                    }
                 };
-                if (timeout) {
-                    iv = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-                        if (Date.now() > startTimeout) {
-                            stopInterval();
-                            yield this.stop();
-                            reject(new Error(`could not start device, reason:timeout`));
-                        }
-                        if (this.started && this.msgCount > 1 && status.userSent) {
-                            this.logger.logEvent({ message: 'start success' });
-                            stopInterval();
+                to = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                    yield this.stop();
+                    reject(new Error(`could not start device, reason:timeout`));
+                    to = null;
+                }), timeout);
+                this.setFEDefaultTimeout();
+                let success = false;
+                let status;
+                let retry = 0;
+                while (!success && retry < MAX_RETRIES) {
+                    retry++;
+                    if (!this.started) {
+                        this.started = yield this.ant.startSensor(this.sensor, this.onDeviceData.bind(this));
+                        status = { userSent: false, slopeSent: false };
+                    }
+                    if (!this.started) {
+                        yield (0, utils_2.sleep)(2000);
+                        continue;
+                    }
+                    try {
+                        const fe = this.sensor;
+                        const mode = this.getCyclingMode();
+                        const bikeType = mode ? mode.getSetting('bikeType').toLowerCase() : 'race';
+                        const defaultBikeWeight = bikeType === 'mountain' ? DEFAULT_BIKE_WEIGHT_MOUNTAIN : DEFAULT_BIKE_WEIGHT;
+                        const userWeight = args.userWeight || user.weight || DEFAULT_USER_WEIGHT;
+                        const bikeWeight = args.bikeWeight || defaultBikeWeight;
+                        status.userSent = status.userSent || (yield fe.sendUserConfiguration(userWeight, bikeWeight, args.wheelDiameter, args.gearRatio));
+                        status.slopeSent = status.slopeSent || (yield fe.sendTrackResistance(0.0));
+                    }
+                    catch (error) {
+                        try {
+                            yield yield this.ant.stopSensor(this.sensor);
                         }
-                    }), 100);
+                        catch (_a) { }
+                        this.started = false;
+                    }
+                    success = status.userSent && status.slopeSent;
                 }
-                this.started = yield this.ant.startSensor(this.sensor, this.onDeviceData.bind(this));
-                if (!this.started) {
-                    stopInterval();
-                    this.stop();
-                    return reject(new Error(`could not start device`));
+                while (success && this.msgCount === 0) {
+                    yield (0, utils_2.sleep)(500);
                 }
-                this.initTimeoutHandler();
-                try {
-                    const fe = this.sensor;
-                    const mode = this.getCyclingMode();
-                    const bikeType = mode ? mode.getSetting('bikeType').toLowerCase() : 'race';
-                    const defaultBikeWeight = bikeType === 'mountain' ? DEFAULT_BIKE_WEIGHT_MOUNTAIN : DEFAULT_BIKE_WEIGHT;
-                    const userWeight = args.userWeight || user.weight || DEFAULT_USER_WEIGHT;
-                    const bikeWeight = args.bikeWeight || defaultBikeWeight;
-                    let i = 0;
-                    while (i < 3 && (!status.userSent || !status.slopeSent)) {
-                        if (!timeout || iv)
-                            status.userSent = status.userSent || (yield fe.sendUserConfiguration(userWeight, bikeWeight, args.wheelDiameter, args.gearRatio));
-                        if (!timeout || iv)
-                            status.slopeSent = status.slopeSent || (yield fe.sendTrackResistance(0.0));
-                        i++;
-                    }
-                    stopInterval();
-                    if (status.userSent) {
-                        this.logger.logEvent({ message: 'start success' });
-                        return resolve(true);
-                    }
-                    this.logger.logEvent({ message: 'start failure' });
-                    this.stop();
-                    return reject(new Error(`could not start device, reason: could not send commands`));
+                if (success) {
+                    this.logger.logEvent({ message: 'start success' });
+                    stopTimeoutCheck();
                 }
-                catch (error) {
-                    reject(new Error(`could not start device, reason:${error.message}`));
-                    return;
+                else {
+                    this.logger.logEvent({ message: 'start failed' });
+                    stopTimeoutCheck();
+                    reject(new Error('could not start device, reason: could not send FE commands'));
                 }
             }));
         });
     }
-    initTimeoutHandler() {
+    setFEDefaultTimeout() {
         const fe = this.sensor;
         fe.setSendTimeout(5000);
     }
@@ -269,5 +277,24 @@ class AntFEAdapter extends ant_device_1.default {
             return stopped;
         });
     }
+    reconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'reconnect to device' });
+            this.isReconnecting = true;
+            try {
+                yield this.stop();
+                yield this.start(this.startProps);
+                this.started = true;
+                this.isReconnecting = false;
+                this.logger.logEvent({ message: 'reconnect success' });
+                return true;
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'reconnect failed' });
+                this.isReconnecting = false;
+                return false;
+            }
+        });
+    }
 }
 exports.default = AntFEAdapter;

package/lib/ble/ble-interface.js

@@ -672,7 +672,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
             if (!this.getBinding())
                 throw new Error('no binding defined');
             this.getBinding().removeAllListeners('discover');
-            const ongoing = this.peripheralCache.filter(i => i.state.isLoading);
+            const ongoing = this.peripheralCache.filter(i => i.state && i.state.isLoading);
             if (ongoing)
                 ongoing.forEach(i => { i.isInterrupted = true; });
             yield this.getBinding().stopScanning();

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

@@ -4,6 +4,7 @@ export default class DaumClassicAdapter extends DaumAdapter {
     static NAME: string;
     name: string;
     id: string;
+    udid: number;
     constructor(protocol: any, bike: any);
     setID(id: any): void;
     getID(): string;

package/lib/daum/classic/DaumClassicAdapter.js

@@ -28,6 +28,8 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
         this.paused = undefined;
         this.iv = undefined;
         this.distanceInternal = undefined;
+        this.udid = Date.now();
+        this.logger.logEvent({ message: 'Device created', udid: this.udid, port: this.getPort() });
         this.initData();
     }
     setID(id) {
@@ -101,13 +103,13 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
     }
     startRide(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'relaunch of device' });
+            this.logger.logEvent({ message: 'relaunch of device', udid: this.udid });
             return yield this.launch(props, true);
         });
     }
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'initial start of device' });
+            this.logger.logEvent({ message: 'initial start of device', udid: this.udid });
             return yield this.launch(props, false);
         });
     }
@@ -122,7 +124,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                     try {
                         const version = yield this.bike.getVersion();
                         const { serialNo, cockpit } = version || {};
-                        this.logEvent({ message: 'device info', deviceInfo: { serialNo, cockpit } });
+                        this.logEvent({ message: 'device info', deviceInfo: { serialNo, cockpit }, udid: this.udid });
                     }
                     catch (_a) { }
                 }
@@ -132,7 +134,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                 return true;
             }
             catch (err) {
-                this.logger.logEvent({ message: 'start result: error', error: err.message });
+                this.logger.logEvent({ message: 'start result: error', error: err.message, udid: this.udid });
                 throw new Error(`could not start device, reason:${err.message}`);
             }
         });

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "incyclist-devices",
-  "version": "1.5.19",
+  "version": "1.5.21",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",
     "@types/serialport": "^8.0.1",
     "gd-ant-plus": "^0.0.33",
-    "incyclist-ant-plus": "^0.1.10",
+    "incyclist-ant-plus": "^0.1.13",
     "win32filetime": "^1.0.2"
   },
   "peerDependencies": {