incyclist-devices 1.4.95 → 1.4.96

package/lib/ant/antfe/AntFEAdapter.js

@@ -18,8 +18,7 @@ const utils_1 = require("../utils");
 const utils_2 = require("../../utils");
 const ant_fe_st_mode_1 = __importDefault(require("./ant-fe-st-mode"));
 const ant_fe_erg_mode_1 = __importDefault(require("./ant-fe-erg-mode"));
-const floatVal = (d) => d ? parseFloat(d) : d;
-const intVal = (d) => d ? parseInt(d) : d;
+const ant_fe_adv_st_mode_1 = __importDefault(require("./ant-fe-adv-st-mode"));
 const hex = (v) => Math.abs(v).toString(16).toUpperCase();
 const TIMEOUT_ACK = 5000;
 const TIMEOUT_START = 10000;
@@ -58,7 +57,7 @@ class AntFEAdapter extends AntAdapter_1.default {
         return `${(0, utils_1.getBrand)(ManId)} FE ${DeviceID}${hrmStr}`;
     }
     getSupportedCyclingModes() {
-        return [ant_fe_st_mode_1.default, ant_fe_erg_mode_1.default];
+        return [ant_fe_st_mode_1.default, ant_fe_erg_mode_1.default, ant_fe_adv_st_mode_1.default];
     }
     setCyclingMode(mode, settings) {
         let selectedMode;

package/lib/ant/antfe/ant-fe-adv-st-mode.d.ts

@@ -0,0 +1,9 @@
+import FtmsCyclingMode from "../../ble/ble-st-mode";
+import { UpdateRequest } from "../../CyclingMode";
+import { DeviceAdapter } from "../../Device";
+export default class AntAdvSimCyclingMode extends FtmsCyclingMode {
+    constructor(adapter: DeviceAdapter, props?: any);
+    getName(): string;
+    getDescription(): string;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+}

package/lib/ant/antfe/ant-fe-adv-st-mode.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ble_st_mode_1 = __importDefault(require("../../ble/ble-st-mode"));
+const MAX_DEVIATION = 10;
+class AntAdvSimCyclingMode extends ble_st_mode_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.initLogger('AntAdvSimMode');
+    }
+    getName() {
+        return 'Advanced Smart Trainer';
+    }
+    getDescription() {
+        return 'Sends Slope to device. Respects Limits (from workout or settings). Calculates speed based on power and slope. ';
+    }
+    sendBikeUpdate(request) {
+        const getData = () => {
+            if (!this.data)
+                return {};
+            const { gear, pedalRpm, slope, power, speed } = this.data;
+            return { gear, pedalRpm, slope, power, speed };
+        };
+        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData() });
+        let newRequest = {};
+        if (request.slope === undefined && request.targetPower === undefined && request.refresh && this.prevRequest) {
+            return this.prevRequest;
+        }
+        if (request.slope !== undefined) {
+            newRequest.slope = parseFloat(request.slope.toFixed(1));
+            this.data.slope = newRequest.slope;
+        }
+        if (this.data && this.data.power) {
+            const { minPower, maxPower } = request;
+            let { targetPower } = request;
+            if (minPower !== undefined && maxPower !== undefined && minPower === maxPower)
+                targetPower = maxPower;
+            if (targetPower !== undefined && Math.abs(this.data.power - targetPower) > MAX_DEVIATION)
+                newRequest.targetPower = targetPower;
+            else if (minPower !== undefined && this.data.power < minPower)
+                newRequest.targetPower = minPower;
+            else if (request.maxPower !== undefined && this.data.power > request.maxPower)
+                newRequest.targetPower = maxPower;
+        }
+        this.prevRequest = JSON.parse(JSON.stringify(newRequest));
+        return newRequest;
+    }
+}
+exports.default = AntAdvSimCyclingMode;

package/lib/ant/antfe/ant-fe-erg-mode.d.ts

@@ -1,5 +1,6 @@
 import BleERGCyclingMode from "../../ble/ble-erg-mode";
 import { DeviceAdapter } from "../../Device";
 export default class AntFeERGCyclingMode extends BleERGCyclingMode {
+    static isERG: boolean;
     constructor(adapter: DeviceAdapter, props?: any);
 }

package/lib/ant/antfe/ant-fe-erg-mode.js

@@ -11,3 +11,4 @@ class AntFeERGCyclingMode extends ble_erg_mode_1.default {
     }
 }
 exports.default = AntFeERGCyclingMode;
