incyclist-devices 1.4.64 → 1.4.67

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

@@ -30,6 +30,7 @@ export declare abstract class BleDevice extends BleDeviceClass {
     logEvent(event: any): void;
     setLogger(logger: EventLogger): void;
     setInterface(ble: BleInterfaceClass): void;
+    isMatching(characteristics: string[]): boolean;
     cleanupListeners(): void;
     onDisconnect(): void;
     waitForConnectFinished(timeout: any): Promise<unknown>;

package/lib/ble/ble-device.js

@@ -47,7 +47,9 @@ class BleDevice extends ble_1.BleDeviceClass {
         if (this.logger) {
             this.logger.logEvent(event);
         }
-        console.log('~~~BLE:', event);
+        if (process.env.BLE_DEBUG) {
+            console.log('~~~BLE:', event);
+        }
     }
     setLogger(logger) {
         this.logger = logger;
@@ -55,6 +57,9 @@ class BleDevice extends ble_1.BleDeviceClass {
     setInterface(ble) {
         this.ble = ble;
     }
+    isMatching(characteristics) {
+        return true;
+    }
     cleanupListeners() {
         if (this.characteristics === undefined) {
             this.characteristics = [];
@@ -244,7 +249,6 @@ class BleDevice extends ble_1.BleDeviceClass {
             if (writeIdx !== -1) {
                 const writeItem = this.writeQueue[writeIdx];
                 this.writeQueue.splice(writeIdx, 1);
-                console.log('~~~ write queue', this.writeQueue);
                 if (writeItem.resolve)
                     writeItem.resolve(data);
             }
@@ -255,9 +259,9 @@ class BleDevice extends ble_1.BleDeviceClass {
             try {
                 const connector = this.ble.getConnector(this.peripheral);
                 const isAlreadySubscribed = connector.isSubscribed(characteristicUuid);
-                console.log('~~~ write ', characteristicUuid, data.toString('hex'), isAlreadySubscribed, this.subscribedCharacteristics);
                 if (!withoutResponse && !isAlreadySubscribed) {
                     const connector = this.ble.getConnector(this.peripheral);
+                    connector.removeAllListeners(characteristicUuid);
                     connector.on(characteristicUuid, (uuid, data) => {
                         this.onData(uuid, data);
                     });
@@ -282,12 +286,11 @@ class BleDevice extends ble_1.BleDeviceClass {
                         let messageDeleted = false;
                         this.writeQueue.push({ uuid: characteristicUuid.toLocaleLowerCase(), data, resolve, reject });
                         const to = setTimeout(() => {
-                            console.log('~~~ write timeout');
                             if (this.writeQueue.length > writeId && !messageDeleted)
                                 this.writeQueue.splice(writeId, 1);
                             this.logEvent({ message: 'writing response', err: 'timeout' });
                             reject(new Error('timeout'));
-                        }, 1000);
+                        }, 5000);
                         this.logEvent({ message: 'writing' });
                         characteristic.write(data, withoutResponse, (err) => {
                             clearTimeout(to);

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

@@ -77,6 +77,7 @@ export default class BleInterface extends BleInterfaceClass {
     getDeviceClasses(peripheral: any, props?: {
         deviceTypes?: (typeof BleDeviceClass)[];
         profile?: string;
+        services?: string[];
     }): (typeof BleDeviceClass)[];
     createDevice(DeviceClass: (typeof BleDeviceClass), peripheral: BlePeripheral, characteristics?: BleCharacteristic[]): any;
     connectDevice(requested: BleDeviceClass | BleDeviceDescription, timeout?: number): Promise<BleDeviceClass>;

package/lib/ble/ble-interface.js

@@ -336,13 +336,13 @@ class BleInterface extends ble_1.BleInterfaceClass {
     }
     getDeviceClasses(peripheral, props = {}) {
         let DeviceClasses;
-        const { deviceTypes, profile } = props;
+        const { deviceTypes, profile, services = peripheral.advertisement.serviceUuids } = props;
         if ((!deviceTypes || deviceTypes.length === 0)) {
             const classes = BleInterface.deviceClasses.map(c => c.Class);
-            DeviceClasses = this.getDevicesFromServices(classes, peripheral.advertisement.serviceUuids);
+            DeviceClasses = this.getDevicesFromServices(classes, services);
         }
         else {
-            DeviceClasses = this.getDevicesFromServices(deviceTypes, peripheral.advertisement.serviceUuids);
+            DeviceClasses = this.getDevicesFromServices(deviceTypes, services);
         }
         if (profile && DeviceClasses && DeviceClasses.length > 0) {
             DeviceClasses = DeviceClasses.filter(C => {
@@ -355,15 +355,26 @@ class BleInterface extends ble_1.BleInterfaceClass {
         return DeviceClasses;
     }
     createDevice(DeviceClass, peripheral, characteristics) {
-        this.logEvent({ message: 'trying to create device', peripheral: peripheral.address, characteristics });
-        const C = DeviceClass;
-        const device = new C({ peripheral });
-        const existingDevice = this.devices.find(i => i.device.id === device.id && i.device.getProfile() === device.getProfile());
-        if (existingDevice)
-            return existingDevice;
-        device.setInterface(this);
-        device.characteristics = characteristics;
-        return device;
+        try {
+            const C = DeviceClass;
+            const device = new C({ peripheral });
+            const cids = characteristics ? characteristics.map(c => (0, ble_1.uuid)(c.uuid)) : [];
+            this.logEvent({ message: 'trying to create device', peripheral: peripheral.address, characteristics: cids, profile: device.getProfile() });
+            const existingDevice = this.devices.find(i => i.device.id === device.id && i.device.getProfile() === device.getProfile());
+            if (existingDevice)
+                return existingDevice;
+            device.setInterface(this);
+            if (characteristics && device.isMatching(cids)) {
+                device.characteristics = characteristics;
+                return device;
+            }
+            else {
+                this.logEvent({ message: 'failed to create device', peripheral: peripheral.address, profile: device.getProfile() });
+            }
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', fn: '', error: err.message || err, stack: err.stack });
+        }
     }
     connectDevice(requested, timeout = DEFAULT_SCAN_TIMEOUT + CONNECT_TIMEOUT) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -540,8 +551,8 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     if (fromCache)
                         this.logEvent({ message: 'adding from Cache', peripheral: peripheral.address });
                     else {
-                        const { id, name, address } = peripheral;
-                        this.logEvent({ message: 'BLE scan: found device', peripheral: { id, name, address } });
+                        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;
@@ -552,7 +563,13 @@ class BleInterface extends ble_1.BleInterfaceClass {
                         return;
                     peripheralsProcessed.push(peripheral.address);
                     const characteristics = yield this.getCharacteristics(peripheral);
-                    const DeviceClasses = this.getDeviceClasses(peripheral, { profile });
+                    const connector = this.getConnector(peripheral);
+                    const connectedServices = connector.getServices();
+                    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 });
+                    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)
@@ -560,6 +577,8 @@ class BleInterface extends ble_1.BleInterfaceClass {
                         if (scanForDevice && cntFound > 0)
                             return;
                         const d = this.createDevice(DeviceClass, peripheral, characteristics);
+                        if (!d)
+                            return;
                         yield d.connect();
                         if (scanForDevice) {
                             if ((id && id !== '' && d.id === id) ||

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

@@ -32,4 +32,5 @@ export default class BlePeripheralConnector {
     getState(): string;
     getCharachteristics(): BleCharacteristic[];
     getServices(): string[];
+    getPeripheral(): BlePeripheral;
 }

package/lib/ble/ble-peripheral.js

@@ -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* () {
@@ -110,7 +112,6 @@ class BlePeripheralConnector {
                             try {
                                 yield this.subscribe(c.uuid);
                                 subscribed.push(c.uuid);
-                                this.state.subscribed.push(c.uuid);
                             }
                             catch (err) {
                                 this.logEvent({ message: 'cannot subscribe', peripheral: this.peripheral.address, characteristic: c.uuid, error: err.message || err });
@@ -137,6 +138,7 @@ class BlePeripheralConnector {
                     reject(new Error('Characteristic not found'));
                     return;
                 }
+                characteristic.removeAllListeners('data');
                 characteristic.on('data', (data, _isNotification) => {
                     this.onData(characteristicUuid, data);
                 });
@@ -149,8 +151,10 @@ class BlePeripheralConnector {
                     this.logEvent({ message: 'subscribe result', characteristic: characteristicUuid, error: err });
                     if (err)
                         reject(err);
-                    else
+                    else {
+                        this.state.subscribed.push(characteristicUuid);
                         resolve(true);
+                    }
                 });
             }
             catch (err) {
@@ -181,5 +185,8 @@ class BlePeripheralConnector {
     getServices() {
         return this.services;
     }
+    getPeripheral() {
+        return this.peripheral;
+    }
 }
 exports.default = BlePeripheralConnector;

package/lib/ble/fm.d.ts

@@ -52,6 +52,7 @@ export default class BleFitnessMachineDevice extends BleDevice {
     windSpeed: number;
     wheelSize: number;
     constructor(props?: any);
+    isMatching(characteristics: string[]): boolean;
     init(): Promise<boolean>;
     onDisconnect(): void;
     getProfile(): string;

package/lib/ble/fm.js

@@ -21,6 +21,8 @@ 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 FTMS_CP = '2ad9';
+const FTMS_STATUS = '2ada';
+const INDOOR_BIKE_DATA = '2ad2';
 const cwABike = {
     race: 0.35,
     triathlon: 0.29,
@@ -94,12 +96,37 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         this.wheelSize = 2100;
         this.data = {};
     }
+    isMatching(characteristics) {
+        if (!characteristics)
+            return false;
+        const hasStatus = characteristics.find(c => c === FTMS_STATUS) !== undefined;
+        const hasCP = characteristics.find(c => c === FTMS_CP) !== undefined;
+        const hasIndoorBike = characteristics.find(c => c === INDOOR_BIKE_DATA) !== undefined;
+        return hasStatus && hasCP && hasIndoorBike;
+    }
     init() {
         const _super = Object.create(null, {
             init: { get: () => super.init }
         });
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                const connector = this.ble.getConnector(this.peripheral);
+                const isAlreadySubscribed = connector.isSubscribed(FTMS_CP);
+                if (!isAlreadySubscribed) {
+                    connector.removeAllListeners(FTMS_CP);
+                    let prev = undefined;
+                    let prevTS = undefined;
+                    connector.on(FTMS_CP, (uuid, data) => {
+                        const message = data.toString('hex');
+                        if (prevTS && prev && message === prev && Date.now() - prevTS < 500) {
+                            return;
+                        }
+                        prevTS = Date.now();
+                        prev = message;
+                        this.onData(uuid, data);
+                    });
+                    yield connector.subscribe(FTMS_CP);
+                }
                 this.logEvent({ message: 'get device info' });
                 yield _super.init.call(this);
                 yield this.getFitnessMachineFeatures();
@@ -278,13 +305,13 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         const uuid = characteristic.toLocaleLowerCase();
         let res = undefined;
         switch (uuid) {
-            case '2ad2':
+            case INDOOR_BIKE_DATA:
                 res = this.parseIndoorBikeData(data);
                 break;
             case '2a37':
                 res = this.parseHrm(data);
                 break;
-            case '2ada':
+            case FTMS_STATUS:
                 res = this.parseFitnessMachineStatus(data);
                 break;
             case '2a63':
@@ -452,7 +479,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
 }
 exports.default = BleFitnessMachineDevice;
 BleFitnessMachineDevice.services = ['1826'];
-BleFitnessMachineDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada'];
+BleFitnessMachineDevice.characteristics = ['2acc', INDOOR_BIKE_DATA, '2ad6', '2ad8', FTMS_CP, FTMS_STATUS];
 ble_interface_1.default.register('BleFitnessMachineDevice', 'fm', BleFitnessMachineDevice, BleFitnessMachineDevice.services);
 class FmAdapter extends Device_1.default {
     constructor(device, protocol) {

package/lib/ble/pwr.d.ts

@@ -33,6 +33,7 @@ export default class BleCyclingPowerDevice extends BleDevice {
     currentCrankData: CrankData;
     prevCrankData: CrankData;
     constructor(props?: any);
+    isMatching(characteristics: string[]): boolean;
     init(): Promise<boolean>;
     getProfile(): string;
     getServiceUUids(): string[];

package/lib/ble/pwr.js

@@ -37,6 +37,8 @@ const ble_interface_1 = __importDefault(require("./ble-interface"));
 const Device_1 = __importStar(require("../Device"));
 const gd_eventlog_1 = require("gd-eventlog");
 const power_meter_1 = __importDefault(require("../modes/power-meter"));
+const CP_MEASUREMENT = '2a63';
+const CP_FEATURE = '2a65';
 class BleCyclingPowerDevice extends ble_device_1.BleDevice {
     constructor(props) {
         super(props);
@@ -49,6 +51,13 @@ class BleCyclingPowerDevice extends ble_device_1.BleDevice {
         this.currentCrankData = undefined;
         this.prevCrankData = undefined;
     }
+    isMatching(characteristics) {
+        if (!characteristics)
+            return false;
+        const hasCPMeasurement = characteristics.find(c => c === CP_MEASUREMENT) !== undefined;
+        const hasCPFeature = characteristics.find(c => c === CP_FEATURE) !== undefined;
+        return hasCPMeasurement && hasCPFeature;
+    }
     init() {
         const _super = Object.create(null, {
             init: { get: () => super.init }
@@ -131,7 +140,7 @@ class BleCyclingPowerDevice extends ble_device_1.BleDevice {
     }
     onData(characteristic, data) {
         super.onData(characteristic, data);
-        if (characteristic.toLocaleLowerCase() === '2a63') {
+        if (characteristic.toLocaleLowerCase() === CP_MEASUREMENT) {
             const res = this.parsePower(data);
             this.emit('data', res);
         }
@@ -149,7 +158,7 @@ class BleCyclingPowerDevice extends ble_device_1.BleDevice {
 }
 exports.default = BleCyclingPowerDevice;
 BleCyclingPowerDevice.services = ['1818'];
-BleCyclingPowerDevice.characteristics = ['2a63', '2a65', '2a5d', '2a3c'];
+BleCyclingPowerDevice.characteristics = [CP_MEASUREMENT, CP_FEATURE, '2a5d', '2a3c'];
 ble_interface_1.default.register('BleCyclingPowerDevice', 'cp', BleCyclingPowerDevice, BleCyclingPowerDevice.services);
 class PwrAdapter extends Device_1.default {
     constructor(device, protocol) {

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

@@ -35,6 +35,7 @@ export default class WahooAdvancedFitnessMachineDevice extends BleFitnessMachine
     timeOffset: number;
     tsPrevWrite: any;
     constructor(props?: any);
+    isMatching(characteristics: string[]): boolean;
     init(): Promise<boolean>;
     getProfile(): string;
     getServiceUUids(): string[];

package/lib/ble/wahoo-kickr.js

@@ -36,7 +36,7 @@ const ble_interface_1 = __importDefault(require("./ble-interface"));
 const Device_1 = require("../Device");
 const gd_eventlog_1 = require("gd-eventlog");
 const fm_1 = __importStar(require("./fm"));
-const WAHOO_ADVANCED_FTMS = 'a026e005';
+const WAHOO_ADVANCED_FTMS = 'a026e00b';
 const WAHOO_ADVANCED_TRAINER_CP = 'a026e037';
 const cwABike = {
     race: 0.35,
@@ -54,12 +54,35 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
         this.tsPrevWrite = undefined;
         this.data = {};
     }
+    isMatching(characteristics) {
+        if (!characteristics)
+            return false;
+        const hasWahooCP = characteristics.find(c => c === WAHOO_ADVANCED_TRAINER_CP) !== undefined;
+        return hasWahooCP;
+    }
     init() {
         const _super = Object.create(null, {
             init: { get: () => super.init }
         });
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                const connector = this.ble.getConnector(this.peripheral);
+                const isAlreadySubscribed = connector.isSubscribed(WAHOO_ADVANCED_TRAINER_CP);
+                if (!isAlreadySubscribed) {
+                    connector.removeAllListeners(WAHOO_ADVANCED_TRAINER_CP);
+                    let prev = undefined;
+                    let prevTS = undefined;
+                    connector.on(WAHOO_ADVANCED_TRAINER_CP, (uuid, data) => {
+                        const message = data.toString('hex');
+                        if (prevTS && prev && message === prev && Date.now() - prevTS < 500) {
+                            return;
+                        }
+                        prevTS = Date.now();
+                        prev = message;
+                        this.onData(uuid, data);
+                    });
+                    yield connector.subscribe(WAHOO_ADVANCED_TRAINER_CP);
+                }
                 this.logEvent({ message: 'get device info' });
                 yield _super.init.call(this);
                 this.logEvent({ message: 'device info', deviceInfo: this.deviceInfo, features: this.features });
@@ -298,7 +321,7 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
 }
 exports.default = WahooAdvancedFitnessMachineDevice;
 WahooAdvancedFitnessMachineDevice.services = ['a026ee0b'];
-WahooAdvancedFitnessMachineDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada', WAHOO_ADVANCED_FTMS, WAHOO_ADVANCED_TRAINER_CP];
+WahooAdvancedFitnessMachineDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada', WAHOO_ADVANCED_TRAINER_CP];
 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.64",
+  "version": "1.4.67",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",