incyclist-devices 1.4.94 → 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

@@ -71,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);
@@ -122,7 +119,6 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     this.connectState.isConnecting = false;
                     this.logEvent({ message: 'connect result: success' });
                     resolve(true);
-                    runBackgroundScan();
                     return;
                 }
                 else {
@@ -142,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 {
@@ -489,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 ?
@@ -497,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'));
@@ -506,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';
@@ -536,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() }));
@@ -566,8 +555,9 @@ class BleInterface extends ble_1.BleInterfaceClass {
                 const onPeripheralFound = (peripheral, fromCache = false) => __awaiter(this, void 0, void 0, function* () {
                     if (!peripheral || !peripheral.advertisement || !peripheral.advertisement.localName || !peripheral.advertisement.serviceUuids || peripheral.advertisement.serviceUuids.length === 0)
                         return;
-                    if (fromCache)
+                    if (fromCache) {
                         this.logEvent({ message: 'adding from Cache', peripheral: peripheral.address });
+                    }
                     else {
                         const { id, name, address, advertisement = {} } = peripheral;
                         this.logEvent({ message: 'BLE scan: found device', peripheral: { id, name, address, services: advertisement.serviceUuids } });
@@ -584,66 +574,62 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     const services = connectedServices ? connectedServices.map(cs => cs.uuid) : undefined;
                     const connectedPeripheral = connector.getPeripheral();
                     const { id, name, address, advertisement = {} } = connectedPeripheral;
-                    const DeviceClasses = this.getDeviceClasses(connectedPeripheral, { profile, services });
+                    const DeviceClasses = this.getDeviceClasses(connectedPeripheral, { profile, services }) || [];
                     this.logEvent({ message: 'BLE scan: device connected', peripheral: { id, name, address, services: advertisement.serviceUuids }, services, classes: DeviceClasses.map(c => c.prototype.constructor.name) });
                     let cntFound = 0;
-                    DeviceClasses.forEach((DeviceClass) => __awaiter(this, void 0, void 0, function* () {
-                        if (!DeviceClass)
-                            return;
-                        if (scanForDevice && cntFound > 0)
-                            return;
-                        const d = this.createDevice(DeviceClass, peripheral, characteristics);
-                        if (!d) {
-                            this.logEvent({ message: `${opStr}: could not create device `, DeviceClass });
-                            return;
-                        }
-                        try {
-                            this.logEvent({ message: `${opStr}: connecting `, device: d.name, profile: d.getProfile(), address: d.address });
-                            yield d.connect();
-                        }
-                        catch (err) {
-                            this.logEvent({ message: 'error', fn: 'onPeripheralFound()', error: err.message || err, stack: err.stack });
-                        }
-                        if (scanForDevice) {
-                            if ((id && id !== '' && d.id === id) ||
-                                (address && address !== '' && d.address === address) ||
-                                (name && name !== '' && d.name === name))
-                                cntFound++;
-                        }
-                        else
+                    const DeviceClass = DeviceClasses.sort((a, b) => (a.detectionPriority || 0 - b.detectionPriority || 0))[0];
+                    if (!DeviceClass)
+                        return;
+                    if (scanForDevice && cntFound > 0)
+                        return;
+                    const d = this.createDevice(DeviceClass, peripheral, characteristics);
+                    if (!d) {
+                        this.logEvent({ message: `${opStr}: could not create device `, DeviceClass });
+                        return;
+                    }
+                    try {
+                        this.logEvent({ message: `${opStr}: connecting `, device: d.name, profile: d.getProfile(), address: d.address });
+                        yield d.connect();
+                    }
+                    catch (err) {
+                        this.logEvent({ message: 'error', fn: 'onPeripheralFound()', error: err.message || err, stack: err.stack });
+                    }
+                    if (scanForDevice) {
+                        if ((id && id !== '' && d.id === id) ||
+                            (address && address !== '' && d.address === address) ||
+                            (name && name !== '' && d.name === name))
                             cntFound++;
-                        const existing = devicesProcessed.find(device => device.id === d.id && device.getProfile() === d.getProfile());
-                        if (!scanForDevice && cntFound > 0 && !existing) {
-                            this.logEvent({ message: `${opStr}: device found`, device: d.name, profile: d.getProfile(), address: d.address, services: d.services.join(',') });
-                            this.addDeviceToCache(d, peripheral.state === 'connected');
-                            devicesProcessed.push(d);
-                            this.emit('device', d);
-                            return;
-                        }
-                        if (scanForDevice && cntFound > 0) {
-                            this.logEvent({ message: `${opStr}: device found`, device: d.name, profile: d.getProfile(), address: d.address, services: d.services.join(',') });
-                            this.addDeviceToCache(d, peripheral.state === 'connected');
-                            devicesProcessed.push(d);
-                            this.emit('device', d);
-                            process.nextTick(() => {
-                                if (this.scanState.timeout) {
-                                    clearTimeout(this.scanState.timeout);
-                                    this.scanState.timeout = null;
-                                }
-                                this.logEvent({ message: `${opStr}: stop scanning`, requested: scanForDevice ? { name, address, profile } : undefined, });
-                                bleBinding.stopScanning(() => {
-                                    this.getBinding().removeAllListeners('discover');
-                                    this.scanState.isScanning = false;
-                                    resolve([d]);
-                                });
+                    }
+                    else
+                        cntFound++;
+                    const existing = devicesProcessed.find(device => device.id === d.id && device.getProfile() === d.getProfile());
+                    if (!scanForDevice && cntFound > 0 && !existing) {
+                        this.logEvent({ message: `${opStr}: device found`, device: d.name, profile: d.getProfile(), address: d.address, services: d.services.join(',') });
+                        this.addDeviceToCache(d, peripheral.state === 'connected');
+                        devicesProcessed.push(d);
+                        this.emit('device', d);
+                        return;
+                    }
+                    if (scanForDevice && cntFound > 0) {
+                        this.logEvent({ message: `${opStr}: device found`, device: d.name, profile: d.getProfile(), address: d.address, services: d.services.join(',') });
+                        this.addDeviceToCache(d, peripheral.state === 'connected');
+                        devicesProcessed.push(d);
+                        this.emit('device', d);
+                        process.nextTick(() => {
+                            if (this.scanState.timeout) {
+                                clearTimeout(this.scanState.timeout);
+                                this.scanState.timeout = null;
+                            }
+                            this.logEvent({ message: `${opStr}: stop scanning`, requested: scanForDevice ? { name, address, profile } : undefined, });
+                            bleBinding.stopScanning(() => {
+                                this.getBinding().removeAllListeners('discover');
+                                this.scanState.isScanning = false;
+                                resolve([d]);
                             });
-                        }
-                    }));
+                        });
+                    }
                 });
                 this.logEvent({ message: `${opStr}: start scanning`, requested: scanForDevice ? { name, address, profile } : undefined, timeout });
-                this.peripheralCache.forEach(i => {
-                    onPeripheralFound(i.peripheral, true);
-                });
                 let services = [];
                 if (scanForDevice) {
                     if (props.requested instanceof ble_1.BleDeviceClass) {

package/lib/ble/fm.d.ts

@@ -45,6 +45,7 @@ declare type IndoorBikeFeatures = {
 export default class BleFitnessMachineDevice extends BleDevice {
     static services: string[];
     static characteristics: string[];
+    static detectionPriority: number;
     data: IndoorBikeData;
     features: IndoorBikeFeatures;
     hasControl: boolean;

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,
@@ -101,7 +102,6 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         const hasStatus = characteristics.find(c => c === consts_1.FTMS_STATUS) !== undefined;
         const hasCP = characteristics.find(c => c === consts_1.FTMS_CP) !== undefined;
         const hasIndoorBike = characteristics.find(c => c === consts_1.INDOOR_BIKE_DATA) !== undefined;
-        const hasTacx = characteristics.find(c => c === consts_1.TACX_FE_C_RX) !== undefined && characteristics.find(c => c === consts_1.TACX_FE_C_TX) !== undefined;
         return hasStatus && hasCP && hasIndoorBike;
     }
     subscribeWriteResponse(cuuid) {
@@ -185,8 +185,8 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         return BleFitnessMachineDevice.services;
     }
     isBike() {
-        return this.features !== undefined &&
-            (this.features.targetSettings & TargetSettingFeatureFlag.IndoorBikeSimulationParametersSupported) !== 0;
+        return this.features === undefined ||
+            ((this.features.targetSettings & TargetSettingFeatureFlag.IndoorBikeSimulationParametersSupported) !== 0);
     }
     isPower() {
         if (this.hasService('1818'))
@@ -539,6 +539,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
 exports.default = BleFitnessMachineDevice;
 BleFitnessMachineDevice.services = [consts_1.FTMS];
 BleFitnessMachineDevice.characteristics = ['2acc', consts_1.INDOOR_BIKE_DATA, '2ad6', '2ad8', consts_1.FTMS_CP, consts_1.FTMS_STATUS];
+BleFitnessMachineDevice.detectionPriority = 100;
 ble_interface_1.default.register('BleFitnessMachineDevice', 'fm', BleFitnessMachineDevice, BleFitnessMachineDevice.services);
 class FmAdapter extends Device_1.default {
     constructor(device, protocol) {
@@ -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/ble/hrm.d.ts

@@ -14,6 +14,7 @@ declare type HrmData = {
 export default class BleHrmDevice extends BleDevice {
     static services: string[];
     static characteristics: string[];
+    static detectionPriority: number;
     heartrate: number;
     rr: number;
     constructor(props?: any);

package/lib/ble/hrm.js

@@ -65,6 +65,7 @@ class BleHrmDevice extends ble_device_1.BleDevice {
 exports.default = BleHrmDevice;
 BleHrmDevice.services = ['180d'];
 BleHrmDevice.characteristics = ['2a37', '2a38', '2a39', '2a3c'];
+BleHrmDevice.detectionPriority = 1;
 ble_interface_1.default.register('BleHrmDevice', 'hr', BleHrmDevice, BleHrmDevice.services);
 class HrmAdapter extends Device_1.default {
     constructor(device, protocol) {

package/lib/ble/pwr.d.ts

@@ -24,6 +24,7 @@ declare type CrankData = {
 export default class BleCyclingPowerDevice extends BleDevice {
     static services: string[];
     static characteristics: string[];
+    static detectionPriority: number;
     instantaneousPower: number;
     balance: number;
     accTorque: number;

package/lib/ble/pwr.js

@@ -163,6 +163,7 @@ class BleCyclingPowerDevice extends ble_device_1.BleDevice {
 exports.default = BleCyclingPowerDevice;
 BleCyclingPowerDevice.services = [consts_1.CSP];
 BleCyclingPowerDevice.characteristics = [consts_1.CSP_MEASUREMENT, consts_1.CSP_FEATURE, '2a5d', '2a3c'];
+BleCyclingPowerDevice.detectionPriority = 1;
 ble_interface_1.default.register('BleCyclingPowerDevice', 'cp', BleCyclingPowerDevice, BleCyclingPowerDevice.services);
 class PwrAdapter extends Device_1.default {
     constructor(device, protocol) {

package/lib/ble/tacx.d.ts

@@ -28,6 +28,7 @@ export default class TacxAdvancedFitnessMachineDevice extends BleFitnessMachineD
     static services: string[];
     static characteristics: string[];
     static PROFILE: string;
+    static detectionPriority: number;
     prevCrankData: CrankData;
     currentCrankData: CrankData;
     timeOffset: number;

package/lib/ble/tacx.js

@@ -84,7 +84,6 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
             return false;
         const hasTacxCP = characteristics.find(c => (0, ble_1.matches)(c, consts_1.TACX_FE_C_RX)) !== undefined &&
             characteristics.find(c => (0, ble_1.matches)(c, consts_1.TACX_FE_C_TX)) !== undefined;
-        const hasFTMS = characteristics.find(c => (0, ble_1.matches)(c, consts_1.FTMS_CP)) !== undefined;
         return hasTacxCP;
     }
     setCharacteristicUUIDs(uuids) {
@@ -658,6 +657,7 @@ exports.default = TacxAdvancedFitnessMachineDevice;
 TacxAdvancedFitnessMachineDevice.services = [consts_1.TACX_FE_C_BLE];
 TacxAdvancedFitnessMachineDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada', consts_1.TACX_FE_C_RX, consts_1.TACX_FE_C_TX];
 TacxAdvancedFitnessMachineDevice.PROFILE = PROFILE_ID;
+TacxAdvancedFitnessMachineDevice.detectionPriority = 10;
 ble_interface_1.default.register('TacxBleFEDevice', 'tacx-ble-fec', TacxAdvancedFitnessMachineDevice, TacxAdvancedFitnessMachineDevice.services);
 class TacxBleFEAdapter extends fm_1.FmAdapter {
     constructor(device, protocol) {

package/lib/ble/wahoo-kickr.d.ts

@@ -42,6 +42,7 @@ declare type CrankData = {
 export default class WahooAdvancedFitnessMachineDevice extends BleFitnessMachineDevice {
     static services: string[];
     static characteristics: string[];
+    static detectionPriority: number;
     prevCrankData: CrankData;
     currentCrankData: CrankData;
     timeOffset: number;

package/lib/ble/wahoo-kickr.js

@@ -424,6 +424,7 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
 exports.default = WahooAdvancedFitnessMachineDevice;
 WahooAdvancedFitnessMachineDevice.services = [consts_1.CSP];
 WahooAdvancedFitnessMachineDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada', consts_1.WAHOO_ADVANCED_TRAINER_CP];
+WahooAdvancedFitnessMachineDevice.detectionPriority = 5;
 ble_interface_1.default.register('WahooAdvancedFitnessMachineDevice', 'wahoo-fm', WahooAdvancedFitnessMachineDevice, WahooAdvancedFitnessMachineDevice.services);
 class WahooAdvancedFmAdapter extends fm_1.FmAdapter {
     constructor(device, protocol) {

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.94",
+  "version": "1.4.96",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",