incyclist-devices 1.4.94 → 1.4.95

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) {
@@ -566,8 +568,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 +587,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

@@ -101,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) {
@@ -185,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'))
@@ -539,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,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/package.json

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