incyclist-devices 2.1.1 → 2.1.2

package/lib/antv2/fe/adapter.js

@@ -13,22 +13,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const adapter_1 = __importDefault(require("../base/adapter"));
+const types_1 = require("../../types");
 const ant_fe_adv_st_mode_1 = __importDefault(require("../../modes/ant-fe-adv-st-mode"));
-const utils_1 = require("../../utils/utils");
-const capabilities_1 = require("../../types/capabilities");
 const consts_1 = require("../../base/consts");
 const antble_erg_1 = __importDefault(require("../../modes/antble-erg"));
 const antble_smarttrainer_1 = __importDefault(require("../../modes/antble-smarttrainer"));
 const DEFAULT_BIKE_WEIGHT_MOUNTAIN = 14.5;
-const MAX_RETRIES = 3;
 class AntFEAdapter extends adapter_1.default {
     constructor(settings, props) {
         super(settings, props);
         this.startProps = {};
-        this.sensorConnected = false;
         this.capabilities = [
-            capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Speed, capabilities_1.IncyclistCapability.Cadence,
-            capabilities_1.IncyclistCapability.Control
+            types_1.IncyclistCapability.Power, types_1.IncyclistCapability.Speed, types_1.IncyclistCapability.Cadence,
+            types_1.IncyclistCapability.Control
         ];
     }
     getDisplayName() {
@@ -36,9 +33,6 @@ class AntFEAdapter extends adapter_1.default {
         const pwrStr = InstantaneousPower ? ` (${InstantaneousPower})` : '';
         return `${this.getUniqueName()}${pwrStr}`;
     }
-    getDefaultReconnectDelay() {
-        return 2000;
-    }
     isReconnecting() {
         return this.promiseReconnect !== null && this.promiseReconnect !== undefined;
     }
@@ -71,8 +65,8 @@ class AntFEAdapter extends adapter_1.default {
     }
     onDeviceData(deviceData) {
         super.onDeviceData(deviceData);
-        if (deviceData.HeartRate && !this.hasCapability(capabilities_1.IncyclistCapability.HeartRate)) {
-            this.capabilities.push(capabilities_1.IncyclistCapability.HeartRate);
+        if (deviceData.HeartRate && !this.hasCapability(types_1.IncyclistCapability.HeartRate)) {
+            this.capabilities.push(types_1.IncyclistCapability.HeartRate);
             this.emit('device-info', this.getSettings(), { capabilities: this.capabilities });
         }
     }
@@ -118,134 +112,45 @@ class AntFEAdapter extends adapter_1.default {
             data.deviceTime = adapterData.time;
         this.data = data;
     }
-    start(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const isReconnect = (props === null || props === void 0 ? void 0 : props.reconnect) || false;
-            const startProps = Object.assign({}, props || {});
-            delete startProps.reconnect;
-            return yield this.performStart(props, isReconnect);
+    start(props = {}) {
+        const _super = Object.create(null, {
+            start: { get: () => super.start }
         });
-    }
-    performStart(props, isReconnect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const wasPaused = this.paused;
-            const wasStopped = this.stopped;
-            this.startProps = props;
-            if (wasPaused)
-                this.resume();
-            this.stopped = false;
-            if (this.started && !wasPaused && !wasStopped) {
-                return true;
-            }
-            const connected = yield this.connect();
-            if (!connected)
-                throw new Error(`could not start device, reason:could not connect`);
-            this.logEvent({ message: 'starting device', props, isStarted: this.started, isReconnecting: isReconnect });
-            const { startupTimeout = this.getDefaultStartupTimeout(), reconnectTimeout = this.getDefaultReconnectDelay() } = props || {};
-            const totalTimeout = Math.min(startupTimeout + 10000, startupTimeout * 2);
-            let status = { timeout: false, sensorStarted: false, hasData: false, userSent: false, slopeSent: false };
-            const doStart = () => __awaiter(this, void 0, void 0, function* () {
-                this.setFEDefaultTimeout();
-                let success = false;
-                let retry = 0;
-                if (isReconnect) {
-                    status.userSent = true;
-                    status.slopeSent = true;
-                }
-                while (!success && retry < MAX_RETRIES && !status.timeout) {
-                    if (retry !== 0) {
-                        console.log('~~~ RETRY', status);
-                    }
-                    retry++;
-                    yield this.initSensor(status, props);
-                    yield this.waitForInitialData(status, startupTimeout);
-                    yield this.sendInititalUserMessage(status, props);
-                    yield this.sendInitialRequest(status, props);
-                    if (!status.hasData) {
-                        yield this.stopSensor();
-                        yield (0, utils_1.sleep)(reconnectTimeout);
-                        continue;
-                    }
-                    success = status.sensorStarted && status.hasData && status.userSent && status.slopeSent;
-                }
-                if (success) {
-                    this.logEvent({ message: 'ANT FE start success' });
-                    this.started = true;
-                    this.paused = false;
-                    return true;
-                }
-                else {
-                    this.started = false;
-                    if (!status.sensorStarted) {
-                        this.logEvent({ message: 'ANT FE start failed', reason: 'could not connect' });
-                        throw new Error('could not start device, reason:could not connect');
-                    }
-                    else if (!status.hasData) {
-                        this.logEvent({ message: 'ANT FE start failed', reason: 'no data received' });
-                        throw new Error('could not start device, reason:no data received');
-                    }
-                    else {
-                        this.logEvent({ message: 'ANT FE start failed', reason: 'could not send FE commands' });
-                        throw new Error('could not start device, reason:could not send FE commands');
-                    }
-                }
-            });
-            try {
-                yield (0, utils_1.runWithTimeout)(doStart(), totalTimeout);
-            }
-            catch (err) {
-                if (err.message === 'Timeout') {
-                    this.started = false;
-                    status.timeout = true;
-                    throw new Error(`could not start device, reason:timeout`);
-                }
-                throw err;
-            }
-            return true;
+            return yield _super.start.call(this, props);
         });
     }
-    waitForInitialData(status, startupTimeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if ((status.sensorStarted && status.hasData) || !status.sensorStarted || status.timeout)
-                return;
-            this.logEvent({ message: 'wait for sensor data', });
-            status.hasData = yield this.waitForData(startupTimeout);
-            if (status.hasData)
-                this.logEvent({ message: 'sensor data received', });
-        });
+    resetStartStatus() {
+        const props = this.startProps;
+        const isReconnect = props.reconnect || false;
+        super.resetStartStatus();
+        if (isReconnect) {
+            delete props.reconnect;
+            this.startStatus.userInitialized = true;
+            this.startStatus.controlInitialized = true;
+        }
     }
-    stopSensor() {
+    startPreChecks(props) {
+        const _super = Object.create(null, {
+            startPreChecks: { get: () => super.startPreChecks }
+        });
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.sensorConnected)
-                return;
-            try {
-                yield yield this.ant.stopSensor(this.sensor);
-                this.sensorConnected = false;
-            }
-            catch (_a) { }
+            this.startProps = props;
+            this.setFEDefaultTimeout();
+            return yield _super.startPreChecks.call(this, props);
         });
     }
