incyclist-devices 1.4.93 → 1.4.95

package/lib/Device.js

@@ -9,7 +9,7 @@ class IncyclistDevice {
         this.detected = false;
         this.selected = false;
         this.onDataFn = undefined;
-        this.settings = settings;
+        this.settings = settings || {};
     }
     isBike() { throw new Error('not implemented'); }
     isPower() { throw new Error('not implemented'); }

package/lib/ant/antpwr/pwr-adapter.d.ts

@@ -36,6 +36,7 @@ export default class AntFEAdapter extends AntAdapter {
     getDisplayName(): string;
     getCyclingMode(): CyclingMode;
     getDefaultCyclingMode(): CyclingMode;
+    getSupportedCyclingModes(): any[];
     onAttached(): void;
     getLogData(data: any, excludeList: any): any;
     onDeviceData(deviceData: AntPwrData): void;

package/lib/ant/antpwr/pwr-adapter.js

@@ -58,6 +58,9 @@ class AntFEAdapter extends AntAdapter_1.default {
     getDefaultCyclingMode() {
         return new power_meter_1.default(this);
     }
+    getSupportedCyclingModes() {
+        return [power_meter_1.default];
+    }
     onAttached() {
         this.logger.logEvent({ message: 'Device connected' });
         this.connected = true;

package/lib/ble/ble-device.d.ts

@@ -35,6 +35,7 @@ export declare abstract class BleDevice extends BleDeviceClass {
     workerIv: NodeJS.Timeout;
     prevMessages: MessageLog[];
     constructor(props?: BleDeviceConstructProps);
+    getServices(): string[];
     logEvent(event: any): void;
     setLogger(logger: EventLogger): void;
     setInterface(ble: BleInterfaceClass): void;
@@ -51,7 +52,7 @@ export declare abstract class BleDevice extends BleDeviceClass {
     disconnect(): Promise<boolean>;
     abstract getProfile(): string;
     checkForDuplicate(characteristic: string, data: Buffer): boolean;
-    onData(characteristic: string, data: Buffer): void;
+    onData(characteristic: string, _data: Buffer): boolean;
     timeoutCheck(): void;
     startWorker(): void;
     stopWorker(): void;

package/lib/ble/ble-device.js

@@ -47,13 +47,14 @@ class BleDevice extends ble_1.BleDeviceClass {
             this.logger = new gd_eventlog_1.EventLogger('BleDevice');
         }
     }
+    getServices() {
+        return this.services;
+    }
     logEvent(event) {
         if (this.logger) {
             this.logger.logEvent(event);
         }
-        if (process.env.BLE_DEBUG) {
-            console.log('~~~BLE:', event);
-        }
+        console.log('~~~BLE:', event);
     }
     setLogger(logger) {
         this.logger = logger;
@@ -80,8 +81,12 @@ class BleDevice extends ble_1.BleDeviceClass {
         this.state = "disconnected";
         if (!this.connectState.isDisconnecting) {
             this.peripheral.state = 'disconnected';
+            this.connectState.isConnecting = false;
             this.connectState.isConnected = false;
-            this.connect();
+            this.cleanupListeners();
+            this.subscribedCharacteristics = [];
+            this.ble.onDisconnect(this.peripheral);
+            this.connect({ reconnect: true });
         }
         this.emit('disconnected');
     }
@@ -128,6 +133,7 @@ class BleDevice extends ble_1.BleDeviceClass {
             this.connectState.isConnecting = true;
             try {
                 const connector = this.ble.getConnector(peripheral);
+                connector.on('disconnect', () => { this.onDisconnect(); });
                 yield connector.connect();
                 yield connector.initialize();
                 yield this.subscribeAll(connector);
@@ -156,9 +162,10 @@ class BleDevice extends ble_1.BleDeviceClass {
     }
     connect(props) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { reconnect } = props || {};
             try {
-                this.logEvent({ message: 'connect', address: this.peripheral ? this.peripheral.address : this.address, state: this.connectState });
-                if (this.connectState.isConnecting) {
+                this.logEvent({ message: reconnect ? 'reconnect' : 'connect', address: this.peripheral ? this.peripheral.address : this.address, state: this.connectState });
+                if (!reconnect && this.connectState.isConnecting) {
                     yield this.waitForConnectFinished(CONNECT_WAIT_TIMEOUT);
                 }
                 if (this.connectState.isConnected) {
@@ -238,6 +245,8 @@ class BleDevice extends ble_1.BleDeviceClass {
             }
             if (!this.connectState.isConnecting && !this.connectState.isConnected) {
                 this.connectState.isDisconnecting = false;
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = false;
                 this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
                 return true;
             }
@@ -245,13 +254,17 @@ class BleDevice extends ble_1.BleDeviceClass {
                 this.cleanupListeners();
                 setTimeout(() => { this.connectState.isDisconnecting = false; }, 1000);
                 this.logEvent({ message: 'disconnect result: unclear - connect ongoing', device: { id, name, address } });
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = false;
                 return true;
             }
             if (this.connectState.isConnected) {
                 this.ble.removeConnectedDevice(this);
                 this.cleanupListeners();
-                setTimeout(() => { this.connectState.isDisconnecting = false; }, 1000);
                 this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
+                this.connectState.isDisconnecting = false;
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = false;
                 return true;
             }
         });
@@ -273,10 +286,11 @@ class BleDevice extends ble_1.BleDeviceClass {
         }
         return false;
     }
-    onData(characteristic, data) {
+    onData(characteristic, _data) {
+        const data = Buffer.from(_data);
         const isDuplicate = this.checkForDuplicate(characteristic, data);
         if (isDuplicate) {
-            return;
+            return false;
         }
         this.logEvent({ message: 'got data', characteristic, data: data.toString('hex'), writeQueue: this.writeQueue.length });
         if (this.writeQueue.length > 0) {
@@ -286,8 +300,10 @@ class BleDevice extends ble_1.BleDeviceClass {
                 this.writeQueue.splice(writeIdx, 1);
                 if (writeItem.resolve)
                     writeItem.resolve(data);
+                return false;
             }
         }
+        return true;
     }
     timeoutCheck() {
         const now = Date.now();
@@ -321,6 +337,8 @@ class BleDevice extends ble_1.BleDeviceClass {
     write(characteristicUuid, data, props) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                if (!this.isConnected())
+                    throw new Error('not connected');
                 const { withoutResponse, timeout } = props || {};
                 const connector = this.ble.getConnector(this.peripheral);
                 const isAlreadySubscribed = connector.isSubscribed(characteristicUuid);
@@ -380,6 +398,8 @@ class BleDevice extends ble_1.BleDeviceClass {
     }
     read(characteristicUuid) {
         return new Promise((resolve, reject) => {
+            if (!this.isConnected())
+                return reject(new Error('not connected'));
             const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
             if (!characteristic) {
                 reject(new Error('Characteristic not found'));

package/lib/ble/ble-interface.d.ts

@@ -67,6 +67,7 @@ export default class BleInterface extends BleInterfaceClass {
     getServicesFromDevice(device: BleDeviceClass): string[];
     waitForConnectFinished(timeout: any): Promise<unknown>;
     addPeripheralToCache(peripheral: any, props?: {}): void;
+    onDisconnect(peripheral: any): void;
     getConnector(peripheral: BlePeripheral): any;
     findPeripheral(peripheral: BlePeripheral | {
         id?: string;

package/lib/ble/ble-interface.js

@@ -56,7 +56,9 @@ class BleInterface extends ble_1.BleInterfaceClass {
         if (this.logger) {
             this.logger.logEvent(event);
         }
-        console.log('~~BLE:', event);
+        if (process.env.BLE_DEBUG) {
+            console.log('~~BLE:', event);
+        }
     }
     onStateChange(state) {
         if (state !== ble_1.BleState.POWERED_ON) {
@@ -290,6 +292,11 @@ class BleInterface extends ble_1.BleInterfaceClass {
         const connector = info && info.connector ? info.connector : new ble_peripheral_1.default(this, peripheral);
         this.peripheralCache.push(Object.assign({ address: peripheral.address, ts: Date.now(), peripheral, connector }, props));
     }
+    onDisconnect(peripheral) {
+        const idx = this.peripheralCache.findIndex(i => i.address === peripheral.address);
+        if (idx !== -1)
+            this.peripheralCache.splice(idx, 1);
+    }
     getConnector(peripheral) {
         const info = this.peripheralCache.find(i => i.address === peripheral.address);
         if (!info) {
@@ -411,7 +418,8 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     if (devices && devices.length > 0) {
                         for (let i = 0; i < devices.length; i++) {
                             const idx = this.devices.push({ device: devices[i], isConnected: false }) - 1;
-                            yield devices[i].connect();
+                            if (!devices[i].isConnected())
+                                yield devices[i].connect();
                             this.devices[idx].isConnected = true;
                         }
                     }
@@ -558,14 +566,15 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     });
                 };
                 const onPeripheralFound = (peripheral, fromCache = false) => __awaiter(this, void 0, void 0, function* () {
-                    if (fromCache)
+                    if (!peripheral || !peripheral.advertisement || !peripheral.advertisement.localName || !peripheral.advertisement.serviceUuids || peripheral.advertisement.serviceUuids.length === 0)
+                        return;
+                    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 } });
                     }
-                    if (!peripheral || !peripheral.advertisement || !peripheral.advertisement.serviceUuids || peripheral.advertisement.serviceUuids.length === 0)
-                        return;
                     if (peripheral.address === undefined || peripheral.address === '')
                         peripheral.address = peripheral.id;
                     const isPeripheralProcessed = peripheralsProcessed.find(p => p === peripheral.address) !== undefined;
@@ -578,67 +587,70 @@ 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);
-                });
-                bleBinding.startScanning([], true, (err) => {
+                let services = [];
+                if (scanForDevice) {
+                    if (props.requested instanceof ble_1.BleDeviceClass) {
+                        const device = props.requested;
+                        services = (device.getServices()) || [];
+                    }
+                }
+                bleBinding.startScanning(services, false, (err) => {
                     if (err) {
                         this.logEvent({ message: `${opStr} result: error`, requested: scanForDevice ? { name, address, profile } : undefined, error: err.message });
                         this.scanState.isScanning = false;

package/lib/ble/ble-peripheral.d.ts

@@ -24,7 +24,7 @@ export default class BlePeripheralConnector {
     initialize(enforce?: boolean): Promise<void>;
     isSubscribed(characteristicUuid: string): boolean;
     subscribeAll(callback: (characteristicUuid: string, data: any) => void): Promise<string[]>;
-    subscribe(characteristicUuid: string): Promise<boolean>;
+    subscribe(characteristicUuid: string, timeout?: number): Promise<boolean>;
     onData(characteristicUuid: string, data: any): void;
     on(characteristicUuid: string, callback: (characteristicUuid: string, data: any) => void): void;
     off(characteristicUuid: string, callback: (characteristicUuid: string, data: any) => void): void;

package/lib/ble/ble-peripheral.js

@@ -22,7 +22,7 @@ class BlePeripheralConnector {
         this.emitter = new events_1.default();
         if (!this.peripheral || !this.ble)
             throw new Error('Illegal Arguments');
-        this.state = { isConnected: false, isConnecting: false, isInitialized: false, isInitializing: false, isSubscribing: false };
+        this.state = { subscribed: [], isConnected: false, isConnecting: false, isInitialized: false, isInitializing: false, isSubscribing: false };
         this.services = undefined;
         this.characteristics = undefined;
         this.logger = new gd_eventlog_1.EventLogger('BLE');
@@ -31,7 +31,9 @@ class BlePeripheralConnector {
         if (this.logger) {
             this.logger.logEvent(event);
         }
-        console.log('~~~BLE:', event);
+        if (process.env.BLE_DEBUG) {
+            console.log('~~~BLE:', event);
+        }
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -40,9 +42,10 @@ class BlePeripheralConnector {
             this.logEvent({ message: 'connect', peripheral: this.peripheral.address, state: this.state });
             this.state.isConnecting = true;
             try {
+                this.peripheral.on('connect', () => { console.log('~~~ peripheral connected', this.peripheral); });
+                this.peripheral.on('disconnect', () => { this.onDisconnect(); });
                 if (!this.state.isConnected || (this.peripheral && this.peripheral.state !== 'connected')) {
                     yield this.peripheral.connectAsync();
-                    this.peripheral.once('disconnect', this.onDisconnect.bind(this));
                 }
                 this.state.isConnected = this.peripheral.state === 'connected';
             }
@@ -58,9 +61,12 @@ class BlePeripheralConnector {
         });
     }
     onDisconnect() {
+        this.peripheral.removeAllListeners('connect');
+        this.peripheral.removeAllListeners('disconnect');
         this.logEvent({ message: 'onDisconnected', peripheral: this.peripheral.address, state: this.state });
         this.state.isConnected = false;
-        this.reconnect();
+        this.state.isConnecting = false;
+        this.emitter.emit('disconnect');
     }
     initialize(enforce = false) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -108,7 +114,7 @@ class BlePeripheralConnector {
                         this.logEvent({ message: 'subscribe', peripheral: this.peripheral.address, characteristic: c.uuid, uuid: (0, ble_1.uuid)(c.uuid) });
                         if (this.state.subscribed.find(uuid => uuid === c.uuid) === undefined) {
                             try {
-                                yield this.subscribe(c.uuid);
+                                yield this.subscribe(c.uuid, 3000);
                                 subscribed.push(c.uuid);
                             }
                             catch (err) {
@@ -126,8 +132,8 @@ class BlePeripheralConnector {
             return subscribed;
         });
     }
-    subscribe(characteristicUuid) {
-        this.logEvent({ message: 'subscribe', characteristic: characteristicUuid, characteristics: this.characteristics.map(c => ({ characteristic: c.uuid, uuid: (0, ble_1.uuid)(c.uuid) })) });
+    subscribe(characteristicUuid, timeout) {
+        this.logEvent({ message: 'subscribe attempt', characteristic: characteristicUuid, characteristics: this.characteristics.map(c => ({ characteristic: c.uuid, uuid: (0, ble_1.uuid)(c.uuid) })) });
         return new Promise((resolve, reject) => {
             try {
                 const characteristic = this.characteristics.find(c => (0, ble_1.uuid)(c.uuid) === (0, ble_1.uuid)(characteristicUuid) || (0, ble_1.uuid)(c.uuid) === (0, ble_1.uuid)(characteristicUuid));
@@ -135,17 +141,21 @@ class BlePeripheralConnector {
                     reject(new Error('Characteristic not found'));
                     return;
                 }
-                this.logEvent({ message: 'subscribe', peripheral: this.peripheral.address, characteristic: characteristic.uuid, uuid: (0, ble_1.uuid)(characteristic.uuid) });
+                this.logEvent({ message: 'subscribe', peripheral: this.peripheral.address, characteristic: characteristic.uuid });
                 characteristic.removeAllListeners('data');
                 characteristic.on('data', (data, _isNotification) => {
                     this.onData((0, ble_1.uuid)(characteristicUuid), data);
                 });
-                const to = setTimeout(() => {
-                    this.logEvent({ message: 'subscribe result', characteristic: characteristicUuid, error: 'timeout' });
-                    reject(new Error('timeout'));
-                }, 3000);
+                let to;
+                if (timeout) {
+                    to = setTimeout(() => {
+                        this.logEvent({ message: 'subscribe result', characteristic: characteristicUuid, error: 'timeout' });
+                        reject(new Error('timeout'));
+                    }, timeout);
+                }
                 characteristic.subscribe((err) => {
-                    clearTimeout(to);
+                    if (to)
+                        clearTimeout(to);
                     this.logEvent({ message: 'subscribe result', characteristic: characteristicUuid, error: err });
                     if (err)
                         reject(err);

package/lib/ble/ble.d.ts

@@ -3,6 +3,7 @@ import EventEmitter from "events";
 import BlePeripheralConnector from "./ble-peripheral";
 export declare type ConnectProps = {
     timeout?: number;
+    reconnect?: boolean;
 };
 export interface BleDeviceIdentifier {
     id?: string;
@@ -42,6 +43,7 @@ export declare abstract class BleDeviceClass extends EventEmitter {
     abstract connect(props?: ConnectProps): Promise<boolean>;
     abstract disconnect(): Promise<boolean>;
     abstract getDeviceInfo(): Promise<BleDeviceInfo>;
+    abstract getServices(): string[];
     setCharacteristicUUIDs(uuids: string[]): void;
 }
 export interface BleWriteProps {
@@ -78,6 +80,7 @@ export declare abstract class BleInterfaceClass extends EventEmitter {
     abstract scan(props: ScanProps): Promise<BleDeviceClass[]>;
     abstract stopScan(): Promise<boolean>;
     abstract disconnect(): Promise<boolean>;
+    abstract onDisconnect(peripheral: BlePeripheral): void;
     abstract isScanning(): boolean;
     abstract addConnectedDevice(device: BleDeviceClass): void;
     abstract removeConnectedDevice(device: BleDeviceClass): void;

package/lib/ble/fm.d.ts

@@ -8,6 +8,7 @@ import { DeviceProtocol } from '../DeviceProtocol';
 import { EventLogger } from 'gd-eventlog';
 import CyclingMode from '../CyclingMode';
 import { IncyclistBikeData } from '../CyclingMode';
+import BlePeripheralConnector from './ble-peripheral';
 declare type PowerData = {
     instantaneousPower?: number;
     balance?: number;
@@ -25,7 +26,9 @@ export declare type IndoorBikeData = {
     resistanceLevel?: number;
     instantaneousPower?: number;
     averagePower?: number;
-    expendedEnergy?: number;
+    totalEnergy?: number;
+    energyPerHour?: number;
+    energyPerMinute?: number;
     heartrate?: number;
     metabolicEquivalent?: number;
     time?: number;
@@ -42,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;
@@ -54,6 +58,7 @@ export default class BleFitnessMachineDevice extends BleDevice {
     constructor(props?: any);
     isMatching(characteristics: string[]): boolean;
     subscribeWriteResponse(cuuid: string): Promise<void>;
+    subscribeAll(conn?: BlePeripheralConnector): Promise<void>;
     init(): Promise<boolean>;
     onDisconnect(): void;
     getProfile(): string;
@@ -71,7 +76,7 @@ export default class BleFitnessMachineDevice extends BleDevice {
     parseIndoorBikeData(_data: Uint8Array): IndoorBikeData;
     parseFitnessMachineStatus(_data: Uint8Array): IndoorBikeData;
     getFitnessMachineFeatures(): Promise<IndoorBikeFeatures>;
-    onData(characteristic: string, data: Buffer): void;
+    onData(characteristic: string, data: Buffer): boolean;
     writeFtmsMessage(requestedOpCode: any, data: any, props?: BleWriteProps): Promise<number>;
     requestControl(): Promise<boolean>;
     setTargetPower(power: number): Promise<boolean>;

package/lib/ble/fm.js

@@ -93,6 +93,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         this.windSpeed = 0;
         this.wheelSize = 2100;
         this.data = {};
+        this.services = BleFitnessMachineDevice.services;
     }
     isMatching(characteristics) {
         if (!characteristics)
@@ -100,7 +101,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) {
@@ -125,13 +125,44 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
             }
         });
     }
+    subscribeAll(conn) {
+        return new Promise(resolve => {
+            const characteristics = [consts_1.INDOOR_BIKE_DATA, consts_1.FTMS_STATUS, consts_1.FTMS_CP];
+            const timeout = Date.now() + 5500;
+            const iv = setInterval(() => {
+                const subscriptionStatus = characteristics.map(c => this.subscribedCharacteristics.find(s => s === c) !== undefined);
+                const done = subscriptionStatus.filter(s => s === true).length === characteristics.length;
+                if (done || Date.now() > timeout) {
+                    clearInterval(iv);
+                    resolve();
+                }
+            }, 100);
+            try {
+                const connector = conn || this.ble.getConnector(this.peripheral);
+                for (let i = 0; i < characteristics.length; i++) {
+                    const c = characteristics[i];
+                    const isAlreadySubscribed = connector.isSubscribed(c);
+                    if (!isAlreadySubscribed) {
+                        connector.removeAllListeners(c);
+                        connector.on(c, (uuid, data) => {
+                            this.onData(uuid, data);
+                        });
+                        connector.subscribe(c);
+                        this.subscribedCharacteristics.push(c);
+                    }
+                }
+            }
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: 'subscribeAll()', error: err.message, stack: err.stack });
+            }
+        });
+    }
     init() {
         const _super = Object.create(null, {
             initDevice: { get: () => super.initDevice }
         });
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                yield this.subscribeWriteResponse(consts_1.FTMS_CP);
                 yield _super.initDevice.call(this);
                 yield this.getFitnessMachineFeatures();
                 this.logEvent({ message: 'device info', deviceInfo: this.deviceInfo, features: this.features });
@@ -153,8 +184,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'))
@@ -180,6 +211,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
             }
         }
         catch (err) {
+            this.logEvent({ message: 'error', fn: 'parseHrm()', error: err.message | err, stack: err.stack });
         }
         return Object.assign(Object.assign({}, this.data), { raw: `2a37:${data.toString('hex')}` });
     }
@@ -191,99 +223,113 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
     getWindSpeed() { return this.windSpeed; }
     parseIndoorBikeData(_data) {
         const data = Buffer.from(_data);
-        const flags = data.readUInt16LE(0);
-        let offset = 2;
-        if ((flags & IndoorBikeDataFlag.MoreData) === 0) {
-            this.data.speed = data.readUInt16LE(offset) / 100;
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.AverageSpeedPresent) {
-            this.data.averageSpeed = data.readUInt16LE(offset) / 100;
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.InstantaneousCadence) {
-            this.data.cadence = data.readUInt16LE(offset) / 2;
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.AverageCadencePresent) {
-            this.data.averageCadence = data.readUInt16LE(offset) / 2;
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.TotalDistancePresent) {
-            const dvLow = data.readUInt8(offset);
-            offset += 1;
-            const dvHigh = data.readUInt16LE(offset);
-            offset += 2;
-            this.data.totalDistance = (dvHigh << 8) + dvLow;
-        }
-        if (flags & IndoorBikeDataFlag.ResistanceLevelPresent) {
-            this.data.resistanceLevel = data.readInt16LE(offset);
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.InstantaneousPowerPresent) {
-            this.data.instantaneousPower = data.readInt16LE(offset);
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.AveragePowerPresent) {
-            this.data.averagePower = data.readInt16LE(offset);
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.ExpendedEnergyPresent) {
-            this.data.expendedEnergy = data.readUInt16LE(offset);
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.HeartRatePresent) {
-            this.data.heartrate = data.readUInt16LE(offset);
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.MetabolicEquivalentPresent) {
-            this.data.metabolicEquivalent = data.readUInt16LE(offset) / 10;
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.ElapsedTimePresent) {
-            this.data.time = data.readUInt16LE(offset);
-            offset += 2;
+        try {
+            const flags = data.readUInt16LE(0);
+            let offset = 2;
+            if ((flags & IndoorBikeDataFlag.MoreData) === 0) {
+                this.data.speed = data.readUInt16LE(offset) / 100;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.AverageSpeedPresent) {
+                this.data.averageSpeed = data.readUInt16LE(offset) / 100;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.InstantaneousCadence) {
+                this.data.cadence = data.readUInt16LE(offset) / 2;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.AverageCadencePresent) {
+                this.data.averageCadence = data.readUInt16LE(offset) / 2;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.TotalDistancePresent) {
+                const dvLow = data.readUInt8(offset);
+                offset += 1;
+                const dvHigh = data.readUInt16LE(offset);
+                offset += 2;
+                this.data.totalDistance = (dvHigh << 8) + dvLow;
+            }
+            if (flags & IndoorBikeDataFlag.ResistanceLevelPresent) {
+                this.data.resistanceLevel = data.readInt8(offset);
+                offset += 1;
+            }
+            if (flags & IndoorBikeDataFlag.InstantaneousPowerPresent) {
+                this.data.instantaneousPower = data.readInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.AveragePowerPresent) {
+                this.data.averagePower = data.readInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.ExpendedEnergyPresent) {
+                this.data.totalEnergy = data.readUInt16LE(offset);
+                offset += 2;
+                this.data.energyPerHour = data.readUInt16LE(offset);
+                offset += 2;
+                this.data.energyPerMinute = data.readUInt8(offset);
+                offset += 1;
+            }
+            if (flags & IndoorBikeDataFlag.HeartRatePresent) {
+                this.data.heartrate = data.readUInt8(offset);
+                offset += 1;
+            }
+            if (flags & IndoorBikeDataFlag.MetabolicEquivalentPresent) {
+                this.data.metabolicEquivalent = data.readUInt8(offset) / 10;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.ElapsedTimePresent) {
+                this.data.time = data.readUInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.RemainingTimePresent) {
+                this.data.remainingTime = data.readUInt16LE(offset);
+                offset += 2;
+            }
         }
-        if (flags & IndoorBikeDataFlag.RemainingTimePresent) {
-            this.data.remainingTime = data.readUInt16LE(offset);
-            offset += 2;
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'parseIndoorBikeData()', error: err.message | err, stack: err.stack });
         }
         return Object.assign(Object.assign({}, this.data), { raw: `2ad2:${data.toString('hex')}` });
     }
     parseFitnessMachineStatus(_data) {
         const data = Buffer.from(_data);
-        const OpCode = data.readUInt8(0);
-        switch (OpCode) {
-            case 8:
-                this.data.targetPower = data.readInt16LE(1);
-                break;
-            case 6:
-                this.data.targetInclination = data.readInt16LE(1) / 10;
-                break;
-            case 4:
-                this.data.status = "STARTED";
-                break;
-            case 3:
-            case 2:
-                this.data.status = "STOPPED";
-                break;
-            case 20:
-                const spinDownStatus = data.readUInt8(1);
-                switch (spinDownStatus) {
-                    case 1:
-                        this.data.status = "SPIN DOWN REQUESTED";
-                        break;
-                    case 2:
-                        this.data.status = "SPIN DOWN SUCCESS";
-                        break;
-                    case 3:
-                        this.data.status = "SPIN DOWN ERROR";
-                        break;
-                    case 4:
-                        this.data.status = "STOP PEDALING";
-                        break;
-                    default: break;
-                }
+        try {
+            const OpCode = data.readUInt8(0);
+            switch (OpCode) {
+                case 8:
+                    this.data.targetPower = data.readInt16LE(1);
+                    break;
+                case 6:
+                    this.data.targetInclination = data.readInt16LE(1) / 10;
+                    break;
+                case 4:
+                    this.data.status = "STARTED";
+                    break;
+                case 3:
+                case 2:
+                    this.data.status = "STOPPED";
+                    break;
+                case 20:
+                    const spinDownStatus = data.readUInt8(1);
+                    switch (spinDownStatus) {
+                        case 1:
+                            this.data.status = "SPIN DOWN REQUESTED";
+                            break;
+                        case 2:
+                            this.data.status = "SPIN DOWN SUCCESS";
+                            break;
+                        case 3:
+                            this.data.status = "SPIN DOWN ERROR";
+                            break;
+                        case 4:
+                            this.data.status = "STOP PEDALING";
+                            break;
+                        default: break;
+                    }
+            }
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'parseFitnessMachineStatus()', error: err.message | err, stack: err.stack });
         }
         return Object.assign(Object.assign({}, this.data), { raw: `2ada:${data.toString('hex')}` });
     }
@@ -298,6 +344,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
                     const fitnessMachine = buffer.readUInt32LE(0);
                     const targetSettings = buffer.readUInt32LE(4);
                     this.features = { fitnessMachine, targetSettings };
+                    this.logEvent({ message: 'supported Features: ', fatures: this.features });
                 }
             }
             catch (err) {
@@ -306,7 +353,9 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         });
     }
     onData(characteristic, data) {
-        super.onData(characteristic, data);
+        const hasData = super.onData(characteristic, data);
+        if (!hasData)
+            return false;
         const uuid = characteristic.toLocaleLowerCase();
         let res = undefined;
         switch (uuid) {
@@ -326,8 +375,11 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
             default:
                 break;
         }
-        if (res)
+        if (res) {
             this.emit('data', res);
+            return false;
+        }
+        return true;
     }
     writeFtmsMessage(requestedOpCode, data, props) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -486,6 +538,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) {

package/lib/ble/hrm.d.ts

@@ -14,13 +14,14 @@ 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);
     getProfile(): string;
     getServiceUUids(): string[];
     parseHrm(_data: Uint8Array): HrmData;
-    onData(characteristic: string, data: Buffer): void;
+    onData(characteristic: string, data: Buffer): boolean;
 }
 export declare class HrmAdapter extends DeviceAdapter {
     device: BleHrmDevice;

package/lib/ble/hrm.js

@@ -51,19 +51,21 @@ class BleHrmDevice extends ble_device_1.BleDevice {
         return { heartrate, rr, raw: data.toString('hex') };
     }
     onData(characteristic, data) {
-        super.onData(characteristic, data);
-        const isDuplicate = this.checkForDuplicate(characteristic, data);
-        if (isDuplicate)
+        const hasData = super.onData(characteristic, data);
+        if (!hasData)
             return;
         if (characteristic.toLocaleLowerCase() === '2a37') {
             const res = this.parseHrm(data);
             this.emit('data', res);
+            return false;
         }
+        return true;
     }
 }
 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;
@@ -42,7 +43,7 @@ export default class BleCyclingPowerDevice extends BleDevice {
         time: any;
     };
     parsePower(_data: Uint8Array): PowerData;
-    onData(characteristic: string, data: Buffer): void;
+    onData(characteristic: string, data: Buffer): boolean;
     reset(): void;
 }
 export declare class PwrAdapter extends DeviceAdapter {
@@ -71,6 +72,7 @@ export declare class PwrAdapter extends DeviceAdapter {
     getDisplayName(): string;
     getCyclingMode(): CyclingMode;
     getDefaultCyclingMode(): CyclingMode;
+    getSupportedCyclingModes(): any[];
     getPort(): string;
     getWeight(): number;
     setIgnoreBike(ignore: any): void;

package/lib/ble/pwr.js

@@ -34,6 +34,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PwrAdapter = void 0;
 const ble_device_1 = require("./ble-device");
 const ble_interface_1 = __importDefault(require("./ble-interface"));
+const ble_1 = require("./ble");
 const Device_1 = __importStar(require("../Device"));
 const gd_eventlog_1 = require("gd-eventlog");
 const consts_1 = require("./consts");
@@ -138,14 +139,15 @@ class BleCyclingPowerDevice extends ble_device_1.BleDevice {
         return { instantaneousPower, balance, accTorque, rpm, time, raw: `2a63:${data.toString('hex')}` };
     }
     onData(characteristic, data) {
-        super.onData(characteristic, data);
-        const isDuplicate = this.checkForDuplicate(characteristic, data);
-        if (isDuplicate)
-            return;
-        if (characteristic.toLocaleLowerCase() === consts_1.CSP_MEASUREMENT) {
+        const hasData = super.onData(characteristic, data);
+        if (!hasData)
+            return false;
+        if ((0, ble_1.matches)(characteristic, consts_1.CSP_MEASUREMENT)) {
             const res = this.parsePower(data);
             this.emit('data', res);
+            return false;
         }
+        return true;
     }
     reset() {
         this.instantaneousPower = undefined;
@@ -161,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) {
@@ -201,6 +204,9 @@ class PwrAdapter extends Device_1.default {
     getDefaultCyclingMode() {
         return new power_meter_1.default(this);
     }
+    getSupportedCyclingModes() {
+        return [power_meter_1.default];
+    }
     getPort() {
         return 'ble';
     }

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;
@@ -63,7 +64,7 @@ export default class TacxAdvancedFitnessMachineDevice extends BleFitnessMachineD
     parseTrainerData(data: Buffer): BleFeBikeData;
     parseProductInformation(data: Buffer): BleFeBikeData;
     parseFECMessage(_data: Buffer): BleFeBikeData;
-    onData(characteristic: string, data: Buffer): any;
+    onData(characteristic: string, data: Buffer): boolean;
     getChecksum(message: any[]): number;
     buildMessage(payload?: number[], msgID?: number): Buffer;
     sendMessage(message: Buffer): Promise<boolean>;

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) {
@@ -164,10 +163,10 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
         return { rpm, time: this.timeOffset + c.time };
     }
     parseCSC(_data, logOnly = false) {
-        this.logEvent({ message: 'BLE CSC message', data: _data.toString('hex') });
+        const data = Buffer.from(_data);
+        this.logEvent({ message: 'BLE CSC message', data: data.toString('hex') });
         if (logOnly)
             return this.data;
-        const data = Buffer.from(_data);
         let offset = 0;
         const flags = data.readUInt8(offset);
         offset++;
@@ -187,10 +186,10 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
         return this.data;
     }
     parsePower(_data, logOnly = false) {
-        this.logEvent({ message: 'BLE CSP message', data: _data.toString('hex') });
+        const data = Buffer.from(_data);
+        this.logEvent({ message: 'BLE CSP message', data: data.toString('hex') });
         if (logOnly)
             return this.data;
-        const data = Buffer.from(_data);
         try {
             let offset = 4;
             const flags = data.readUInt16LE(0);
@@ -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;
@@ -70,7 +71,7 @@ export default class WahooAdvancedFitnessMachineDevice extends BleFitnessMachine
         time: any;
     };
     parsePower(_data: Buffer): IndoorBikeData;
-    onData(characteristic: string, data: Buffer): void;
+    onData(characteristic: string, data: Buffer): boolean;
     writeWahooFtmsMessage(requestedOpCode: number, data: Buffer, props?: BleWriteProps): Promise<boolean>;
     requestControl(): Promise<boolean>;
     setPowerAdjusting(): void;

package/lib/ble/wahoo-kickr.js

@@ -170,7 +170,9 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
         return { instantaneousPower, cadence, time, raw: data.toString('hex') };
     }
     onData(characteristic, data) {
-        super.onData(characteristic, data);
+        const hasData = super.onData(characteristic, data);
+        if (!hasData)
+            return false;
         const uuid = characteristic.toLowerCase();
         let res = undefined;
         switch (uuid) {
@@ -190,8 +192,11 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
                 this.logEvent({ message: 'data', uuid, data: data.toString('hex') });
                 break;
         }
-        if (res)
+        if (res) {
             this.emit('data', res);
+            return false;
+        }
+        return true;
     }
     writeWahooFtmsMessage(requestedOpCode, data, props) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -419,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/package.json

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