+AntFeERGCyclingMode.isERG = true;

package/lib/ant/antfe/ant-fe-st-mode copy.d.ts

@@ -0,0 +1,7 @@
+import FtmsCyclingMode from "../../ble/ble-st-mode";
+import { UpdateRequest } from "../../CyclingMode";
+import { DeviceAdapter } from "../../Device";
+export default class AntStCyclingMode extends FtmsCyclingMode {
+    constructor(adapter: DeviceAdapter, props?: any);
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+}

package/lib/ant/antfe/ant-fe-st-mode copy.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ble_st_mode_1 = __importDefault(require("../../ble/ble-st-mode"));
+class AntStCyclingMode extends ble_st_mode_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.initLogger('AntSTMode');
+    }
+    sendBikeUpdate(request) {
+        console.log('~~~ SIMMode:sendBikeUpdate reuqest', request);
+        const getData = () => {
+            if (!this.data)
+                return {};
+            const { gear, pedalRpm, slope, power, speed } = this.data;
+            return { gear, pedalRpm, slope, power, speed };
+        };
+        const event = {};
+        if (this.data === undefined)
+            event.noData = true;
+        if (request.slope !== undefined && (event.noData || Math.abs(request.slope - this.data.slope) >= 0.1))
+            event.slopeUpdate = true;
+        if (this.prevRequest === undefined)
+            event.initialCall = true;
+        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData(), event });
+        let newRequest = {};
+        if (request.slope === undefined && request.targetPower === undefined && request.refresh && this.prevRequest) {
+            return this.prevRequest;
+        }
+        if (request.slope !== undefined) {
+            newRequest.slope = parseFloat(request.slope.toFixed(1));
+            this.data.slope = newRequest.slope;
+        }
+        if (request.targetPower !== undefined) {
+            newRequest.targetPower = request.targetPower;
+        }
+        if (request.minPower && request.maxPower && request.minPower === request.maxPower) {
+            newRequest.targetPower = request.minPower;
+        }
+        const prevData = this.data;
+        if (newRequest.targetPower === undefined && prevData && prevData.power) {
+            if (request.minPower !== undefined && prevData.power < request.minPower)
+                newRequest.targetPower = request.minPower;
+            if (request.maxPower !== undefined && prevData.power > request.maxPower)
+                newRequest.targetPower = request.maxPower;
+        }
+        this.prevRequest = JSON.parse(JSON.stringify(newRequest));
+        console.log('~~~ SimMode:sendBikeUpdate result', newRequest);
+        return newRequest;
+    }
+}
+exports.default = AntStCyclingMode;

package/lib/ant/antfe/ant-fe-st-mode.d.ts

@@ -1,7 +1,5 @@
 import FtmsCyclingMode from "../../ble/ble-st-mode";
-import { UpdateRequest } from "../../CyclingMode";
 import { DeviceAdapter } from "../../Device";
 export default class AntStCyclingMode extends FtmsCyclingMode {
     constructor(adapter: DeviceAdapter, props?: any);
-    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
 }

package/lib/ant/antfe/ant-fe-st-mode.js

@@ -7,46 +7,7 @@ const ble_st_mode_1 = __importDefault(require("../../ble/ble-st-mode"));
 class AntStCyclingMode extends ble_st_mode_1.default {
     constructor(adapter, props) {
         super(adapter, props);
-        this.initLogger('AntSTMode');
-    }
-    sendBikeUpdate(request) {
-        const getData = () => {
-            if (!this.data)
-                return {};
-            const { gear, pedalRpm, slope, power, speed } = this.data;
-            return { gear, pedalRpm, slope, power, speed };
-        };
-        const event = {};
-        if (this.data === undefined)
-            event.noData = true;
-        if (request.slope !== undefined && (event.noData || Math.abs(request.slope - this.data.slope) >= 0.1))
-            event.slopeUpdate = true;
-        if (this.prevRequest === undefined)
-            event.initialCall = true;
-        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData(), event });
-        let newRequest = {};
-        if (request.slope === undefined && request.targetPower === undefined && request.refresh && this.prevRequest) {
-            return this.prevRequest;
-        }
-        if (request.slope !== undefined) {
-            newRequest.slope = parseFloat(request.slope.toFixed(1));
-            this.data.slope = newRequest.slope;
-        }
-        if (request.targetPower !== undefined) {
-            newRequest.targetPower = request.targetPower;
-        }
-        if (request.minPower && request.maxPower && request.minPower === request.maxPower) {
-            newRequest.targetPower = request.minPower;
-        }
-        const prevData = this.data;
-        if (newRequest.targetPower === undefined && prevData && prevData.power) {
-            if (request.minPower !== undefined && prevData.power < request.minPower)
-                newRequest.targetPower = request.minPower;
-            if (request.maxPower !== undefined && prevData.power > request.maxPower)
-                newRequest.targetPower = request.maxPower;
-        }
-        this.prevRequest = JSON.parse(JSON.stringify(newRequest));
-        return newRequest;
+        this.initLogger('AntSimMode');
     }
 }
 exports.default = AntStCyclingMode;