-    initSensor(status, props) {
+    initControl() {
         return __awaiter(this, void 0, void 0, function* () {
-            status.sensorStarted = this.sensorConnected;
-            if (status.sensorStarted || status.timeout)
-                return;
-            this.logEvent({ message: 'start sensor', props });
-            try {
-                this.sensorConnected = yield this.startSensor();
-                if (this.sensorConnected) {
-                    this.logEvent({ message: 'sensor started', props });
-                    status.sensorStarted = true;
-                }
-            }
-            catch (err) {
-                this.logEvent({ message: 'start sensor failed', reason: err.message, props });
-            }
+            yield this.sendInititalUserMessage();
+            yield this.sendInitialRequest();
         });
     }
-    sendInititalUserMessage(status, props) {
+    sendInititalUserMessage() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!status.sensorStarted || !status.hasData || status.userSent || status.timeout)
+            const props = this.startProps;
+            const { sensorStarted, hasData, userInitialized, timeout } = this.startStatus;
+            if (!sensorStarted || !hasData || userInitialized || timeout)
                 return;
             const opts = props || {};
             const { args = {}, user = {} } = opts;
@@ -256,39 +161,40 @@ class AntFEAdapter extends adapter_1.default {
                 const defaultBikeWeight = bikeType === 'mountain' ? DEFAULT_BIKE_WEIGHT_MOUNTAIN : consts_1.DEFAULT_BIKE_WEIGHT;
                 const userWeight = args.userWeight || user.weight || consts_1.DEFAULT_USER_WEIGHT;
                 const bikeWeight = args.bikeWeight || defaultBikeWeight;
-                status.userSent = status.userSent || (yield fe.sendUserConfiguration(userWeight, bikeWeight, args.wheelDiameter, args.gearRatio));
+                this.startStatus.userInitialized = yield fe.sendUserConfiguration(userWeight, bikeWeight, args.wheelDiameter, args.gearRatio);
             }
             catch (err) {
                 this.logEvent({ message: 'sending FE message error', error: err.message });
-                status.userSent = false;
+                this.startStatus.userInitialized = false;
             }
         });
     }
