incyclist-devices 1.5.20 → 1.5.22

package/lib/antv2/ant-device.js

@@ -109,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/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,76 @@ 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 = { userSent: false, slopeSent: false };
+                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 (err) {
+                        this.logger.logEvent({ message: 'sending FE message error', error: err.message });
+                        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();
+                    resolve(true);
                 }
-                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 +279,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/lib/daum/premium/bike.d.ts

@@ -44,7 +44,7 @@ declare class Daum8i {
     getUserWeight(): any;
     getBikeWeight(): number;
     unblock(): void;
-    connect(): void;
+    connect(): Promise<void>;
     reconnect(): Promise<void>;
     saveConnect(): Promise<unknown>;
     onPortOpen(): void;

package/lib/daum/premium/bike.js

@@ -118,87 +118,98 @@ class Daum8i {
         this.blocked = false;
     }
     connect() {
-        this.logEvent({ message: "connect()", sp: (this.sp !== undefined), connected: this.connected, blocked: this.blocked, port: this.portName, settings: this.settings });
-        if (this.connected || this.blocked) {
-            return;
-        }
-        this.state.busy = true;
-        this.state.commandsInQueue = {};
-        try {
-            if (this.sp !== undefined) {
-                try {
-                    this.sp.removeAllListeners();
-                    this.sp.close();
-                }
-                catch (err) {
-                }
-                this.sp = undefined;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: "connect()", sp: (this.sp !== undefined), connected: this.connected, blocked: this.blocked, port: this.portName, settings: this.settings });
+            if (this.connected || this.blocked) {
+                return;
             }
-            if (this.sp === undefined) {
-                if (this.tcpip) {
-                    const { host, port } = this.tcpipConnection;
-                    const { logger } = this.props;
-                    this.logEvent({ message: "creating TCPSocketPort", host, port });
-                    this.sp = new tcpserial_1.default({ host, port, net, timeout: OPEN_TIMEOUT, logger });
+            this.state.busy = true;
+            this.state.commandsInQueue = {};
+            try {
+                if (this.sp !== undefined) {
+                    try {
+                        this.sp.removeAllListeners();
+                        yield this.sp.close();
+                    }
+                    catch (err) {
+                    }
+                    this.sp = undefined;
                 }
-                else {
-                    const settings = this.settings.port || {};
-                    settings.autoOpen = false;
-                    this.logEvent({ message: "creating SerialPort", port: this.port, settings });
-                    this.sp = new __SerialPort(this.port, settings);
+                if (this.sp === undefined) {
+                    if (this.tcpip) {
+                        const { host, port } = this.tcpipConnection;
+                        const { logger } = this.props;
+                        this.logEvent({ message: "creating TCPSocketPort", host, port });
+                        this.sp = new tcpserial_1.default({ host, port, net, timeout: OPEN_TIMEOUT, logger });
+                    }
+                    else {
+                        const settings = this.settings.port || {};
+                        settings.autoOpen = false;
+                        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.on('error', (error) => { this.onPortError(error); });
+                    this.sp.on('data', (data) => { this.onData(data); });
                 }
-                this.sp.on('open', this.onPortOpen.bind(this));
-                this.sp.on('close', this.onPortClose.bind(this));
-                this.sp.on('error', (error) => { this.onPortError(error); });
-                this.sp.on('data', (data) => { this.onData(data); });
+                const start = Date.now();
+                this.state.connecting = true;
+                this.state.opening = { start, timeout: start + this.getTimeoutValue() };
+                this.logEvent({ message: "opening port ..." });
+                yield this.sp.open();
             }
-            const start = Date.now();
-            this.state.connecting = true;
-            this.state.opening = { start, timeout: start + this.getTimeoutValue() };
-            this.logEvent({ message: "opening port ..." });
-            this.sp.open();
-        }
-        catch (err) {
-            this.logEvent({ message: "scan:error:", error: err.message, stack: err.stack });
-            this.state.busy = false;
-        }
+            catch (err) {
+                this.logEvent({ message: "connect:error:", error: err.message, stack: err.stack });
+                this.state.busy = false;
+            }
+        });
     }
     reconnect() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.saveClose();
-            yield this.saveConnect();
+            try {
+                yield this.saveClose();
+                yield this.saveConnect();
+            }
+            catch (_a) { }
         });
     }
     saveConnect() {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
             if (this.isConnected()) {
                 this.state.connecting = false;
                 return resolve(true);
             }
-            this.connect();
+            try {
+                yield this.connect();
+            }
+            catch (_a) { }
             const tTimeout = Date.now() + TIMEOUT_START;
             const iv = setInterval(() => {
-                if (this.state.error !== undefined) {
-                    clearInterval(iv);
-                    this.forceClose();
-                    reject(this.state.error);
-                    this.state = { opened: false, closed: true, busy: false };
-                }
-                else if (this.isConnected()) {
-                    this.state.connecting = false;
-                    resolve(true);
-                    clearInterval(iv);
-                }
-                else {
-                    if (Date.now() > tTimeout) {
-                        this.state.connecting = false;
+                try {
+                    if (this.state.error !== undefined) {
+                        clearInterval(iv);
                         this.forceClose();
+                        reject(this.state.error);
+                        this.state = { opened: false, closed: true, busy: false };
+                    }
+                    else if (this.isConnected()) {
+                        this.state.connecting = false;
+                        resolve(true);
                         clearInterval(iv);
-                        reject(new Error('timeout'));
+                    }
+                    else {
+                        if (Date.now() > tTimeout) {
+                            this.state.connecting = false;
+                            this.forceClose();
+                            clearInterval(iv);
+                            reject(new Error('timeout'));
+                        }
                     }
                 }
+                catch (_a) { }
             }, 100);
-        });
+        }));
     }
     onPortOpen() {
         this.error = undefined;
@@ -239,11 +250,14 @@ class Daum8i {
         this.error = error;
         if (this.blocked) {
             if (!this.state.closed) {
-                if (this.sp) {
-                    this.sp.removeAllListeners();
-                    this.sp.close();
-                    this.sp = undefined;
+                try {
+                    if (this.sp) {
+                        this.sp.removeAllListeners();
+                        this.sp.close();
+                        this.sp = undefined;
+                    }
                 }
+                catch (_a) { }
                 this.state = { opened: false, closed: true, busy: false };
             }
             return;
@@ -300,7 +314,10 @@ class Daum8i {
             sp.flush();
         }
         catch (_a) { }
-        sp.close();
+        try {
+            sp.close();
+        }
+        catch (_b) { }
         this.connected = false;
         if (updateState)
             this.state = { opened: false, closed: true, busy: false };

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "incyclist-devices",
-  "version": "1.5.20",
+  "version": "1.5.22",
   "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.12",
+    "incyclist-ant-plus": "file:../ant-plus",
+    "incyclist-devices": "^1.5.21",
     "win32filetime": "^1.0.2"
   },
   "peerDependencies": {