package/lib/ble/ble-erg-mode.d.ts

@@ -2,6 +2,7 @@ import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } fr
 import { DeviceAdapter } from "../Device";
 import PowerBasedCyclingModeBase from "../modes/power-base";
 export default class BleERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
+    static isERG: boolean;
     prevRequest: UpdateRequest;
     hasBikeUpdate: boolean;
     chain: number[];

package/lib/ble/ble-erg-mode.js

@@ -50,21 +50,15 @@ class BleERGCyclingMode extends power_base_1.default {
                 this.prevRequest = {};
                 return request.reset ? { reset: true } : {};
             }
+            delete request.slope;
             const prevData = this.data || {};
             if (request.targetPower !== undefined) {
-                delete request.slope;
                 delete request.refresh;
             }
             if (request.refresh) {
                 delete request.refresh;
                 newRequest.targetPower = this.prevRequest.targetPower;
             }
-            if (request.slope !== undefined) {
-                if (!this.data)
-                    this.data = {};
-                this.data.slope = request.slope;
-                delete request.slope;
-            }
             if (request.maxPower !== undefined && request.minPower !== undefined && request.maxPower === request.minPower) {
                 request.targetPower = request.maxPower;
                 newRequest.targetPower = request.targetPower;
@@ -130,3 +124,4 @@ class BleERGCyclingMode extends power_base_1.default {
     }
 }
 exports.default = BleERGCyclingMode;
+BleERGCyclingMode.isERG = true;

package/lib/ble/ble-interface.js

@@ -56,9 +56,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
         if (this.logger) {
             this.logger.logEvent(event);
         }