-    sendInitialRequest(status, props) {
+    sendInitialRequest() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!status.sensorStarted || !status.hasData || status.slopeSent || status.timeout)
+            const { sensorStarted, hasData, controlInitialized, timeout } = this.startStatus;
+            if (!sensorStarted || !hasData || controlInitialized || timeout)
                 return;
             const fe = this.sensor;
             try {
                 const startRequest = this.getCyclingMode().getBikeInitRequest();
                 if (startRequest) {
                     if (startRequest.targetPower !== undefined && startRequest.targetPower !== null) {
-                        status.slopeSent = yield fe.sendTargetPower(startRequest.targetPower);
+                        this.startStatus.controlInitialized = yield fe.sendTargetPower(startRequest.targetPower);
                     }
                     else if (startRequest.slope !== undefined && startRequest.slope !== null) {
-                        status.slopeSent = yield fe.sendTrackResistance(startRequest.slope);
+                        this.startStatus.controlInitialized = yield fe.sendTrackResistance(startRequest.slope);
                     }
                     else {
-                        status.slopeSent = true;
+                        this.startStatus.controlInitialized = true;
                     }
                 }
                 else {
-                    status.slopeSent = yield fe.sendTrackResistance(0.0);
+                    this.startStatus.controlInitialized = yield fe.sendTrackResistance(0.0);
                 }
             }
             catch (err) {
                 this.logEvent({ message: 'sending FE message error', error: err.message });
-                status.slopeSent = false;
+                this.startStatus.controlInitialized = false;
             }
         });
     }
@@ -310,7 +216,7 @@ class AntFEAdapter extends adapter_1.default {
             const doReconnect = () => __awaiter(this, void 0, void 0, function* () {
                 try {
                     yield this.stop();
-                    yield this.performStart(this.startProps, true);
+                    yield this.start(Object.assign(Object.assign({}, this.startProps), { reconnect: true }));
                     this.started = true;
                     this.logEvent({ message: 'reconnect success' });
                     return true;
@@ -338,7 +244,6 @@ class AntFEAdapter extends adapter_1.default {
                     }
                 }
                 catch (err) {
-                    console.log(err);
                     return false;
                 }
             }

package/lib/antv2/index.d.ts

@@ -2,7 +2,7 @@ import AntPwrAdapter from "./pwr";
 import AntFEAdapter from "./fe";
 import AntHrAdapter from "./hr";
 import AntAdapterFactory from "./factories/adapter-factory";
-import AntInterface from "./base/ant-interface";
+import AntInterface from "./base/interface";
 import { AntInterfaceProps } from "./types";
 export { AntDeviceSettings, AntDeviceProperties, AntScanProps } from "./types";
 export { AntAdapterFactory, AntFEAdapter, AntHrAdapter, AntPwrAdapter, AntInterface, AntInterfaceProps };

package/lib/antv2/index.js

@@ -13,8 +13,8 @@ exports.AntHrAdapter = hr_1.default;
 const cad_1 = __importDefault(require("./cad"));
 const adapter_factory_1 = __importDefault(require("./factories/adapter-factory"));
 exports.AntAdapterFactory = adapter_factory_1.default;
-const ant_interface_1 = __importDefault(require("./base/ant-interface"));
-exports.AntInterface = ant_interface_1.default;
+const interface_1 = __importDefault(require("./base/interface"));
+exports.AntInterface = interface_1.default;
 const af = adapter_factory_1.default.getInstance();
 af.register('PWR', 'Power Meter', pwr_1.default);
 af.register('HR', 'Heartrate Monitor', hr_1.default);

package/lib/antv2/types.d.ts

@@ -4,6 +4,7 @@ import AntAdapter from './base/adapter';
 export interface AntDeviceSettings extends DeviceSettings {
     deviceID?: string;
     profile: Profile | LegacyProfile;
+    interface: string;
     protocol?: string;
 }
 export type LegacyProfile = 'Heartrate Monitor' | 'Power Meter' | 'Smart Trainer' | 'Speed Sensor' | 'Cadence Sensor' | 'Speed + Cadence Sensor';
@@ -40,3 +41,11 @@ export interface ConnectState {
     connected: boolean;
     connecting: boolean;
 }
+export interface AdapterStartStatus {
+    timeout: boolean;
+    sensorStarted: boolean;
+    hasData: boolean;
+    userInitialized?: boolean;
+    controlInitialized?: boolean;
+    interrupted?: boolean;
+}

package/lib/factories/interfaces.d.ts

@@ -1,6 +1,6 @@
 import { InterfaceProps } from "../types/interface";
 import { SerialInterface } from "../serial";
-import AntInterface from "../antv2/base/ant-interface";
+import AntInterface from "../antv2/base/interface";
 import { BleInterface } from "../ble";
 export default class InterfaceFactory {
     static create(ifaceName: string, props?: InterfaceProps): AntInterface | BleInterface | SerialInterface;

package/lib/factories/interfaces.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const serial_1 = require("../serial");
-const ant_interface_1 = __importDefault(require("../antv2/base/ant-interface"));
+const interface_1 = __importDefault(require("../antv2/base/interface"));
 const device_1 = require("../types/device");
 const ble_1 = require("../ble");
 class InterfaceFactory {
@@ -17,7 +17,7 @@ class InterfaceFactory {
                 return serial_1.SerialInterface.getInstance(serialProps);
             case device_1.INTERFACE.ANT:
                 const antProps = props;
-                return ant_interface_1.default.getInstance(antProps);
+                return interface_1.default.getInstance(antProps);
             case device_1.INTERFACE.BLE:
                 const bleProps = props;
                 return ble_1.BleInterface.getInstance(bleProps);

package/lib/serial/base/serial-interface.js

@@ -65,7 +65,7 @@ class SerialInterface extends events_1.default {
             this.logger.logEvent(event);
         }
         const w = global.window;
-        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.SERIAL_DEBUG || process.env.ANT_DEBUG || process.env.BLE_DEBUG) {
             console.log('~~~ Serial', event);
         }
     }

package/lib/serial/base/serial-scanner.js

@@ -32,7 +32,7 @@ class SinglePathScanner {
             this.logger.logEvent(event);
         }
         const w = global.window;
-        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG || process.env.ANT_DEBUG || process.env.SERIAL_DEBUG) {
             console.log('~~~ SerialScanner', event);
         }
     }
@@ -67,7 +67,7 @@ class SinglePathScanner {
                         }
                         const adapterSettings = { interface: this.serial.getName(), host, port, protocol };
                         const adapter = adapter_factory_1.default.getInstance().createInstance(adapterSettings);
-                        found = yield adapter.check();
+                        found = yield (adapter === null || adapter === void 0 ? void 0 : adapter.check());
                         if (found) {
                             this.isFound = true;
                             const name = adapter.getName();

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

@@ -65,7 +65,7 @@ class DaumClassicMockImpl {
     }
     list() {
         return __awaiter(this, void 0, void 0, function* () {
-            return binding_mock_1.MockBinding.list();
+            return yield binding_mock_1.MockBinding.list();
         });
     }
     open(options) {

package/lib/utils/utils.d.ts

@@ -4,6 +4,7 @@ export declare function runWithRetries(fn: any, maxRetries: any, timeBetween: an
 export declare function floatVal(d?: number | string): number;
 export declare function intVal(d?: number | string): number;
 export declare function hexstr(arr: any, start?: any, len?: any): string;
+export declare function isTrue(value: any): boolean;
 export declare class Queue<T> {
     protected data: Array<T>;
     constructor(values?: Array<T>);

package/lib/utils/utils.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitWithTimeout = exports.runWithTimeout = exports.Queue = exports.hexstr = exports.intVal = exports.floatVal = exports.runWithRetries = exports.resolveNextTick = exports.sleep = void 0;
+exports.waitWithTimeout = exports.runWithTimeout = exports.Queue = exports.isTrue = exports.hexstr = exports.intVal = exports.floatVal = exports.runWithRetries = exports.resolveNextTick = exports.sleep = void 0;
 const sleep = (ms) => {
     return new Promise(resolve => setTimeout(resolve, ms));
 };
@@ -92,6 +92,23 @@ function hexstr(arr, start, len) {
     return str;
 }
 exports.hexstr = hexstr;
+function isTrue(value) {
+    if (typeof (value) === 'string') {
+        value = value.trim().toLowerCase();
+    }
+    switch (value) {
+        case true:
+        case "true":
+        case 1:
+        case "1":
+        case "on":
+        case "yes":
+            return true;
+        default:
+            return false;
+    }
+}
+exports.isTrue = isTrue;
 class Queue {
     constructor(values) {
         this.data = [];

package/package.json

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