-        if (process.env.BLE_DEBUG) {
-            console.log('~~BLE:', event);
-        }
+        console.log('~~BLE:', event);
     }
     onStateChange(state) {
         if (state !== ble_1.BleState.POWERED_ON) {
@@ -73,9 +71,6 @@ class BleInterface extends ble_1.BleInterfaceClass {
     }
     connect(props = {}) {
         const timeout = props.timeout || 2000;
-        const runBackgroundScan = () => {
-            return;
-        };
         return new Promise((resolve, reject) => {
             if (this.connectState.isConnected) {
                 return resolve(true);
@@ -124,7 +119,6 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     this.connectState.isConnecting = false;
                     this.logEvent({ message: 'connect result: success' });
                     resolve(true);
-                    runBackgroundScan();
                     return;
                 }
                 else {
@@ -144,7 +138,6 @@ class BleInterface extends ble_1.BleInterfaceClass {
                             this.connectState.isConnected = true;
                             this.connectState.isConnecting = false;
                             this.logEvent({ message: 'connect result: success' });
-                            runBackgroundScan();
                             return resolve(true);
                         }
                         else {
@@ -491,7 +484,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
     }
     scan(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { timeout = DEFAULT_SCAN_TIMEOUT, deviceTypes = [], requested, isBackgroundScan } = props;
+            const { timeout = DEFAULT_SCAN_TIMEOUT, deviceTypes = [], requested } = props;
             let profile;
             if (requested)
                 profile = requested instanceof ble_1.BleDeviceClass ?
@@ -499,7 +492,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     requested.profile;
             const { id, address, name } = requested || {};
             const scanForDevice = (requested !== null && requested !== undefined);
-            const services = (props.isBackgroundScan || !deviceTypes || deviceTypes.length === 0) ? this.getAllSupportedServices() : this.getServicesFromDeviceTypes(deviceTypes);
+            const services = (!deviceTypes || deviceTypes.length === 0) ? this.getAllSupportedServices() : this.getServicesFromDeviceTypes(deviceTypes);
             const bleBinding = this.getBinding();
             if (!bleBinding)
                 return Promise.reject(new Error('no binding defined'));
@@ -508,18 +501,14 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }
             const peripheralsProcessed = [];
             const devicesProcessed = [];
-            this.logEvent({ message: 'scan()', props: { timeout, isBackgroundScan }, scanState: this.scanState,
+            this.logEvent({ message: 'scan()', props: { timeout }, scanState: this.scanState,
                 peripheralCache: this.peripheralCache.map(i => ({ address: i.address, ts: i.ts, name: i.peripheral ? i.peripheral.advertisement.localName : '' })),
                 deviceCache: this.devices.map(i => ({ address: i.device.address, profile: i.device.getProfile(), isConnected: i.isConnected }))
             });
-            if (!props.isBackgroundScan && this.scanState.isBackgroundScan) {
-                yield this.stopScan();
-                this.scanState.isBackgroundScan = false;
-            }
             let opStr;
             if (scanForDevice) {
                 opStr = 'search device';
-                this.logEvent({ message: 'search device request', device: { id, address, name }, deviceTypes });
+                this.logEvent({ message: 'search device request', services, device: { id, address, name }, deviceTypes });
             }
             else {
                 opStr = 'scan';
@@ -538,8 +527,6 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }
             return new Promise((resolve, reject) => {
                 this.scanState.isScanning = true;
-                if (props.isBackgroundScan)
-                    this.scanState.isBackgroundScan = true;
                 if (scanForDevice) {
                     if (this.devices && this.devices.length > 0) {
                         const knownDevices = this.devices.map(i => ({ name: i.device.name, address: i.device.address, isConnected: i.isConnected, connectState: i.device.getConnectState() }));

package/lib/ble/fm.js

@@ -21,6 +21,7 @@ const power_meter_1 = __importDefault(require("../modes/power-meter"));
 const ble_st_mode_1 = __importDefault(require("./ble-st-mode"));
 const ble_erg_mode_1 = __importDefault(require("./ble-erg-mode"));
 const consts_1 = require("./consts");
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 const cwABike = {
     race: 0.35,
     triathlon: 0.29,
@@ -685,7 +686,17 @@ class FmAdapter extends Device_1.default {
                                 break;
                         }
                     }
-                    yield this.device.requestControl();
+                    let hasControl = yield this.device.requestControl();
+                    if (!hasControl) {
+                        let retry = 1;
+                        while (!hasControl && retry < 3) {
+                            yield sleep(1000);
+                            hasControl = yield this.device.requestControl();
+                            retry++;
+                        }
+                    }
+                    if (!hasControl)
+                        throw new Error('could not establish control');
                     const startRequest = this.getCyclingMode().getBikeInitRequest();
                     yield this.sendUpdate(startRequest);
                     bleDevice.on('data', (data) => {

package/lib/daum/ERGCyclingMode.d.ts

@@ -13,6 +13,7 @@ export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements
     chain: number[];
     cassette: number[];
     event: ERGEvent;
+    static isERG: boolean;
     constructor(adapter: DaumAdapter, props?: any);
     getName(): string;
     getDescription(): string;

package/lib/daum/ERGCyclingMode.js

@@ -198,3 +198,4 @@ class ERGCyclingMode extends power_base_1.default {
     }
 }
 exports.default = ERGCyclingMode;
+ERGCyclingMode.isERG = true;

package/lib/kettler/ergo-racer/ERGCyclingMode.d.ts

@@ -8,6 +8,7 @@ export declare type ERGEvent = {
     tsStart?: number;
 };
 export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
+    static isERG: boolean;
     prevRequest: UpdateRequest;
     hasBikeUpdate: boolean;
     chain: number[];

package/lib/kettler/ergo-racer/ERGCyclingMode.js

@@ -142,3 +142,4 @@ class ERGCyclingMode extends power_base_1.default {
     }
 }
 exports.default = ERGCyclingMode;
+ERGCyclingMode.isERG = true;

package/lib/modes/simulator.d.ts

@@ -9,6 +9,7 @@ export declare type ERGEvent = {
     tsStart?: number;
 };
 export default class SimulatorCyclingMode extends PowerBasedCyclingModeBase {
+    static isERG: boolean;
     logger: EventLogger;
     data: IncyclistBikeData;
     prevRequest: UpdateRequest;

package/lib/modes/simulator.js

@@ -137,3 +137,4 @@ class SimulatorCyclingMode extends power_base_1.default {
     }
 }
 exports.default = SimulatorCyclingMode;
+SimulatorCyclingMode.isERG = true;

package/package.json

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